@davesheffer/hunch 1.18.1 → 1.19.0

package/dist/core/delivery.js

@@ -13,6 +13,15 @@ import { pathMatchesGlob, pathsRelated } from "./glob.js";
 import { toPosixTarget } from "./paths.js";
 import { renderGrounding } from "./topics.js";
 const SEVERITY = { advisory: 1, warning: 2, blocking: 3, low: 1, medium: 2, high: 3, critical: 4 };
+const MIN_ADVISORY_CONFIDENCE = 0.5;
+const MIN_UNCONDITIONED_CONFIDENCE = 0.7;
+const MAX_ACTIONABLE_HYPOTHESES = 2;
+const TASK_STOP_WORDS = new Set([
+    "a", "an", "and", "are", "as", "at", "be", "been", "but", "by", "can", "does", "for", "from",
+    "has", "have", "in", "into", "is", "it", "its", "of", "on", "or", "that", "the", "this", "to",
+    "use", "uses", "using", "was", "when", "where", "which", "while", "with", "without",
+    "bug", "fix", "issue", "problem",
+]);
 function clipHeadline(value, max) {
     const flat = value.replace(/\s+/g, " ").trim();
     if (flat.length <= max)
@@ -29,6 +38,217 @@ function sourceTier(source) {
         return "model";
     return source || "unknown";
 }
+function stemToken(token) {
+    if (!/^[a-z0-9]+$/.test(token))
+        return token;
+    if (token.endsWith("ies") && token.length > 5)
+        return `${token.slice(0, -3)}y`;
+    for (const suffix of ["ing", "ed"]) {
+        if (token.endsWith(suffix) && token.length - suffix.length >= 4) {
+            const base = token.slice(0, -suffix.length);
+            if (base.endsWith("s") && !base.endsWith("ss"))
+                return `${base}e`;
+            return base;
+        }
+    }
+    if (/(?:sses|xes|zes|ches|shes)$/.test(token) && token.length > 5)
+        return token.slice(0, -2);
+    if (token.endsWith("s") && !token.endsWith("ss") && token.length > 4)
+        return token.slice(0, -1);
+    return token;
+}
+function lexicalTokens(value) {
+    const expanded = value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase();
+    const words = expanded.match(/[\p{L}\p{N}]+/gu) ?? [];
+    return new Set(words.map(stemToken).filter((token) => token.length >= 3 && !TASK_STOP_WORDS.has(token)));
+}
+function codeSyntaxTokens(value) {
+    const out = new Set();
+    for (const fragment of value.split(/\s+/)) {
+        // Code-shaped spans identify the API/file nouns without treating every symbol
+        // name anywhere in a large repository as a noun. The latter erased ordinary
+        // evidence words such as "empty" and "throws" in real task phrases.
+        if (!/[.$()[\]`/\\_:<>]/.test(fragment))
+            continue;
+        for (const token of lexicalTokens(fragment))
+            out.add(token);
+    }
+    return out;
+}
+/** Separate task evidence (symptoms/expected behavior) from code nouns. A file,
+ * symbol, or API noun proves scope, not that a prescriptive decision answers the
+ * current problem. Low-authority memory must match the evidence terms too. */
+function queryProfile(target, options) {
+    const normalized = toPosixTarget(target.trim());
+    const exactSymbol = (options.symbols ?? []).some((symbol) => symbol.id === normalized || symbol.name === normalized || symbol.file === normalized || pathsRelated(symbol.file, normalized));
+    const exactComponent = (options.components ?? []).some((component) => component.id === normalized);
+    const hasWhitespace = /\s/.test(normalized);
+    const pathLike = !hasWhitespace && (normalized.includes("/") || /\.[a-z0-9]{1,8}$/i.test(normalized));
+    const taskPhrase = !exactSymbol && !exactComponent && !pathLike && hasWhitespace;
+    const allTerms = lexicalTokens(normalized);
+    if (!taskPhrase)
+        return { taskPhrase, evidenceTerms: new Set(), allTerms };
+    const codeTerms = codeSyntaxTokens(normalized);
+    const evidenceTerms = new Set([...allTerms].filter((token) => !codeTerms.has(token)));
+    return { taskPhrase, evidenceTerms, allTerms };
+}
+function decisionRecordTerms(decision) {
+    return lexicalTokens([
+        decision.title,
+        decision.context,
+        decision.decision,
+        ...decision.consequences,
+        ...decision.alternatives_rejected,
+        ...decision.related_files,
+        ...decision.related_components,
+    ].join(" "));
+}
+/** Ranking uses only the record's claim, not consequences or path metadata.
+ * Otherwise prose such as "the test moved away from tuple" can falsely make an
+ * unrelated lazy-schema decision look tuple-specific. */
+function decisionPrimaryTerms(decision) {
+    return lexicalTokens([decision.title, decision.context, decision.decision].join(" "));
+}
+function decisionEvidenceMatches(decision, query) {
+    const recordTerms = decisionPrimaryTerms(decision);
+    return [...query.evidenceTerms].filter((term) => recordTerms.has(term));
+}
+function decisionHypothesis(decision, matches, target) {
+    const files = decision.related_files.filter(isSafeDeliveryAnchor).slice(0, 3);
+    const components = decision.related_components.slice(0, Math.max(0, 3 - files.length)).map((id) => `component:${id}`);
+    const where = [...files, ...components];
+    const location = where.length ? where.join(", ") : "an unanchored record";
+    const why = matches.length
+        ? `Matches task evidence (${matches.join(", ")}) and is anchored to ${location}.`
+        : `No symptom-term overlap was found; it is included because its authority/confidence passed delivery and its recorded scope is ${location}. Treat it as a hypothesis, not proof.`;
+    const consequences = decision.consequences.slice(0, 2).join("; ");
+    const pattern = clipHeadline(`${decision.decision || decision.title}${consequences ? ` Expected outcomes: ${consequences}` : ""}`, 420);
+    const historicalPattern = decision.commit
+        ? `Commit ${decision.commit}: ${pattern}`
+        : `Recorded decision (no fix commit attached): ${pattern}`;
+    const evidence = decision.provenance.evidence.map((item) => clipHeadline(item, 120)).filter(Boolean).slice(0, 2);
+    const conformance = decision.conformance?.[0];
+    const premise = decision.premises?.[0];
+    const reproduction = clipHeadline(target, 180);
+    let verify;
+    const safeCommit = decision.commit && /^[0-9a-f]{7,64}$/i.test(decision.commit) ? decision.commit : null;
+    const diffPaths = files.filter((file) => /^[a-zA-Z0-9._/-]+$/.test(file)).slice(0, 2);
+    if (safeCommit) {
+        const scoped = diffPaths.length ? ` -- ${diffPaths.join(" ")}` : "";
+        verify = `Inspect the recorded change before editing: git show --stat --oneline ${safeCommit}${scoped}; then git show ${safeCommit}${scoped}. Compare that diff with the current code, then reproduce: ${reproduction}.`;
+    }
+    else if (evidence.length) {
+        verify = `Check recorded evidence (${evidence.join("; ")}), then reproduce: ${reproduction}.`;
+    }
+    else if (conformance) {
+        verify = `Check whether ${conformance.subject} ${conformance.assert}${conformance.object ? ` ${conformance.object}` : ""}${conformance.transitive ? " transitively" : ""}, then reproduce: ${reproduction}.`;
+    }
+    else if (premise) {
+        verify = `Check the recorded premise (${clipHeadline(premise.claim, 150)}), then reproduce: ${reproduction}.`;
+    }
+    else {
+        verify = `Reproduce: ${reproduction}. Inspect ${location} and run the narrowest existing test that exercises that path before changing code.`;
+    }
+    const disprove = where.length
+        ? `Reject this hypothesis if the reproduction does not execute ${location}, or if checking the recorded pattern leaves the observed failure unchanged.`
+        : "Reject this hypothesis if the smallest reproduction contradicts the recorded pattern or passes without it.";
+    const obligations = [];
+    if (safeCommit) {
+        obligations.push({
+            id: `${decision.id}:inspect:${safeCommit.slice(0, 12)}`,
+            origin: "memory",
+            category: "evidence",
+            phase: "session",
+            description: `Inspect recorded commit ${safeCommit.slice(0, 12)} and compare it with the current code.`,
+            command_alternatives: [["git", "show", safeCommit.slice(0, 7)]],
+            expected: { success: true, output_includes: [safeCommit.slice(0, 7)] },
+        });
+    }
+    const testPath = decision.provenance.evidence
+        .flatMap((item) => item.match(/[A-Za-z0-9_.\/-]+\.(?:test|spec)\.[cm]?[jt]sx?/gi) ?? [])
+        .find((item) => isSafeDeliveryAnchor(item));
+    if (testPath) {
+        obligations.push({
+            id: `${decision.id}:proof:${testPath.replace(/[^A-Za-z0-9._-]/g, "_").slice(-60)}`,
+            origin: "memory",
+            category: "behavior",
+            phase: "after-edit",
+            description: `Re-run the recorded proof ${testPath} after the latest product edit.`,
+            command_alternatives: [
+                ["vitest", testPath],
+                ["jest", testPath],
+                ["pytest", testPath],
+                ["tsx", "--test", testPath],
+                ["node", "--test", testPath],
+                ["npm", "test", testPath],
+            ],
+            expected: { success: true },
+        });
+    }
+    return {
+        kind: "decision",
+        record_id: decision.id,
+        why,
+        where,
+        historical_pattern: historicalPattern,
+        verify,
+        disprove,
+        obligations,
+    };
+}
+function renderHypothesis(hypothesis, provenance, source) {
+    const lines = [
+        `${hypothesis.record_id} | hypothesis/decision | ${sourceTier(source)}/${provenance} | hunch_why("${hypothesis.record_id}")`,
+        `  why: ${hypothesis.why}`,
+        `  where: ${hypothesis.where.join(", ") || "unanchored"}`,
+        `  historical pattern: ${hypothesis.historical_pattern}`,
+        `  verify: ${hypothesis.verify}`,
+        `  disprove: ${hypothesis.disprove}`,
+    ];
+    if (hypothesis.obligations.length) {
+        lines.push(`  controller: ${hypothesis.obligations.map((item) => `${item.id} [${item.category}/${item.phase}] ${item.description}`).join("; ")}`);
+    }
+    return lines.join("\n  ");
+}
+function decisionAbstention(decision, query) {
+    const source = decision.provenance.source ?? "";
+    if (source.split("+").includes("human_confirmed"))
+        return null;
+    const confidence = decision.provenance.confidence ?? 0;
+    if (confidence < MIN_ADVISORY_CONFIDENCE) {
+        return {
+            reason: "low-confidence",
+            detail: `non-human decision confidence ${confidence.toFixed(2)} is below the ${MIN_ADVISORY_CONFIDENCE.toFixed(2)} delivery floor`,
+        };
+    }
+    if (confidence >= MIN_UNCONDITIONED_CONFIDENCE)
+        return null;
+    if (!query.taskPhrase || !query.evidenceTerms.size) {
+        return {
+            reason: "insufficient-context",
+            detail: "low-authority prescriptive memory needs a task phrase with symptoms or expected behavior, not only a file/symbol/API target",
+        };
+    }
+    const recordTerms = decisionRecordTerms(decision);
+    const evidenceOverlap = [...query.evidenceTerms].filter((term) => recordTerms.has(term)).length;
+    const allOverlap = [...query.allTerms].filter((term) => recordTerms.has(term)).length;
+    const requiredEvidence = Math.max(1, Math.ceil(query.evidenceTerms.size * 0.4));
+    if (evidenceOverlap < requiredEvidence || allOverlap / Math.max(1, query.allTerms.size) < 0.2) {
+        return {
+            reason: "low-relevance",
+            detail: `weak task-evidence match (${evidenceOverlap}/${query.evidenceTerms.size} symptom terms; ${allOverlap}/${query.allTerms.size} total terms) for confidence ${confidence.toFixed(2)}`,
+        };
+    }
+    return null;
+}
+function emptyAbstention() {
+    return {
+        active: false,
+        withheld: 0,
+        reasons: { "low-confidence": 0, "insufficient-context": 0, "low-relevance": 0 },
+        retry_hint: null,
+    };
+}
 function isSafeDeliveryAnchor(value) {
     const path = toPosixTarget(value);
     const segments = path.split("/");
@@ -149,6 +369,7 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
         ?? (options.root ? localCommitReachability(options.root) : (() => "unknown"));
     const canValidateAnchors = options.root !== undefined || options.symbols !== undefined || options.components !== undefined;
     const candidates = [];
+    const query = queryProfile(ctx.target, options);
     for (const constraint of ctx.constraints) {
         const retired = !options.historical && (constraint.status === "retired" || constraint.valid_to != null);
         const validation = validationState(constraint.scope, (anchor) => anchorResolves(anchor, ctx.target, options), undefined, reachability, false, canValidateAnchors);
@@ -169,6 +390,9 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
         const validation = validationState([...fileAnchors, ...componentAnchors], (anchor) => fileAnchors.includes(anchor)
             ? anchorResolves(anchor, ctx.target, options)
             : componentResolves(anchor, ctx.target, options), decision.commit, reachability, true, canValidateAnchors);
+        const abstention = decisionAbstention(decision, query);
+        const relevanceTerms = query.taskPhrase ? decisionEvidenceMatches(decision, query) : undefined;
+        const hypothesis = query.taskPhrase ? decisionHypothesis(decision, relevanceTerms ?? [], ctx.target) : undefined;
         candidates.push({
             ref: { kind: "decisions", record_id: decision.id },
             mandatory: false,
@@ -176,7 +400,13 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
             provenance: validation.state,
             staleDetail: validation.detail,
             retiredDetail: retired ? `decision is ${decision.status} at HEAD` : undefined,
-            line: `${decision.id} | decision/${decision.status} | ${clipHeadline(`${decision.title}: ${decision.decision}`, 220)} | scope ${clipHeadline(decision.related_files.join(", ") || decision.related_components.join(", ") || "unanchored", 100)} | ${sourceTier(decision.provenance.source)}/${validation.state} | hunch_why("${decision.id}")`,
+            abstainReason: abstention?.reason,
+            abstainDetail: abstention?.detail,
+            hypothesis,
+            relevanceTerms,
+            line: hypothesis
+                ? renderHypothesis(hypothesis, validation.state, decision.provenance.source)
+                : `${decision.id} | decision/${decision.status} | ${clipHeadline(`${decision.title}: ${decision.decision}`, 220)} | scope ${clipHeadline(decision.related_files.join(", ") || decision.related_components.join(", ") || "unanchored", 100)} | ${sourceTier(decision.provenance.source)}/${validation.state} | hunch_why("${decision.id}")`,
         });
     }
     for (const bug of ctx.bugs) {
@@ -218,7 +448,7 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
     if (!hasAnything) {
         const empty = `# Hunch context for "${ctx.target}"\n\n(No recorded constraints/decisions/bugs for this target yet — Hunch is still learning it.)\n`;
         const text = fitText(empty, cap);
-        return { text, delivered: [], supplements: [], omitted: [], budget_tokens: budget, used_chars: charCount(text), blocking_overflow: false };
+        return { text, delivered: [], hypotheses: [], obligations: [], supplements: [], omitted: [], budget_tokens: budget, used_chars: charCount(text), blocking_overflow: false, abstention: emptyAbstention() };
     }
     const omitted = [];
     const eligible = [];
@@ -231,18 +461,64 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
             omitted.push({ ...candidate.ref, reason: "stale-provenance", detail: candidate.staleDetail ?? "provenance is stale" });
             continue;
         }
+        if (candidate.abstainReason && !candidate.mandatory && candidate.ref) {
+            omitted.push({ ...candidate.ref, reason: candidate.abstainReason, detail: candidate.abstainDetail ?? "delivery confidence gate abstained" });
+            continue;
+        }
         eligible.push(candidate);
     }
+    const hypothesisCandidates = eligible.filter((candidate) => candidate.hypothesis);
+    const documentFrequency = new Map();
+    for (const candidate of hypothesisCandidates) {
+        for (const term of new Set(candidate.relevanceTerms ?? [])) {
+            documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+        }
+    }
+    for (const candidate of hypothesisCandidates) {
+        const rarity = (candidate.relevanceTerms ?? []).reduce((sum, term) => {
+            const frequency = documentFrequency.get(term) ?? hypothesisCandidates.length;
+            return sum + Math.log2((hypothesisCandidates.length + 1) / (frequency + 1)) + 1;
+        }, 0);
+        // Rank specific task evidence (rare across the retrieved candidate set)
+        // above generic verbs such as "parse", "value", and "property".
+        candidate.score += rarity * 10;
+    }
     eligible.sort((left, right) => Number(right.mandatory) - Number(left.mandatory) || right.score - left.score || (left.ref?.record_id ?? left.line).localeCompare(right.ref?.record_id ?? right.line));
-    const recordCandidates = eligible.filter((candidate) => candidate.ref);
-    const structuralCandidates = eligible.filter((candidate) => !candidate.ref);
+    const boundedEligible = [];
+    let actionableHypotheses = 0;
+    for (const candidate of eligible) {
+        if (candidate.hypothesis && candidate.ref) {
+            if (actionableHypotheses >= MAX_ACTIONABLE_HYPOTHESES) {
+                omitted.push({
+                    ...candidate.ref,
+                    reason: "actionability-cap",
+                    detail: `only the top ${MAX_ACTIONABLE_HYPOTHESES} decision hypotheses are delivered; refine the task evidence or inspect this record with hunch_why`,
+                });
+                continue;
+            }
+            actionableHypotheses++;
+        }
+        boundedEligible.push(candidate);
+    }
+    const recordCandidates = boundedEligible.filter((candidate) => candidate.ref);
+    const structuralCandidates = boundedEligible.filter((candidate) => !candidate.ref);
     const lines = [
         `# Hunch context for "${ctx.target}"`,
         "",
-        "## 🧠 Ranked memory (Invariants · Decisions · Bugs · Known findings)",
+        query.taskPhrase
+            ? `## 🧠 Bounded memory (Invariants · max ${MAX_ACTIONABLE_HYPOTHESES} decision hypotheses · Bugs · Known findings)`
+            : "## 🧠 Ranked memory (Invariants · Decisions · Bugs · Known findings)",
     ];
+    if (candidates.some((candidate) => candidate.abstainReason)) {
+        lines.push("Evidence rule: explicit task, repro, and test evidence outranks advisory memory; weak unverified matches are withheld.");
+    }
+    if (query.taskPhrase) {
+        lines.push("Diagnostic loop: before editing, call hunch_context again with the first concrete failing assertion, stack frame, expected behavior, and API/code path you observe.");
+    }
     let text = `${lines.join("\n")}\n`;
     const delivered = [];
+    const hypotheses = [];
+    const obligations = [];
     const supplements = [];
     let blockingOverflow = false;
     for (const [index, candidate] of recordCandidates.entries()) {
@@ -256,6 +532,10 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
                 provenance_status: candidate.provenance,
                 token_cost: estimatedTokens(next),
             });
+            if (candidate.hypothesis) {
+                hypotheses.push({ ...candidate.hypothesis, rank: index + 1 });
+                obligations.push(...candidate.hypothesis.obligations);
+            }
             if (charCount(text) > cap && candidate.mandatory)
                 blockingOverflow = true;
         }
