@davesheffer/hunch 1.32.2 → 1.32.4

package/dist/mcp/server.js

@@ -11,6 +11,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { RootsListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { hunchPaths, findRoot, toPosixTarget } from "../core/paths.js";
+import { resolveMcpToolset } from "./toolset.js";
+import { readConfig } from "../core/config.js";
 import { canonicalRootPath, resolveActiveRoot } from "./roots.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { StateRefusal, SubscribeResponseSchema, capabilities, partitionOf, readState, recordsState, subscribeState, writeState } from "../store/stateBinding.js";
@@ -536,6 +538,15 @@ function prepareRoot(root, explicitOverlay, requireIndex) {
         throw error;
     }
 }
+/** Delivered to every MCP client at initialize — the one grounding channel that
+ * needs no host hook or instruction file. Host-neutral by design (con_e04226bd05);
+ * per-host prose (CLAUDE.md, AGENTS.md) and hooks add to it, never replace it. */
+export const MCP_INSTRUCTIONS = [
+    "Hunch is this repository's engineering memory: decisions, bug history, invariants, components, with provenance.",
+    "Per user task: (1) hunch_task(action:\"start\", title) once — unless the host's prompt hook already printed a task_id, then reuse it; (2) hunch_context(target, task_id) FIRST, before reading or editing, for the file, symbol, or task phrase; (3) hunch_check_constraints(scope) before editing shared code; (4) hunch_task(action:\"finish\", task_id) before the final response and show its contribution card.",
+    "Then by moment: hunch_why(target) for rationale and rejected alternatives, hunch_bug_lineage before fixing a failure, hunch_record_decision after a non-trivial choice, hunch_record_correction when a human corrects you.",
+    "Hosts without lifecycle hooks (Windsurf, Cursor, or Codex before its hooks are trusted) receive no automatic grounding: call these tools yourself.",
+].join("\n");
 export function buildServerWithRootControl(initialRoot, options = {}) {
     const pinned = options.pinned === true;
     const explicitOverlay = !!process.env.HUNCH_PRIVATE_DIR?.trim();
@@ -598,7 +609,13 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
     // the optional model isn't installed). The model then loads lazily on the first
     // hunch_query and stays warm — and hybridSearch degrades to FTS until then.
     const embedderReady = selectEmbedder();
-    const server = new McpServer({ name: "hunch", version: HUNCH_VERSION });
+    // Everyday tools by default; specialist groups by evidence, config, or env
+    // (src/mcp/toolset.ts). Hidden tools are never registered, so tools/list is
+    // exactly what the host can call.
+    const toolset = resolveMcpToolset(root, { configSpec: readConfig(hunchPaths(root)).mcp_tools ?? null, pinned });
+    if (toolset.hidden.length)
+        process.stderr.write(`[hunch-mcp] tool groups: ${toolset.groups.length ? toolset.groups.join(", ") : "core only"} (${toolset.source}); ${toolset.hidden.length} specialist tool(s) hidden — HUNCH_MCP_TOOLS=all or .hunch/config.json mcp_tools to expose\n`);
+    const server = new McpServer({ name: "hunch", version: HUNCH_VERSION }, { instructions: MCP_INSTRUCTIONS });
     let activeRequests = 0;
     let pendingRoot = null;
     let pendingScheduled = false;
@@ -1774,155 +1791,157 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
         return err(`nuryel.state/1 failed: ${e.message}`);
     };
     const stateResult = (text, structured) => ({ content: [{ type: "text", text }], structuredContent: structured });
