@davesheffer/hunch 1.7.0 → 1.7.1

package/dist/extractors/parse.js

@@ -1,15 +1,5 @@
-/**
- * Deterministic tree-sitter parsing (no LLM). Extracts, per file:
- *   - symbols: functions, methods, classes, interfaces, types, arrow-fn consts
- *   - imports: module specifiers (for dependency edges)
- *   - calls:   callee names + byte offset (mapped to the enclosing symbol)
- *
- * Uses NATIVE tree-sitter (synchronous, prebuilt for Node 20 — see decision in
- * the commit history; web-tree-sitter's WASM grammars had an incompatible ABI).
- */
-import Parser from "tree-sitter";
-import TS from "tree-sitter-typescript";
-const { typescript, tsx } = TS;
+import { loadNativeTreeSitter } from "./nativeTreeSitter.js";
+const { Parser, typescript, tsx } = loadNativeTreeSitter();
 /** Extremely common builtin/array/object/string/promise method names. Member
  *  calls to these (e.g. `arr.map(...)`) must NOT create call edges to unrelated
  *  repo symbols that happen to share the name (DESIGN: keep the graph clean). */
@@ -112,12 +102,12 @@ export function parseSource(file, source) {
             imports.push(node.text.replace(STR_QUOTES, ""));
         }
         else if (cname === "call.id") {
-            calls.push({ callee: node.text, atByte: node.startIndex, member: false });
+            calls.push({ callee: node.text, atByte: node.startIndex, endByte: node.endIndex, member: false });
         }
         else if (cname === "call.member") {
             // skip builtin method names to avoid false edges to similarly-named symbols
             if (!BUILTIN_METHODS.has(node.text))
-                calls.push({ callee: node.text, atByte: node.startIndex, member: true });
+                calls.push({ callee: node.text, atByte: node.startIndex, endByte: node.endIndex, member: true });
         }
     }
     for (const { kind, def, name } of pendingDefs.values()) {
@@ -131,7 +121,7 @@ export function parseSource(file, source) {
         });
     }
     symbols.sort((a, b) => a.startByte - b.startByte);