@@ -280,7 +560,11 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
         }
         const next = `- supplemental/${supplement.kind} | ${content}\n`;
         const tokenCost = estimatedTokens(next);
-        if (charCount(text) + charCount(next) <= cap) {
+        const abstainedMemory = omitted.some((item) => item.reason === "low-confidence" || item.reason === "insufficient-context" || item.reason === "low-relevance");
+        if (abstainedMemory && delivered.length === 0 && supplement.kind.startsWith("search-")) {
+            supplements.push({ id: supplement.id, kind: supplement.kind, delivered: false, reason: "abstained", rank: index + 1, token_cost: tokenCost });
+        }
+        else if (charCount(text) + charCount(next) <= cap) {
             text += next;
             supplements.push({ id: supplement.id, kind: supplement.kind, delivered: true, reason: "supplemental", rank: index + 1, token_cost: tokenCost });
         }
@@ -295,9 +579,23 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
     }
     const staleCount = omitted.filter((item) => item.reason === "stale-provenance" || item.reason === "retired").length;
     const budgetCount = omitted.filter((item) => item.reason === "budget").length;
+    const actionabilityCount = omitted.filter((item) => item.reason === "actionability-cap").length;
+    const abstention = emptyAbstention();
+    for (const item of omitted) {
+        if (item.reason === "low-confidence" || item.reason === "insufficient-context" || item.reason === "low-relevance") {
+            abstention.active = true;
+            abstention.withheld++;
+            abstention.reasons[item.reason]++;
+        }
+    }
+    if (abstention.active) {
+        abstention.retry_hint = "Retry hunch_context with the concrete symptom, expected behavior, failing API, and repro evidence; do not let advisory memory override the task or tests.";
+    }
     const notes = [
         staleCount ? `${staleCount} stale/retired record(s) withheld; run hunch drift or hunch_why(id) to inspect.` : "",
         budgetCount ? `${budgetCount} lower-ranked record(s) omitted by budget; use hunch_why(id) to drill down.` : "",
+        actionabilityCount ? `${actionabilityCount} additional decision hypothesis/hypotheses withheld by the actionability cap; refine the task evidence or use hunch_why(id).` : "",
+        abstention.active ? `${abstention.withheld} weak prescriptive record(s) withheld by confidence/relevance abstention. ${abstention.retry_hint}` : "",
     ].filter(Boolean);
     if (notes.length) {
         const footer = `… ${notes.join(" ")}\n`;
@@ -312,11 +610,14 @@ export function buildDeliveryEnvelope(ctx, options = {}) {
     return {
         text,
         delivered,
+        hypotheses,
+        obligations,
         supplements,
         omitted,
         budget_tokens: budget,
         used_chars: charCount(text),
         blocking_overflow: blockingOverflow,
+        abstention,
     };
 }
 //# sourceMappingURL=delivery.js.map

package/dist/core/evidenceMap.js

@@ -0,0 +1,202 @@
+import { z } from "zod";
+export const EvidenceOutcomeSchema = z.enum(["red", "green", "error", "not-run"]);
+const ownerIsSafe = (value) => {
+    if (/\0|[\r\n]/.test(value))
+        return false;
+    const separator = value.indexOf("::");
+    if (separator <= 0 || separator === value.length - 2)
+        return false;
+    const path = value.slice(0, separator);
+    if (path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(path) || path.includes("\\"))
+        return false;
+    return path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+};
+export const EvidenceOwnerSchema = z.string().min(4).max(500).refine(ownerIsSafe, "owner must be a safe repo-relative path and declaration separated by ::");
+export const EvidenceProbeSchema = z.object({
+    target_before: EvidenceOutcomeSchema,
+    control_before: EvidenceOutcomeSchema,
+    target_after: EvidenceOutcomeSchema.optional(),
+    control_after: EvidenceOutcomeSchema.optional(),
+}).strict();
+export const EvidenceExecutionSchema = z.object({
+    owner: EvidenceOwnerSchema,
+    target_count: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    control_count: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+}).strict();
+export const EvidenceInterventionSchema = z.object({
+    owner: EvidenceOwnerSchema,
+    mutation_id: z.string().min(1).max(200).optional(),
+    target_after: EvidenceOutcomeSchema,
+    control_after: EvidenceOutcomeSchema,
+}).strict();
+export const VerifiedEvidenceReceiptSchema = z.object({
+    version: z.literal(1),
+    claim: z.string().trim().min(1).max(100_000),
+    probe: EvidenceProbeSchema,
+    execution: z.array(EvidenceExecutionSchema).max(500).default([]),
+    interventions: z.array(EvidenceInterventionSchema).max(500).default([]),
+}).strict();
+function ownerPath(owner) {
+    return owner.slice(0, owner.indexOf("::"));
+}
+function unique(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function closureStatus(receipt, authenticated) {
+    const target = receipt.probe.target_after ?? null;
+    const control = receipt.probe.control_after ?? null;
+    if (!authenticated)
+        return { status: "unverified", target_after: target, control_after: control };
+    if (!target || target === "not-run")
+        return { status: "open", target_after: target, control_after: control };
+    if (target === "error")
+        return { status: "probe-error", target_after: target, control_after: control };
+    if (target === "red")
+        return { status: "still-red", target_after: target, control_after: control };
+    if (control === "red" || control === "error")
+        return { status: "control-regressed", target_after: target, control_after: control };
+    if (!control || control === "not-run")
+        return { status: "control-unchecked", target_after: target, control_after: control };
+    return { status: "closed", target_after: target, control_after: control };
+}
+/** Compile externally observed receipts into a bounded evidence map. This is
+ * deliberately pure: it runs no probe, edits no source, and never turns causal
+ * influence into a correction-owner claim. */
+export function compileVerifiedEvidenceMap(value) {
+    const parsed = VerifiedEvidenceReceiptSchema.safeParse(value);
+    if (!parsed.success) {
+        const details = parsed.error.issues.slice(0, 5).map((issue) => `${issue.path.join(".") || "receipt"}: ${issue.message}`).join("; ");
+        throw new Error(`invalid verified-evidence receipt: ${details}`);
+    }
+    const receipt = parsed.data;
+    const authenticated = receipt.probe.target_before === "red" && receipt.probe.control_before === "green";
+    const verificationReason = authenticated
+        ? "the target was red while the distinct control stayed green"
+        : "authentication requires target_before=red and control_before=green";
+    const executionByOwner = new Map();
+    for (const entry of receipt.execution) {
+        const current = executionByOwner.get(entry.owner) ?? { target: 0, control: 0 };
+        current.target = Math.max(current.target, entry.target_count);
+        current.control = Math.max(current.control, entry.control_count);
+        executionByOwner.set(entry.owner, current);
+    }
+    const targetObserved = unique([...executionByOwner].filter(([, counts]) => counts.target > 0).map(([owner]) => owner));
+    const targetOnly = unique([...executionByOwner].filter(([, counts]) => counts.target > 0 && counts.control === 0).map(([owner]) => owner));
+    const shared = unique([...executionByOwner].filter(([, counts]) => counts.target > 0 && counts.control > 0).map(([owner]) => owner));
+    // A single target-only call is often setup noise. The transfer-development
+    // rule therefore requires at least two target calls and a 2x target/control
+    // ratio before execution may reserve one file-level shortlist slot.
+    const strongDifferential = unique([...executionByOwner]
+        .filter(([, counts]) => counts.target > counts.control && counts.target >= 2 * Math.max(1, counts.control))
+        .map(([owner]) => owner));
+    const strongDifferentialFiles = unique(strongDifferential.map(ownerPath));
+    const strongDifferentialEntries = strongDifferential.map((owner) => {
+        const counts = executionByOwner.get(owner);
+        return {
+            owner,
+            target_count: counts.target,
+            control_count: counts.control,
+            ratio: counts.target / Math.max(1, counts.control),
+        };
+    });
+    const admitted = authenticated
+        ? receipt.interventions.filter((entry) => entry.target_after === "green" && entry.control_after === "green")
+        : [];
+    const behaviorSensitive = unique(admitted.map((entry) => entry.owner));
+    const sensitiveFiles = unique(behaviorSensitive.map(ownerPath));
+    const paths = unique([...targetObserved.map(ownerPath), ...sensitiveFiles]);
+    const files = paths.map((path) => {
+        const targetExecutionOwners = targetObserved.filter((owner) => ownerPath(owner) === path);
+        const targetOnlyOwners = targetOnly.filter((owner) => ownerPath(owner) === path);
+        const sharedOwners = shared.filter((owner) => ownerPath(owner) === path);
+        const strongDifferentialOwners = strongDifferential.filter((owner) => ownerPath(owner) === path);
+        const strongDifferentialSupport = strongDifferentialOwners.reduce((support, owner) => {
+            const counts = executionByOwner.get(owner);
+            return support + counts.target - counts.control;
+        }, 0);
+        const sensitiveOwners = behaviorSensitive.filter((owner) => ownerPath(owner) === path);
+        const evidence = [
+            ...(targetExecutionOwners.length ? ["target-execution"] : []),
+            ...(targetOnlyOwners.length ? ["target-only-execution"] : []),
+            ...(sharedOwners.length ? ["shared-execution"] : []),
+            ...(strongDifferentialOwners.length ? ["strong-differential-execution"] : []),
+            ...(sensitiveOwners.length ? ["behavior-sensitive"] : []),
+        ];
+        return {
+            path,
+            target_execution_owners: targetExecutionOwners,
+            target_only_owners: targetOnlyOwners,
+            shared_execution_owners: sharedOwners,
+            strong_differential_owners: strongDifferentialOwners,
+            strong_differential_support: strongDifferentialSupport,
+            behavior_sensitive_owners: sensitiveOwners,
+            evidence,
+        };
+    });
+    const level = !authenticated
+        ? "unverified"
+        : behaviorSensitive.length
+            ? "behavior-sensitive"
+            : targetObserved.length
+                ? "execution-verified"
+                : "probe-authenticated";
+    return {
+        version: 1,
+        claim: receipt.claim,
+        level,
+        verification: {
+            authenticated,
+            target_before: receipt.probe.target_before,
+            control_before: receipt.probe.control_before,
+            reason: verificationReason,
+        },
+        closure: closureStatus(receipt, authenticated),
+        execution_slice: {
+            target_observed_owners: targetObserved,
+            target_only_owners: targetOnly,
+            shared_owners: shared,
+            strong_differential_owners: strongDifferential,
+            strong_differential_files: strongDifferentialFiles,
+            strong_differential: strongDifferentialEntries,
+        },
+        intervention_slice: {
+            admitted_receipts: admitted.length,
+            behavior_sensitive_owners: behaviorSensitive,
+            behavior_sensitive_files: sensitiveFiles,
+        },
+        files,
+        owner_claim: {
+            enabled: false,
+            owner: null,
+            reason: "Execution and successful interventions establish behavioral influence, not correction ownership.",
+        },
+        limitations: [
+            "The compiler trusts supplied observations; it does not execute or independently authenticate probes.",
+            "Unexecuted code and unsupported mutation shapes remain outside the evidence slice.",
+            "A behavior-sensitive declaration may be an upstream lever, wrapper, or downstream symptom site rather than the correction owner.",
+        ],
+    };
+}
+function listed(values) {
+    return values.length ? values.map((value) => `  - ${value}`).join("\n") : "  (none)";
+}
+export function formatVerifiedEvidenceMap(map) {
+    return [
+        "Verified evidence map (read-only receipt compiler)",
+        `Claim: ${map.claim}`,
+        `Evidence level: ${map.level}`,
+        `Probe authentication: ${map.verification.authenticated ? "authenticated" : "not authenticated"} — ${map.verification.reason}`,
+        `Closure: ${map.closure.status}`,
+        "Target-only execution:",
+        listed(map.execution_slice.target_only_owners),
+        "Shared execution:",
+        listed(map.execution_slice.shared_owners),
+        "Strong differential execution files:",
+        listed(map.execution_slice.strong_differential_files),
+        "Behavior-sensitive files:",
+        listed(map.intervention_slice.behavior_sensitive_files),
+        `Exact-owner claim: disabled — ${map.owner_claim.reason}`,
+        "This command compiled supplied observations; it did not run code or mutate the repository.",
+    ].join("\n");
+}
+//# sourceMappingURL=evidenceMap.js.map