-    server.registerTool("nuryel_capabilities", {
-        title: "nuryel.state/1 — what this state layer supports",
-        description: "Negotiate before depending on anything: returns the contract version, the capability list (verbs + record schemas), the repository partition this store serves, and which partition kinds it can hold. A capability you need that is missing here is a typed refusal on use, never a degraded answer.",
-        inputSchema: {},
-    }, async () => {
-        const caps = capabilities(store);
-        return stateResult(`${caps.protocol} · repository ${caps.repository.id} · partitions ${caps.partitions.join(", ")} · ${caps.capabilities.length} capabilities`, caps);
-    });
-    server.registerTool("nuryel_read", {
-        title: "nuryel.state/1 read — the system-of-record answer for a subject",
-        description: "Read organizational state under a delivery receipt. Pass the principal (id, kind, grants) and the scope; optionally a subject (an entity id, a decision topic, an external `object_type:object_key`) to get state_of_record — what is current, in force, done, what it depends on and what invalidates it — plus a task phrase for the ranked delivery envelope. Scopes the principal is not granted are named in denied_scopes, never silently dropped. To read observations beyond the default 64, use observed_page:{} with one scope and a subject, then pass state_of_record.observed_page.next_cursor as observed_page.cursor until null. A conflict means the observations changed: restart from the first page. Never claim complete coverage while a next cursor remains.",
-        inputSchema: ReadRequestSchema.omit({ schema: true }).shape,
-        outputSchema: ReadResponseSchema.shape,
-    }, async (input) => {
-        try {
-            const { response, envelope } = readState(store, { schema: STATE_READ_VERSION, ...input });
-            const sor = response.state_of_record;
-            const summary = sor
-                ? `subject ${sor.subject}: current ${sor.current.length} · in force ${sor.in_force.length} · done ${sor.done.length} · observed ${sor.observed?.length ?? 0} · depends on ${sor.depends_on.length} · invalidated by ${sor.invalidated_by.length}`
-                : "no subject — delivery envelope only";
-            const deniedNote = response.denied_scopes.length ? `\ndenied scopes: ${response.denied_scopes.map((s) => `${s.kind}/${s.id}`).join(", ")}` : "";
-            // Render the state of record itself, not only its refs: a consumer answers from this text.
-            const line = (label, ref) => {
-                const r = (response.records ?? {})[ref.id] ?? {};
-                const g = (k) => { const v = r[k]; return typeof v === "string" ? v : v == null ? "" : JSON.stringify(v); };
-                if (ref.facet === "derived")
-                    return `- ${label} derived ${ref.id} · computed ${g("computed_at")} · ${r.dependencies?.length ?? 0} dependencies\n    ${g("content").slice(0, 1200)}`;
-                if (ref.facet === "commitments")
-                    return `- ${label} commitment ${ref.id} · ${g("status")} · due ${g("due")} · owner ${g("owner")}: ${g("title")}${r.closed_by ? ` · closed by ${g("closed_by")}` : ""}`;
-                if (ref.facet === "receipts") {
-                    const t = (r.target ?? {});
-                    // The chain: what the action rested on, one pointer per line, so a reader follows
-                    // incident → decision → change proof → closure without a second call.
-                    const rests = (Array.isArray(r.rests_on) ? r.rests_on : []);
-                    const restLines = rests.map((d) => {
-                        if (d.kind === "record") {
-                            const sc = d.scope;
-                            return `\n    rests on record ${String(d.id)}${sc ? ` in ${String(sc.kind)}/${String(sc.id)}` : ""}`;
-                        }
-                        if (d.kind === "external") {
-                            const x = (d.ref ?? {});
-                            return `\n    rests on ${String(x.system ?? "")} ${String(x.object_type ?? "")}:${String(x.object_key ?? "")}`;
-                        }
-                        return `\n    rests on ${String(d.kind)} ${String(d.name ?? "")}`;
-                    }).join("");
-                    return `- ${label} receipt ${ref.id} · ${g("action_kind")} on ${String(t.system ?? "")} ${String(t.object_type ?? "")}:${String(t.object_key ?? "")} · ${g("state")} at ${g("occurred_at")} by ${g("actor")}${restLines}`;
-                }
-                if (ref.facet === "decisions")
-                    return `- ${label} decision ${ref.id} · ${g("status")}: ${g("title")}`;
-                if (ref.facet === "constraints")
-                    return `- ${label} constraint ${ref.id} · ${g("severity")}: ${g("statement")}`;
-                if (ref.facet === "entities")
-                    return `- ${label} entity ${ref.id} · ${g("kind")} ${g("name")} · ${g("lifecycle")}`;
-                return `- ${label} ${ref.facet} ${ref.id}`;
-            };
-            const stateText = sor
-                ? [...sor.current.map((r) => line("current", r)), ...sor.in_force.map((r) => line("in force", r)), ...sor.done.map((r) => line("done", r)),
-                    ...(sor.observed ?? []).map(r => line("observed; verify currentness before relying on it", r)),
-                    ...(sor.observed_page ? [`- Observation page: ${sor.observed_page.total} total; next_cursor: ${JSON.stringify(sor.observed_page.next_cursor)}`]
-                        : sor.observed_truncated ? ['- More observations exist; read this subject with observed_page:{} in one partition, then follow next_cursor.'] : []),
-                    ...(sor.invalidated_by.length ? [`- invalidated by: ${sor.invalidated_by.join(", ")}`] : [])].join("\n") || "(nothing on record for this subject)"
-                : "";
-            return stateResult(`${response.receipt_id} · ${summary}${deniedNote}${stateText ? `\n\nState of record:\n${stateText}` : ""}\n\n${envelope.text}`, response);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
-    server.registerTool("nuryel_write", {
-        title: "nuryel.state/1 write — provenance + idempotency in, durability out",
-        description: "Write one record into a facet (receipts, commitments, derived, entities, relationships, or the legacy decisions/constraints/bugs/findings). The record must carry provenance; the request must carry an idempotency_key — a replay returns the original, a reused key with a different payload is refused. Ids are derived from the record's facts, never chosen. A second live decision on a topic is refused with the incumbent named; pass supersedes to replace it explicitly. organization/team/user partitions never ride a repository: they require an overlay. To show an existing captured observation under another subject without copying it, write a relationship type observation_about with from=observation id, to=subject, observation_hash, lifecycle=active, reason and hashed external evidence of the explicit association. Retire the relationship to unlink; reactivation requires expected_version.",
-        inputSchema: { ...WriteRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
-        outputSchema: WriteResultSchema.shape,
-    }, async ({ cwd: _cwd, ...input }) => {
-        try {
-            // Same cross-process lock `hunch serve` takes: a second agent writing over stdio must
-            // not race the HTTP server between the ledger read and the record write.
-            const result = await withWriteLock(hunchPaths(root).hunch, () => writeState(store, { schema: STATE_WRITE_VERSION, ...input }, {
-                flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
-            }));
-            return stateResult(`${result.outcome} ${result.record_id} (${result.durability}) ${result.record_hash}`, result);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
-    server.registerTool("nuryel_capture", {
-        title: "nuryel.state/1 capture — one relevant assertion with exact source excerpts",
-        description: "Save ONE relevant atomic assertion learned during the task. First split mixed source material into independent assertions; check each one, retaining new relevant details inside otherwise known passages. Exclude chatter, speculation, unsupported conclusions and transient tool output. Supply a concrete future-use reason and exact excerpts from the source text. Whole source text is transient and is never stored. Deduplication is per assertion + subject + source excerpt, independent of agent and read time; never skip a whole document because some of it is known. Records are observations, not verified current summaries or execution receipts. Call after substantive learning without waiting for the user to say remember. Read back the returned record before claiming it was saved.",
-        inputSchema: { ...CaptureRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
-        outputSchema: WriteResultSchema.shape,
-    }, async ({ cwd: _cwd, ...input }) => {
-        try {
-            const result = await withWriteLock(hunchPaths(root).hunch, () => captureState(store, { schema: STATE_CAPTURE_VERSION, ...input }, {
-                flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
-            }));
-            return stateResult(`${result.outcome} observation ${result.record_id} (${result.durability}); this does not assert currentness. ${result.record_hash}`, result);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
-    server.registerTool("nuryel_capture_batch", {
-        title: "nuryel.state/1 capture batch — save relevant atomic observations",
-        description: "Preferred capture for multiple facts learned during the task. Split source material into independent relevant assertions, select exact supporting excerpts and give each a concrete future-use reason. Exclude chatter, unsupported inference and transient output. Check every assertion even in a known paragraph: deduplication never discards a whole passage. Send each source once and reference its zero-based index. At most 32 observations and 8 sources; split larger work into batches. One partition lock and index update, no extra model call. Results preserve input indexes; inspect every refusal and stored record. Saved observations have unknown currentness, not verified receipts or current summaries. Use your own initiating agent identity automatically after substantive learning. Optional reviews withdraw specific prior observations: supply record_id, expected_hash, a reason, and exact excerpts from a changed source that observation depends on. Mere hash changes, missing text or uncertain interpretation never suffice; the initiating agent must identify explicit contradiction or withdrawal. Original facts remain in history with the review author and evidence. Review results are separately indexed; inspect every refusal.",
-        inputSchema: { ...CaptureBatchRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
-        outputSchema: CaptureBatchResultSchema.shape,
-    }, async ({ cwd: _cwd, ...input }) => {
-        try {
-            const result = await withWriteLock(hunchPaths(root).hunch, () => captureBatchState(store, { schema: STATE_CAPTURE_BATCH_VERSION, ...input }, {
-                flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
-            }));
-            return stateResult(`Capture batch: ${result.results.filter(r => r.status === "saved").length} saved/replayed, ${result.results.filter(r => r.status === "refused").length} refused.${result.reviews ? ` Reviews: ${result.reviews.filter(r => r.status === "saved").length} withdrawn/replayed, ${result.reviews.filter(r => r.status === "refused").length} refused.` : ''} Inspect each indexed result.`, result);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
-    server.registerTool("nuryel_subscribe", {
-        title: "nuryel.state/1 subscribe — the scope's ordered change stream after a cursor",
-        description: "Return the change events for a scope with seq > after_seq, strictly ordered. Unfiltered, the events are contiguous (a gap means resynchronize); with facets/subjects filters the response is a subsequence and head_seq is still your next cursor. Each event names the record, its hash, what changed, what it invalidates, and the cause.",
-        inputSchema: SubscribeRequestSchema.omit({ schema: true }).shape,
-        outputSchema: SubscribeResponseSchema.shape,
-    }, async (input) => {
-        try {
-            const response = subscribeState(store, { schema: STATE_SUBSCRIBE_VERSION, ...input });
-            const lines = response.events.map((e) => `${e.seq} ${e.at} ${e.change} ${e.facet}/${e.record_id}${e.invalidates.length ? ` invalidates ${e.invalidates.join(", ")}` : ""}`);
-            return stateResult(`${response.scope.kind}/${response.scope.id} head_seq ${response.head_seq} · ${response.events.length} event(s)${response.filtered ? " (filtered)" : ""}\n${lines.join("\n")}`, response);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
-    server.registerTool("nuryel_records", {
-        title: "nuryel.state/1 records — fetch records by id, grants first",
-        description: "Fetch state records by id (from a subscribe event, a read ref, or a write result). Every id is accounted for: found (with its facet), denied (its scope is outside your grants — named, never described) or missing.",
-        inputSchema: RecordsRequestSchema.omit({ schema: true }).shape,
-        outputSchema: RecordsResponseSchema.shape,
-    }, async (input) => {
-        try {
-            const response = recordsState(store, { schema: STATE_RECORDS_VERSION, ...input });
-            const lines = Object.entries(response.records).map(([id, r]) => `- ${response.facets[id]} ${id}: ${JSON.stringify(r).slice(0, 600)}`);
-            const tail = [...(response.missing.length ? [`missing: ${response.missing.join(", ")}`] : []), ...(response.denied.length ? [`denied: ${response.denied.join(", ")}`] : [])];
-            return stateResult(`${Object.keys(response.records).length} record(s)\n${lines.join("\n")}${tail.length ? `\n${tail.join("\n")}` : ""}`, response);
-        }
-        catch (e) {
-            return stateRefusal(e);
-        }
-    });
+    if (toolset.enabled("nuryel")) {
+        server.registerTool("nuryel_capabilities", {
+            title: "nuryel.state/1 — what this state layer supports",
+            description: "Negotiate before depending on anything: returns the contract version, the capability list (verbs + record schemas), the repository partition this store serves, and which partition kinds it can hold. A capability you need that is missing here is a typed refusal on use, never a degraded answer.",
+            inputSchema: {},
+        }, async () => {
+            const caps = capabilities(store);
+            return stateResult(`${caps.protocol} · repository ${caps.repository.id} · partitions ${caps.partitions.join(", ")} · ${caps.capabilities.length} capabilities`, caps);
+        });
+        server.registerTool("nuryel_read", {
+            title: "nuryel.state/1 read — the system-of-record answer for a subject",
+            description: "Read organizational state under a delivery receipt. Pass the principal (id, kind, grants) and the scope; optionally a subject (an entity id, a decision topic, an external `object_type:object_key`) to get state_of_record — what is current, in force, done, what it depends on and what invalidates it — plus a task phrase for the ranked delivery envelope. Scopes the principal is not granted are named in denied_scopes, never silently dropped. To read observations beyond the default 64, use observed_page:{} with one scope and a subject, then pass state_of_record.observed_page.next_cursor as observed_page.cursor until null. A conflict means the observations changed: restart from the first page. Never claim complete coverage while a next cursor remains.",
+            inputSchema: ReadRequestSchema.omit({ schema: true }).shape,
+            outputSchema: ReadResponseSchema.shape,
+        }, async (input) => {
+            try {
+                const { response, envelope } = readState(store, { schema: STATE_READ_VERSION, ...input });
+                const sor = response.state_of_record;
+                const summary = sor
+                    ? `subject ${sor.subject}: current ${sor.current.length} · in force ${sor.in_force.length} · done ${sor.done.length} · observed ${sor.observed?.length ?? 0} · depends on ${sor.depends_on.length} · invalidated by ${sor.invalidated_by.length}`
+                    : "no subject — delivery envelope only";
+                const deniedNote = response.denied_scopes.length ? `\ndenied scopes: ${response.denied_scopes.map((s) => `${s.kind}/${s.id}`).join(", ")}` : "";
+                // Render the state of record itself, not only its refs: a consumer answers from this text.
+                const line = (label, ref) => {
+                    const r = (response.records ?? {})[ref.id] ?? {};
+                    const g = (k) => { const v = r[k]; return typeof v === "string" ? v : v == null ? "" : JSON.stringify(v); };
+                    if (ref.facet === "derived")
+                        return `- ${label} derived ${ref.id} · computed ${g("computed_at")} · ${r.dependencies?.length ?? 0} dependencies\n    ${g("content").slice(0, 1200)}`;
+                    if (ref.facet === "commitments")
+                        return `- ${label} commitment ${ref.id} · ${g("status")} · due ${g("due")} · owner ${g("owner")}: ${g("title")}${r.closed_by ? ` · closed by ${g("closed_by")}` : ""}`;
+                    if (ref.facet === "receipts") {
+                        const t = (r.target ?? {});
+                        // The chain: what the action rested on, one pointer per line, so a reader follows
+                        // incident → decision → change proof → closure without a second call.
+                        const rests = (Array.isArray(r.rests_on) ? r.rests_on : []);
+                        const restLines = rests.map((d) => {
+                            if (d.kind === "record") {
+                                const sc = d.scope;
+                                return `\n    rests on record ${String(d.id)}${sc ? ` in ${String(sc.kind)}/${String(sc.id)}` : ""}`;
+                            }
+                            if (d.kind === "external") {
+                                const x = (d.ref ?? {});
+                                return `\n    rests on ${String(x.system ?? "")} ${String(x.object_type ?? "")}:${String(x.object_key ?? "")}`;
+                            }
+                            return `\n    rests on ${String(d.kind)} ${String(d.name ?? "")}`;
+                        }).join("");
+                        return `- ${label} receipt ${ref.id} · ${g("action_kind")} on ${String(t.system ?? "")} ${String(t.object_type ?? "")}:${String(t.object_key ?? "")} · ${g("state")} at ${g("occurred_at")} by ${g("actor")}${restLines}`;
+                    }
+                    if (ref.facet === "decisions")
+                        return `- ${label} decision ${ref.id} · ${g("status")}: ${g("title")}`;
+                    if (ref.facet === "constraints")
+                        return `- ${label} constraint ${ref.id} · ${g("severity")}: ${g("statement")}`;
+                    if (ref.facet === "entities")
+                        return `- ${label} entity ${ref.id} · ${g("kind")} ${g("name")} · ${g("lifecycle")}`;
+                    return `- ${label} ${ref.facet} ${ref.id}`;
+                };
+                const stateText = sor
+                    ? [...sor.current.map((r) => line("current", r)), ...sor.in_force.map((r) => line("in force", r)), ...sor.done.map((r) => line("done", r)),
+                        ...(sor.observed ?? []).map(r => line("observed; verify currentness before relying on it", r)),
+                        ...(sor.observed_page ? [`- Observation page: ${sor.observed_page.total} total; next_cursor: ${JSON.stringify(sor.observed_page.next_cursor)}`]
+                            : sor.observed_truncated ? ['- More observations exist; read this subject with observed_page:{} in one partition, then follow next_cursor.'] : []),
+                        ...(sor.invalidated_by.length ? [`- invalidated by: ${sor.invalidated_by.join(", ")}`] : [])].join("\n") || "(nothing on record for this subject)"
+                    : "";
+                return stateResult(`${response.receipt_id} · ${summary}${deniedNote}${stateText ? `\n\nState of record:\n${stateText}` : ""}\n\n${envelope.text}`, response);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+        server.registerTool("nuryel_write", {
+            title: "nuryel.state/1 write — provenance + idempotency in, durability out",
+            description: "Write one record into a facet (receipts, commitments, derived, entities, relationships, or the legacy decisions/constraints/bugs/findings). The record must carry provenance; the request must carry an idempotency_key — a replay returns the original, a reused key with a different payload is refused. Ids are derived from the record's facts, never chosen. A second live decision on a topic is refused with the incumbent named; pass supersedes to replace it explicitly. organization/team/user partitions never ride a repository: they require an overlay. To show an existing captured observation under another subject without copying it, write a relationship type observation_about with from=observation id, to=subject, observation_hash, lifecycle=active, reason and hashed external evidence of the explicit association. Retire the relationship to unlink; reactivation requires expected_version.",
+            inputSchema: { ...WriteRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
+            outputSchema: WriteResultSchema.shape,
+        }, async ({ cwd: _cwd, ...input }) => {
+            try {
+                // Same cross-process lock `hunch serve` takes: a second agent writing over stdio must
+                // not race the HTTP server between the ledger read and the record write.
+                const result = await withWriteLock(hunchPaths(root).hunch, () => writeState(store, { schema: STATE_WRITE_VERSION, ...input }, {
+                    flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
+                }));
+                return stateResult(`${result.outcome} ${result.record_id} (${result.durability}) ${result.record_hash}`, result);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+        server.registerTool("nuryel_capture", {
+            title: "nuryel.state/1 capture — one relevant assertion with exact source excerpts",
+            description: "Save ONE relevant atomic assertion learned during the task. First split mixed source material into independent assertions; check each one, retaining new relevant details inside otherwise known passages. Exclude chatter, speculation, unsupported conclusions and transient tool output. Supply a concrete future-use reason and exact excerpts from the source text. Whole source text is transient and is never stored. Deduplication is per assertion + subject + source excerpt, independent of agent and read time; never skip a whole document because some of it is known. Records are observations, not verified current summaries or execution receipts. Call after substantive learning without waiting for the user to say remember. Read back the returned record before claiming it was saved.",
+            inputSchema: { ...CaptureRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
+            outputSchema: WriteResultSchema.shape,
+        }, async ({ cwd: _cwd, ...input }) => {
+            try {
+                const result = await withWriteLock(hunchPaths(root).hunch, () => captureState(store, { schema: STATE_CAPTURE_VERSION, ...input }, {
+                    flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
+                }));
+                return stateResult(`${result.outcome} observation ${result.record_id} (${result.durability}); this does not assert currentness. ${result.record_hash}`, result);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+        server.registerTool("nuryel_capture_batch", {
+            title: "nuryel.state/1 capture batch — save relevant atomic observations",
+            description: "Preferred capture for multiple facts learned during the task. Split source material into independent relevant assertions, select exact supporting excerpts and give each a concrete future-use reason. Exclude chatter, unsupported inference and transient output. Check every assertion even in a known paragraph: deduplication never discards a whole passage. Send each source once and reference its zero-based index. At most 32 observations and 8 sources; split larger work into batches. One partition lock and index update, no extra model call. Results preserve input indexes; inspect every refusal and stored record. Saved observations have unknown currentness, not verified receipts or current summaries. Use your own initiating agent identity automatically after substantive learning. Optional reviews withdraw specific prior observations: supply record_id, expected_hash, a reason, and exact excerpts from a changed source that observation depends on. Mere hash changes, missing text or uncertain interpretation never suffice; the initiating agent must identify explicit contradiction or withdrawal. Original facts remain in history with the review author and evidence. Review results are separately indexed; inspect every refusal.",
+            inputSchema: { ...CaptureBatchRequestSchema.omit({ schema: true }).shape, cwd: cwdHintField },
+            outputSchema: CaptureBatchResultSchema.shape,
+        }, async ({ cwd: _cwd, ...input }) => {
+            try {
+                const result = await withWriteLock(hunchPaths(root).hunch, () => captureBatchState(store, { schema: STATE_CAPTURE_BATCH_VERSION, ...input }, {
+                    flush: (isPrivate, message) => flushCapture(store, hunchPaths(root).hunch, isPrivate, message, startupTeamRoute ?? undefined),
+                }));
+                return stateResult(`Capture batch: ${result.results.filter(r => r.status === "saved").length} saved/replayed, ${result.results.filter(r => r.status === "refused").length} refused.${result.reviews ? ` Reviews: ${result.reviews.filter(r => r.status === "saved").length} withdrawn/replayed, ${result.reviews.filter(r => r.status === "refused").length} refused.` : ''} Inspect each indexed result.`, result);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+        server.registerTool("nuryel_subscribe", {
+            title: "nuryel.state/1 subscribe — the scope's ordered change stream after a cursor",
+            description: "Return the change events for a scope with seq > after_seq, strictly ordered. Unfiltered, the events are contiguous (a gap means resynchronize); with facets/subjects filters the response is a subsequence and head_seq is still your next cursor. Each event names the record, its hash, what changed, what it invalidates, and the cause.",
+            inputSchema: SubscribeRequestSchema.omit({ schema: true }).shape,
+            outputSchema: SubscribeResponseSchema.shape,
+        }, async (input) => {
+            try {
+                const response = subscribeState(store, { schema: STATE_SUBSCRIBE_VERSION, ...input });
+                const lines = response.events.map((e) => `${e.seq} ${e.at} ${e.change} ${e.facet}/${e.record_id}${e.invalidates.length ? ` invalidates ${e.invalidates.join(", ")}` : ""}`);
+                return stateResult(`${response.scope.kind}/${response.scope.id} head_seq ${response.head_seq} · ${response.events.length} event(s)${response.filtered ? " (filtered)" : ""}\n${lines.join("\n")}`, response);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+        server.registerTool("nuryel_records", {
+            title: "nuryel.state/1 records — fetch records by id, grants first",
+            description: "Fetch state records by id (from a subscribe event, a read ref, or a write result). Every id is accounted for: found (with its facet), denied (its scope is outside your grants — named, never described) or missing.",
+            inputSchema: RecordsRequestSchema.omit({ schema: true }).shape,
+            outputSchema: RecordsResponseSchema.shape,
+        }, async (input) => {
+            try {
+                const response = recordsState(store, { schema: STATE_RECORDS_VERSION, ...input });
+                const lines = Object.entries(response.records).map(([id, r]) => `- ${response.facets[id]} ${id}: ${JSON.stringify(r).slice(0, 600)}`);
+                const tail = [...(response.missing.length ? [`missing: ${response.missing.join(", ")}`] : []), ...(response.denied.length ? [`denied: ${response.denied.join(", ")}`] : [])];
+                return stateResult(`${Object.keys(response.records).length} record(s)\n${lines.join("\n")}${tail.length ? `\n${tail.join("\n")}` : ""}`, response);
+            }
+            catch (e) {
+                return stateRefusal(e);
+            }
+        });
+    } // toolset: nuryel
     // -- hunch_findings (read: the open-observations ledger) --------------------
     server.registerTool("hunch_findings", {
         title: "Open findings for a scope",
@@ -2270,78 +2289,80 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
             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}`);
-        }
-    });
+    if (toolset.enabled("constitution-experiments")) {
+        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}`);
+            }
+        });
+    } // toolset: constitution-experiments
     // -- hunch_conformance ----------------------------------------------------
     server.registerTool("hunch_conformance", {
         title: "Does the code still satisfy the recorded intent?",
@@ -2363,106 +2384,108 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
             return err(`Conformance refused an incomplete working graph: ${error.message}`);
         }
     });
-    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)."),
-            cwd: cwdHintField,
-        },
-    }, async ({ decision_id, since, max_commits, limit, allow_install_scripts, dependency_timeout_ms }) => {
-        try {
-            const materialized = 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,
-            });
-            flushMemoryHome(store, hunchPaths(root).hunch, "private", "hunch: materialize G2 behavior policies", startupTeamRoute ?? undefined);
-            const destRoot = resolveDestRoot("private", store, root);
-            return ok(JSON.stringify({ ...materialized, destination: { root: destRoot, branch: currentBranch(destRoot) } }, null, 2));
-        }
-        catch (e) {
-            return err(`Failed to materialize G2 behavior policies: ${e.message}`);
-        }
-    });
+    if (toolset.enabled("constitution-experiments")) {
+        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)."),
+                cwd: cwdHintField,
+            },
+        }, async ({ decision_id, since, max_commits, limit, allow_install_scripts, dependency_timeout_ms }) => {
+            try {
+                const materialized = 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,
+                });
+                flushMemoryHome(store, hunchPaths(root).hunch, "private", "hunch: materialize G2 behavior policies", startupTeamRoute ?? undefined);
+                const destRoot = resolveDestRoot("private", store, root);
+                return ok(JSON.stringify({ ...materialized, destination: { root: destRoot, branch: currentBranch(destRoot) } }, null, 2));
+            }
+            catch (e) {
+                return err(`Failed to materialize G2 behavior policies: ${e.message}`);
+            }
+        });
+    } // toolset: constitution-experiments
     return {
         server,
         getRoot: () => root,