-    return { symbols, imports, calls };
+    return { symbols, imports, calls, parseable: !tree.rootNode.hasError };
 }
 /** Walk up to the nearest node whose type is a definition we recognize. */
 function ascendToDef(node) {

package/dist/integrations/claudemd.js

@@ -6,6 +6,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { wikiSummary } from "../wiki/wiki.js";
+import { PolicyRepository } from "../constitution/repository.js";
 const START = "<!-- HUNCH:START — auto-generated, do not edit by hand -->";
 const END = "<!-- HUNCH:END -->";
 export function renderHunchSection(store, root) {
@@ -18,6 +19,7 @@ export function renderHunchSection(store, root) {
         bugs: store.json.loadAll("bugs").length,
         constraints: store.json.loadAll("constraints").length,
         components: store.json.loadAll("components").length,
+        policies: root ? new PolicyRepository(root, store).listPolicies({ publicOnly: true }).length : 0,
     };
     const lines = [];
     lines.push(START);
@@ -25,7 +27,7 @@ export function renderHunchSection(store, root) {
     lines.push("");
     lines.push("This repo has **Hunch** — a curated graph of *why* the code is the way it is " +
         "(decisions, bug history, invariants). It currently holds " +
-        `**${counts.decisions} decisions, ${counts.bugs} bugs, ${counts.constraints} constraints, ${counts.components} components**.`);
+        `**${counts.decisions} decisions, ${counts.bugs} bugs, ${counts.constraints} constraints, ${counts.components} components, ${counts.policies} policies**.`);
     lines.push("");
     lines.push("**Consult Hunch via the `hunch_*` MCP tools — pick by MOMENT, not from memory:**");
     lines.push("");
@@ -47,8 +49,13 @@ export function renderHunchSection(store, root) {
     lines.push("");
     lines.push("**Before committing / merging:**");
     lines.push("- `hunch_conformance()` — does the code still SATISFY recorded intent? Run before and after a refactor.");
+    lines.push("- `hunch_policy_evaluate(policy_id?, active_only?)` / `hunch_policy_plan(policy_id)` / `hunch_policy_card(policy_id)` / `hunch_policy_proof(policy_id)` — evaluate canonical policy, inspect the planned corpus, review the evidence/uncertainty card, and inspect raw replay receipts; only an explicit human activation grants authority.");
     lines.push("- `hunch_pr_impact(base?)` / `hunch_merge_verdict(...)` — a change's memory surface; would it re-open a closed bug?");
     lines.push("");
+    lines.push("**Build the Constitution review queue:**");
+    lines.push("- `hunch constitution bootstrap --since 90d --max-candidates 3` (CLI) — normalize recent structured human evidence into at most three non-active policy candidates; add `--history` for exact, human-identifier-grounded fix/revert deltas or explicit dependency retirements. Coincidence/ambiguity stays uncompilable; neither path grants authority.");
+    lines.push("- `hunch constitution ingest --since 90d [--instructions] [--from export.json]` (CLI) — normalize corrections/failures plus bounded committed instructions/ADRs and strict local review/conversation/PR exports into Git-native evidence; raw prose is hash-only, unsupported intent remains uncompilable, and no policy is minted.");
+    lines.push("");
     lines.push("**After deciding / when corrected:**");
     lines.push("- `hunch_capture_decision(topic?)` → `hunch_record_decision(...)` — interview first, then write; status `proposed` = roadmap intent (shows in `hunch now`).");
     lines.push("- `hunch_record_correction(...)` — a human correction becomes an ENFORCED rule (Never Twice), not a one-session memory.");

package/dist/integrations/gitignore.js

@@ -19,6 +19,7 @@ const ENTRIES = [
     ".hunch/*.sqlite-wal",
     ".hunch/*.sqlite-journal",
     ".hunch/**/*.tmp*",
+    ".hunch-cache/",
     // Per-machine private-overlay pointer written by `hunch private` (holds the local
     // path to the private store) — never committed.
     ".hunch/local.json",
@@ -39,6 +40,13 @@ const MEM_ENTRIES = [
     ".hunch/bugs/",
     ".hunch/constraints/",
     ".hunch/components/",
+    ".hunch/evidence/",
+    ".hunch/corpora/",
+    ".hunch/policies/",
+    ".hunch/proofs/",
+    ".hunch/plans/",
+    ".hunch/dispositions/",
+    ".hunch/shadow/",
     ".hunch/symbols/",
     ".hunch/edges/",
 ];

package/dist/integrations/providers.js

@@ -21,6 +21,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { renderHunchSection, upsertSection, updateClaudeMd } from "./claudemd.js";
+import { isGitCleanPath } from "../extractors/git.js";
 /** Strip // line and block comments + trailing commas (JSONC → JSON). String-aware
  *  (double-quoted, with escapes) so a // inside a value isn't mangled. VS Code's
  *  .vscode/mcp.json is JSONC, so we must tolerate comments. */
@@ -405,23 +406,24 @@ export function regenerateGrounding(root, store) {
         writeWindsurfRule(root, store),
     ];
 }
-/** Self-heal: refresh the Hunch section in each grounding doc that ALREADY exists,
- *  and report which ones actually changed. Unlike regenerateGrounding it NEVER creates
- *  a file (so it can't scaffold grounding into a project that opted out of an
- *  assistant). Run by `hunch index` and non-hook `hunch sync` so a project silently
- *  picks up generator fixes (e.g. corrected MCP tool param names) and fresh record
- *  counts on the next refresh — no manual `hunch init`. Not run from the commit hook,
- *  which deliberately avoids dirtying the working tree on every commit. */
-export function refreshExistingGrounding(root, store) {
-    const targets = [
+function groundingTargets(root, store) {
+    return [
         ["CLAUDE.md", () => updateClaudeMd(root, store)],
         ["AGENTS.md", () => writeAgentsMd(root, store)],
         [join(".github", "copilot-instructions.md"), () => writeCopilotInstructions(root, store)],
         [join(".cursor", "rules", "hunch.mdc"), () => writeCursorRule(root, store)],
         [join(".windsurf", "rules", "hunch.md"), () => writeWindsurfRule(root, store)],
     ];
+}
+/** Self-heal: refresh the Hunch section in each grounding doc that ALREADY exists,
+ *  and report which ones actually changed. Unlike regenerateGrounding it NEVER creates
+ *  a file (so it can't scaffold grounding into a project that opted out of an
+ *  assistant). Run by `hunch index` and non-hook `hunch sync` so a project silently
+ *  picks up generator fixes (e.g. corrected MCP tool param names) and fresh record
+ *  counts on the next refresh — no manual `hunch init`. */
+export function refreshExistingGrounding(root, store) {
     const changed = [];
-    for (const [rel, write] of targets) {
+    for (const [rel, write] of groundingTargets(root, store)) {
         const file = join(root, rel);
         if (!existsSync(file))
             continue; // refresh-only: never scaffold a doc the project doesn't have
@@ -432,6 +434,26 @@ export function refreshExistingGrounding(root, store) {
     }
     return changed;
 }
+/** Capture-commit refresh: rewrite ONLY grounding docs that are git-clean, and return the
+ *  absolute paths of the ones that changed so the caller folds them into the memory commit
+ *  (commitAndPushHunch alsoStage). This keeps committed record counts permanently true —
+ *  every capture used to bump the count and re-stale the committed docs, failing the
+ *  release gate's clean-tree check on the next CI index (the refresh-counts treadmill).
+ *  A user-dirty or untracked doc is left completely untouched (never refreshed, never
+ *  staged); it heals on the next manual `hunch sync` or `hunch index`. */
+export function refreshCommittableGrounding(root, store) {
+    const changed = [];
+    for (const [rel, write] of groundingTargets(root, store)) {
+        const file = join(root, rel);
+        if (!existsSync(file) || !isGitCleanPath(root, rel))
+            continue;
+        const before = readFileSync(file, "utf8");
+        write();
+        if (readFileSync(file, "utf8") !== before)
+            changed.push(file);
+    }
+    return changed;
+}
 /** A malformed configuration for one surface (for example an MCP file) must not
  * prevent the same assistant's rule or lifecycle hook from being installed. */
 function runProvider(writers) {

package/dist/integrations/sync.js

@@ -1,4 +1,15 @@
+/**
+ * The single funnel for auto-committing memory after a capture, so memory never has to be
+ * committed by hand — in EVERY mode (auto-commit is ON by default; `--no-auto-commit` opts out).
+ * A private record commits + two-way-syncs (merge remote, then push) its dedicated overlay repo.
+ * A public record commits the repo-tracked .hunch/ WITHOUT pushing — an automatic pull/push on
+ * the user's CODE repo would merge the remote into their working branch and publish unpushed
+ * commits (bug_overlay_clobber); the memory commit rides their next push instead.
+ * Used by every CLI/MCP path that writes a record.
+ */
+import { dirname } from "node:path";
 import { commitAndPushHunch } from "../extractors/git.js";
+import { refreshCommittableGrounding } from "./providers.js";
 /** Auto-commit + push the overlay after a private write, when auto-commit is on. No-op
  *  otherwise (manual `hunch private --sync` still works). Never throws. */
 export function flushPrivate(store, message) {
@@ -21,6 +32,10 @@ export function flushCapture(store, publicHunchDir, isPrivate, message) {
     }
     if (!store.autoCommit)
         return null;
-    return commitAndPushHunch(publicHunchDir, message, { push: false });
+    // A public capture changes record counts, so refresh git-clean grounding docs and fold
+    // them into the SAME memory commit — otherwise every capture re-stales the committed
+    // counts and the release gate's clean-tree check fails on the next CI index.
+    const grounding = refreshCommittableGrounding(dirname(publicHunchDir), store);
+    return commitAndPushHunch(publicHunchDir, message, { push: false, alsoStage: grounding });
 }
 //# sourceMappingURL=sync.js.map

package/dist/mcp/server.js

@@ -22,9 +22,12 @@ import { ensureTeamOverlay } from "../integrations/team.js";
 import { formatContext, formatStructure } from "../core/format.js";
 import { compareCandidates } from "../core/compare.js";
 import { checkConformance } from "../core/conformance.js";
+import { ConstitutionService } from "../constitution/service.js";
+import { G2_RUNBOOK_CATEGORIES } from "../constitution/g2.js";
 import { renderMarkdown, renderImpact, verdict } from "../core/checkreport.js";
 import { nowData, wikiStatus, publicHome, readWikiManifestAt } from "../wiki/wiki.js";
 import { HUNCH_VERSION } from "../core/version.js";
+import { indexRepo } from "../extractors/indexer.js";
 import { liveForTopic, historyForTopic, rejectedForTopic, captureConflicts } from "../core/topics.js";
 import { issueCaptureToken as issueToken, consumeCaptureToken as consumeToken } from "../core/capturetoken.js";
 import { randomUUID } from "node:crypto";
@@ -723,6 +726,191 @@ export function buildServer(root) {
             return err(`Failed to compare candidates: ${e.message}`);
         }
     });
+    // -- Hunch Constitution (read-first, agent-neutral Policy IR) ------------
+    server.registerTool("hunch_policy_candidates", {
+        title: "List Constitution policy candidates",
+        description: "List compiled/proposed deterministic Policy IR candidates. Read-only; candidates carry no authority and cannot block. Uses the same Git-native policy store for every MCP client.",
+        inputSchema: {
+            public_only: z.boolean().optional().describe("Exclude the private overlay from this response."),
+        },
+    }, async ({ public_only }) => {
+        try {
+            const service = new ConstitutionService(store, root);
+            const candidates = service.list({ publicOnly: public_only }).filter((p) => p.state === "compiled" || p.state === "validating" || p.state === "proposed");
+            if (!candidates.length)
+                return ok("No Constitution policy candidates.");
+            return ok(JSON.stringify(candidates.map((p) => ({ id: p.id, state: p.state, statement: p.statement, proof: p.proof, data_class: p.data_class })), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to list policy candidates: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_policy_plan", {
+        title: "Generate or inspect a Constitution proof plan",
+        description: "Return the canonical Git-native ProofPlan for a policy candidate: immutable source/current commits, known-good/bad corpus, mutation operators, expectations, and budgets. Planning executes no replay, model, test, or authority transition.",
+        inputSchema: {
+            policy_id: z.string().describe("Policy id (pol_*)."),
+            public_only: z.boolean().optional().describe("Exclude private-overlay policy and evidence records."),
+        },
+    }, async ({ policy_id, public_only }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).plan(policy_id, { publicOnly: public_only }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to generate policy proof plan: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_policy_card", {
+        title: "Inspect a Constitution proof card",
+        description: "Return the deterministic proof-card view for a policy: exact assertion/scope, raw evidence vector, uncertainty, blocking readiness, authority, limitations, and next actions. Read-only and grants no authority.",
+        inputSchema: {
+            policy_id: z.string().describe("Policy id (pol_*)."),
+            public_only: z.boolean().optional().describe("Exclude private-overlay policy and proof records."),
+        },
+    }, async ({ policy_id, public_only }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).card(policy_id, { publicOnly: public_only }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to build policy proof card: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_policy_shadow", {
+        title: "Inspect Constitution shadow precision",
+        description: "Return the append-only shadow evaluation ledger, current human dispositions, raw precision counts, unknown/error rate, thresholds, and P4-review recommendation for one policy. Read-only: it never records a sample, changes lifecycle, activates, warns, or blocks.",
+        inputSchema: {
+            policy_id: z.string().describe("Policy id (pol_*)."),
+            public_only: z.boolean().optional().describe("Exclude private-overlay shadow records."),
+        },
+    }, async ({ policy_id, public_only }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).shadowReport(policy_id, {}, { publicOnly: public_only }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect policy shadow precision: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_policy_proof", {
+        title: "Inspect a Constitution policy proof",
+        description: "Return the full content-addressed proof artifact for a policy. Read-only; exposes baseline, mutations, proof class, artifact hashes, and limitations without changing authority.",
+        inputSchema: {
+            policy_id: z.string().describe("Policy id (pol_*)."),
+            public_only: z.boolean().optional().describe("Exclude the private overlay from this response."),
+        },
+    }, async ({ policy_id, public_only }) => {
+        try {
+            const service = new ConstitutionService(store, root);
+            const policy = service.get(policy_id, { publicOnly: public_only });
+            if (!policy.proof)
+                return ok(`Policy ${policy_id} has no proof yet.`);
+            return ok(JSON.stringify(service.proof(policy.proof, { publicOnly: public_only }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to read policy proof: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_policy_evaluate", {
+        title: "Evaluate Constitution policy",
+        description: "Evaluate one or all deterministic Policy IR records and return canonical neutral receipts (satisfied, violated, not_applicable, unknown, error). This is the same evaluator used by CLI and strict CI; models never decide the verdict.",
+        inputSchema: {
+            policy_id: z.string().optional().describe("Optional policy id; omit for all policies."),
+            active_only: z.boolean().optional().describe("Evaluate only active advisory/blocking policies."),
+            public_only: z.boolean().optional().describe("Exclude private-overlay policies and graph records."),
+            workspace: z.enum(["staged", "working"]).optional().describe("For executable-behavior policies, evaluate the staged index or complete working snapshot in a disposable checkout."),
+            commit: z.string().optional().describe("For executable-behavior policies, evaluate an exact commit ref instead of the current committed HEAD."),
+        },
+    }, async ({ policy_id, active_only, public_only, workspace, commit }) => {
+        try {
+            if (workspace && commit)
+                throw new Error("choose either workspace or commit for executable-behavior evaluation");
+            if (commit && !revExists(commit, root))
+                throw new Error(`commit ref ${JSON.stringify(commit)} does not resolve`);
+            indexRepo(store, root, { churn: false });
+            store.reindex();
+            const behavior = workspace ? { workspace }
+                : commit ? { commit: revParse(commit, root) }
+                    : undefined;
+            const receipts = new ConstitutionService(store, root)
+                .evaluate({ id: policy_id, activeOnly: active_only, publicOnly: public_only, behavior })
+                .map((r) => r.evaluation);
+            return ok(JSON.stringify(receipts, null, 2));
+        }
+        catch (e) {
+            return err(`Failed to evaluate policy: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_readiness", {
+        title: "Inspect Constitution G2 readiness",
+        description: "Return the exact private G2 dogfood evidence packet: human-selected policies, bound proof/corpus/shadow evidence, operational runbook rehearsals, and blockers. Read-only; it never creates evidence, signs off G2, activates policy, warns, or blocks.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2Readiness(), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect G2 readiness: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g3_readiness", {
+        title: "Inspect Constitution G3 readiness",
+        description: "Return the exact private G3 advisory packet: human-selected policies and clients, immutable experiment preregistrations, proof-card comprehension/review measurements, executable adapter conformance, scorecard, and blockers. Read-only; it never records evidence, activates policy, or signs off G3.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g3Readiness(), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect G3 readiness: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_shadow_queue", {
+        title: "Review unclassified G2 shadow violations",
+        description: "Return a bounded private queue of exact-current-proof G2 shadow violations that still require human classification. Read-only; it never records an observation or disposition, changes lifecycle, grants authority, warns, or blocks.",
+        inputSchema: {
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum queue items to return (default 20)."),
+        },
+    }, async ({ limit }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2ShadowQueue(limit ?? 20), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect the G2 shadow queue: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_operational_drill", {
+        title: "Execute one exact G2 operational drill",
+        description: "Execute the selected private G2 runbook's exact safety regression and return a content-addressed hash-only receipt. Diagnostic only: it writes no rehearsal or shadow evidence, grants no authority, and never signs off G2.",
+        inputSchema: {
+            category: z.enum(G2_RUNBOOK_CATEGORIES).describe("Exact operational category selected by the current private G2 plan."),
+        },
+    }, async ({ category }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2OperationalDrill(category), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to execute the G2 operational drill: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_candidates", {
+        title: "Review potential G2 dogfood candidates",
+        description: "Return a bounded private review packet of exact structural candidates from fix-labeled git history, including the current append-only human selection/rejection when present. Read-only: proposed before/after corpus refs are not replayed evidence, and the tool creates no attestation, policy, proof, corpus, authority, warning, or block.",
+        inputSchema: {
+            since: z.string().min(1).max(100).optional().describe("Git history window (default 180d)."),
+            max_commits: z.number().int().min(1).max(200).optional().describe("Maximum fix-labeled commits to inspect (default 100)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum ranked candidates to return (default 30)."),
+        },
+    }, async ({ since, max_commits, limit }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2CandidateReview({
+                since: since ?? "180d",
+                maxCommits: max_commits ?? 100,
+                limit: limit ?? 30,
+            }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect G2 candidates: ${e.message}`);
+        }
+    });
     // -- hunch_conformance ----------------------------------------------------
     server.registerTool("hunch_conformance", {
         title: "Does the code still satisfy the recorded intent?",
@@ -737,6 +925,102 @@ export function buildServer(root) {
         const head = violations.length ? `⛔ ${violations.length} intent(s) the code no longer satisfies` : "✅ the code satisfies every recorded intent";
         return ok(`Intent-conformance (${results.length - violations.length}/${results.length} satisfied):\n\n${lines.join("\n")}\n\n${head}`);
     });
+    server.registerTool("hunch_constitution_g2_behavior_candidates", {
+        title: "Review executable G2 behavior candidates",
+        description: "Derive a bounded private review packet from human-grounded rejected structural proxies and newly added literal node:test cases in their exact fixing commits. Read-only: candidates remain unselected and create no policy, corpus, proof, authority, warning, or block.",
+        inputSchema: {
+            decision_id: z.string().regex(/^dec_[A-Za-z0-9_-]+$/).optional().describe("Exact current human-confirmed decision to use as the direct behavior grounding batch."),
+            since: z.string().min(1).max(100).optional().describe("Git history window (default 180d)."),
+            max_commits: z.number().int().min(1).max(200).optional().describe("Maximum fix-labeled commits to inspect (default 100)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum behavior candidates to return (default 30)."),
+        },
+    }, async ({ decision_id, since, max_commits, limit }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2BehaviorCandidateReview({
+                since: since ?? "180d",
+                maxCommits: max_commits ?? 100,
+                limit: limit ?? 30,
+                decisionId: decision_id,
+            }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to inspect G2 behavior candidates: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_behavior_replay", {
+        title: "Replay one G2 behavior candidate",
+        description: "Execute one exact behavior candidate without a shell in disposable known-bad and known-good worktrees, transplanting the hash-bound known-good test file into both. Diagnostic only: writes no Constitution artifact and grants no policy or G2 authority.",
+        inputSchema: {
+            candidate_id: z.string().regex(/^g2behavior_[a-f0-9]{10}$/),
+            review_hash: z.string().regex(/^sha1:[a-f0-9]{40}$/),
+            decision_id: z.string().regex(/^dec_[A-Za-z0-9_-]+$/).optional().describe("Exact decision batch used by the reviewed candidate."),
+            since: z.string().min(1).max(100).optional().describe("Git history window used by the exact review packet (default 180d)."),
+            max_commits: z.number().int().min(1).max(200).optional().describe("Fix-commit bound used by the exact review packet (default 100)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Item limit used by the exact review packet (default 30)."),
+            timeout_ms: z.number().int().min(1).max(120000).optional().describe("Per-leg execution timeout (default 30000ms)."),
+        },
+    }, async ({ candidate_id, review_hash, decision_id, since, max_commits, limit, timeout_ms }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2BehaviorCandidateReplay(candidate_id, review_hash, {
+                since: since ?? "180d",
+                maxCommits: max_commits ?? 100,
+                limit: limit ?? 30,
+                decisionId: decision_id,
+                timeoutMs: timeout_ms ?? 30_000,
+            }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to replay G2 behavior candidate: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_behavior_materialization", {
+        title: "Assess selected G2 behavior materialization",
+        description: "Bind the complete current private behavior review and exact selected attestations, then report whether their durable meanings are expressible by the supported Policy IR. Read-only and fail-closed: unsupported behavior creates no policy, corpus, plan, proof, authority, warning, or block.",
+        inputSchema: {
+            decision_id: z.string().regex(/^dec_[A-Za-z0-9_-]+$/).optional().describe("Exact decision batch to assess."),
+            since: z.string().min(1).max(100).optional().describe("Git history window used by the exact review packet (default 180d)."),
+            max_commits: z.number().int().min(1).max(200).optional().describe("Fix-commit bound used by the exact review packet (default 100)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Item limit used by the exact review packet (default 30)."),
+        },
+    }, async ({ decision_id, since, max_commits, limit }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2BehaviorMaterializationAssessment({
+                since: since ?? "180d",
+                maxCommits: max_commits ?? 100,
+                limit: limit ?? 30,
+                decisionId: decision_id,
+            }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to assess G2 behavior materialization: ${e.message}`);
+        }
+    });
+    server.registerTool("hunch_constitution_g2_behavior_policy_materialize", {
+        title: "Materialize selected G2 behavior policies",
+        description: "Materialize every current exact selected behavior attestation into a separate private Policy IR v2 proposal, exact corpus and plan, and P3 executable proof. Writes private non-authoritative artifacts only; activation remains a separate explicit human action.",
+        inputSchema: {
+            decision_id: z.string().regex(/^dec_[A-Za-z0-9_-]+$/).optional().describe("Exact decision batch to materialize."),
+            since: z.string().min(1).max(100).optional().describe("Git history window used by the complete exact review packet (default 180d)."),
+            max_commits: z.number().int().min(1).max(200).optional().describe("Fix-commit bound used by the exact review packet (default 100)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Item limit used by the exact review packet (default 30)."),
+            allow_install_scripts: z.array(z.string().min(1).max(214)).max(20).optional().describe("Exact dependency package names allowed to run lifecycle scripts while provisioning snapshots."),
+            dependency_timeout_ms: z.number().int().min(1).max(900000).optional().describe("Timeout for each exact dependency snapshot operation (default 300000ms)."),
+        },
+    }, async ({ decision_id, since, max_commits, limit, allow_install_scripts, dependency_timeout_ms }) => {
+        try {
+            return ok(JSON.stringify(new ConstitutionService(store, root).g2BehaviorPolicyMaterialize({
+                since: since ?? "180d",
+                maxCommits: max_commits ?? 100,
+                limit: limit ?? 30,
+                decisionId: decision_id,
+                allowInstallScripts: allow_install_scripts ?? [],
+                dependencyTimeoutMs: dependency_timeout_ms ?? 300_000,
+            }), null, 2));
+        }
+        catch (e) {
+            return err(`Failed to materialize G2 behavior policies: ${e.message}`);
+        }
+    });
     return server;
 }
 function provLine(record) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
   "description": "Architectural Conformance for AI-generated code: a git-native graph that deterministically blocks AI changes which break your architecture — the semantic invariants (layering, must-reach, dependency direction) pattern-SAST can't express — grounded in the decisions and bugs behind each rule, across any MCP assistant (Claude Code, Cursor, Copilot, Windsurf, Antigravity, Codex).",
@@ -18,6 +18,7 @@
   },
   "files": [
     "dist/**/*.js",
+    "bench/constitution-exp03-v1.json",
     "LICENSE",
     "NOTICE"
   ],
@@ -48,6 +49,9 @@
     "hunch": "tsx src/cli/index.ts",
     "test": "tsx --test test/*.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "rehearse:constitution": "npm run build && node tooling/constitution-clean-rehearsal.mjs",
+    "gate:release": "node tooling/release-gate.mjs",
+    "site:proof": "npm run build && node tooling/generate-public-proof.mjs",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {