@xmarts/genius-setup 1.7.2 → 1.9.0

package/CLAUDE_PROTOCOL.md

@@ -9,6 +9,10 @@ El Brain de Genius está conectado vía el MCP **`beesmart_genius`** y dos hooks
   learnings, playbooks y patrones relevantes — no tienes que pedirlos.
 - **Captura automática** (SessionEnd/PreCompact/Stop): tus hallazgos y tu sesión se capturan solos al
   final; no tienes que documentar manualmente.
+- **Enforcement de plan/comité** (Stop): si una sesión generó un **plan** o convocó un **comité** pero
+  no se capturó **ningún** learning al Brain, el guard bloquea el cierre **una sola vez** y te recuerda
+  destilarlo con `capture_learning`. Falla-abierto (nunca te atrapa) y se puede ajustar por máquina con
+  `XMA_PLAN_GUARD_MODE=block|warn|off`.
 - **Auto-actualización**: el paquete se refresca solo en segundo plano (1×/día). Cuando agregamos tools,
   skills o features, las recibes en tus turnos **sin hacer nada**.
 
@@ -21,6 +25,13 @@ El Brain de Genius está conectado vía el MCP **`beesmart_genius`** y dos hooks
 5. **NUNCA te conectes directo al Odoo del cliente** — todo fluye por el MCP `beesmart_genius`.
 6. Tu tiempo se sugiere solo a partir de tu actividad; confírmalo cuando puedas en **My Week**
    (`/mcp/webapp/my-week`). Solo el tiempo que confirmas cuenta como horas reales.
+7. **PLAN o COMITÉ ⇒ captura MANDATORIA al Brain.** Siempre que generes un **plan** (modo plan /
+   estrategia aprobada) o convoques un **comité** (multi-agente / Workflow / panel), es OBLIGATORIO
+   destilar sus perspectivas, análisis, soluciones, decision-records y estrategia en learnings vía
+   `capture_learning` (central/universal — **sin** `target_client`) **ANTES de cerrar la tarea**. El
+   análisis de un plan/comité ES conocimiento durable: la tarea **no está terminada** hasta que el Brain
+   quedó alimentado (move-list + hallazgos + alternativas rechazadas + gotchas + pasos human-gated, cada
+   uno con su `forward_directive`). El guard de Stop lo hace cumplir por máquina.
 
 ## Tools (servidas dinámicamente por `beesmart_genius`)
 

package/bin/genius-setup.js

@@ -123,16 +123,17 @@ function runSetup(token) {
     if (secret) { try { fs.chmodSync(p, 0o600); } catch (_) {} }
   }
 
-  // 1) ~/.genius/config.json + hook
+  // 1) ~/.genius/config.json + hook. MERGE into any existing config so state we
+  //    track across runs (e.g. managed_mcp_keys for MCP de-provisioning) survives.
   ensureDir(HOOKS_DIR);
-  const cfg = {
-    base_url: BASE,
-    token: token,
-    capture_endpoint: BASE + '/xma/genius/v1/capture/transcript',
-    inject_endpoint: BASE + '/xma/genius/v1/inject',
-  };
+  const cfgPath0 = path.join(GENIUS_DIR, 'config.json');
+  const cfg = readJson(cfgPath0);
+  cfg.base_url = BASE;
+  cfg.token = token;
+  cfg.capture_endpoint = BASE + '/xma/genius/v1/capture/transcript';
+  cfg.inject_endpoint = BASE + '/xma/genius/v1/inject';
   if (CLIENT) cfg.target_client = CLIENT;
-  writeJson(path.join(GENIUS_DIR, 'config.json'), cfg, true);  // secret: 0600
+  writeJson(cfgPath0, cfg, true);  // secret: 0600
 
   // Copy the hooks shipped alongside this script (capture + per-turn inject).
   function copyHook(fname) {
@@ -148,6 +149,7 @@ function runSetup(token) {
   }
   const hookDst = copyHook('genius_capture.py');
   const injectDst = copyHook('genius_inject.py');
+  const guardDst = copyHook('plan_committee_guard.py');
 
   // 2) ~/.claude.json mcpServers (merge, no clobber)
   const claudeJsonPath = path.join(HOME, '.claude.json');
@@ -179,6 +181,12 @@ function runSetup(token) {
   ['SessionEnd', 'PreCompact', 'Stop'].forEach((e) => addHook(e, hookDst));
   // Per-turn knowledge injection + session priming (consultant_access guarantee).
   ['UserPromptSubmit', 'SessionStart'].forEach((e) => addHook(e, injectDst));
+  // Plan/committee -> Brain capture ENFORCEMENT (CLAUDE.md §6). On Stop it blocks the
+  // turn ONCE if a plan or committee ran this session without any capture_learning.
+  // Fails open, blocks at most once per session, and is mode-overridable per machine
+  // (XMA_PLAN_GUARD_MODE=block|warn|off). Unlike the fire-and-forget hooks above, this
+  // one can return {"decision":"block"} — by design — but never traps a session.
+  addHook('Stop', guardDst);
   writeJson(settingsPath, settings);
 
   // 4) ~/.claude/CLAUDE.md — install/refresh the Genius Protocol between auto-managed
@@ -204,11 +212,103 @@ function runSetup(token) {
     log('WARN: could not write CLAUDE.md protocol (' + e.message + ')');
   }
 
+  // 5) Fan out the consultant's OTHER MCP servers (asana, clickup, google, ...).
+  //    Their non-secret shape (manifest) + per-device secret VALUES come from the
+  //    Bearer-authed /xma/genius/v1/mcp/secrets endpoint. We write Claude Code
+  //    always and Claude Desktop only if it is installed. Fail-open: a fetch
+  //    error never breaks onboarding. Re-runs (self-update / epoch bump) converge.
+  function desktopConfigPath() {
+    try {
+      if (process.platform === 'darwin')
+        return path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      if (process.platform === 'win32')
+        return path.join(process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+      return path.join(HOME, '.config', 'Claude', 'claude_desktop_config.json');
+    } catch (_) { return ''; }
+  }
+  function mcpEntry(srv, secrets, host) {
+    // One mcpServers entry, or null if a required secret is missing (never write a
+    // half-broken server) or it is not portable to this host.
+    const env = {};
+    let ok = true;
+    (srv.env_keys || []).forEach((k) => { if (secrets[k]) env[k] = secrets[k]; else ok = false; });
+    if (!ok) return null;
+    const isHttp = srv.transport === 'http' || srv.transport === 'sse';
+    if (host === 'desktop') {
+      if (srv.host_targets !== 'both' || srv.desktop_strategy === 'skip') return null;
+      if (isHttp) return { command: 'npx', args: ['-y', 'mcp-remote', srv.url] }; // stdio-only Desktop
+      const e = { command: srv.command, args: srv.args || [] };
+      if (Object.keys(env).length) e.env = env;
+      return e;
+    }
+    if (isHttp) return { type: srv.transport, url: srv.url };
+    const e = { type: 'stdio', command: srv.command, args: srv.args || [] };
+    if (Object.keys(env).length) e.env = env;
+    return e;
+  }
+  function writeHostMcps(cfgPath, manifest, secrets, host, prevKeys) {
+    let obj = readJson(cfgPath);
+    if (!obj || typeof obj !== 'object') obj = {};
+    backup(cfgPath);
+    obj.mcpServers = obj.mcpServers || {};
+    // De-provision: drop servers WE previously managed that are no longer granted.
+    (prevKeys || []).forEach((k) => {
+      if (obj.mcpServers[k] && !manifest.find((s) => s.key === k)) delete obj.mcpServers[k];
+    });
+    const nowKeys = [];
+    manifest.forEach((srv) => {
+      const entry = mcpEntry(srv, secrets, host);
+      if (entry) { obj.mcpServers[srv.key] = entry; nowKeys.push(srv.key); }
+      else if (obj.mcpServers[srv.key] && (prevKeys || []).includes(srv.key)) {
+        delete obj.mcpServers[srv.key]; // lost its secret / portability -> remove
+      }
+    });
+    writeJson(cfgPath, obj, true); // may carry env secrets -> 0600
+    return nowKeys;
+  }
+  function provisionMcps(token) {
+    let url;
+    try { url = new URL(BASE + '/xma/genius/v1/mcp/secrets'); } catch (_) { return; }
+    const mod = url.protocol === 'http:' ? require('http') : require('https');
+    const payload = JSON.stringify({ jsonrpc: '2.0', method: 'call', id: 1, params: {} });
+    const req = mod.request({
+      hostname: url.hostname, port: url.port || (url.protocol === 'http:' ? 80 : 443),
+      path: url.pathname, method: 'POST',
+      headers: {
+        'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload),
+        'Authorization': 'Bearer ' + token, 'User-Agent': 'XmartsGenius-Setup/1.6.0',
+      },
+      timeout: 15000,
+    }, (res) => {
+      let data = ''; res.on('data', (c) => { data += c; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data); const r = parsed.result || parsed;
+          if (!r || r.status !== 'ok' || !Array.isArray(r.manifest)) return;
+          const secrets = r.secrets || {};
+          const cfgPath = path.join(GENIUS_DIR, 'config.json');
+          const prev = (readJson(cfgPath).managed_mcp_keys) || [];
+          const managed = writeHostMcps(path.join(HOME, '.claude.json'), r.manifest, secrets, 'code', prev);
+          const dp = desktopConfigPath();
+          if (dp && (fs.existsSync(dp) || fs.existsSync(path.dirname(dp)))) {
+            try { writeHostMcps(dp, r.manifest, secrets, 'desktop', prev); } catch (_) {}
+          }
+          try { const c = readJson(cfgPath); c.managed_mcp_keys = managed; writeJson(cfgPath, c, true); } catch (_) {}
+          if (managed.length) log('  - MCP fan-out   : ' + managed.join(', '));
+        } catch (_) {}
+      });
+    });
+    req.on('error', () => {}); req.on('timeout', () => { try { req.destroy(); } catch (_) {} });
+    req.write(payload); req.end();
+  }
+  provisionMcps(token);
+
   log('');
   log('  Xmarts Genius is set up.');
   log('  - MCP server     : beesmart_genius -> ' + BASE + '/mcp/consultant');
   log('  - Capture hook   : ' + hookDst + '  (SessionEnd / PreCompact / Stop)');
   log('  - Inject hook    : ' + injectDst + '  (UserPromptSubmit / SessionStart)');
+  log('  - Plan/committee : ' + guardDst + '  (Stop — enforces plan/comité → Brain; XMA_PLAN_GUARD_MODE=block|warn|off)');
   log('  - Config         : ' + path.join(GENIUS_DIR, 'config.json'));
   log('  - Protocol       : ' + path.join(CLAUDE_DIR, 'CLAUDE.md') + '  (auto-managed)');
   if (CLIENT) log('  - Default client : ' + CLIENT);

package/hooks/genius_inject.py

@@ -25,6 +25,7 @@ TIMEOUT = 3.5
 SELF_UPDATE_TTL = 86400  # at most once/day
 SELF_UPDATE_STAMP = os.path.join(HOME, ".genius", ".last_selfupdate")
 FORCE_STAMP = os.path.join(HOME, ".genius", ".last_forced_epoch")
+MCP_EPOCH_STAMP = os.path.join(HOME, ".genius", ".last_mcp_epoch")
 
 SESSION_PRIMER = (
     "[Xmarts Genius — Brain connected]\n"
@@ -77,9 +78,10 @@ def _inject(cfg, prompt):
         result = data.get("result", data) or {}
         return ((result.get("context", "") or ""),
                 result.get("hook_force_epoch"),
-                result.get("hook_pin_version"))
+                result.get("hook_pin_version"),
+                result.get("mcp_manifest_epoch"))
     except Exception:
-        return "", None, None
+        return "", None, None, None
 
 
 # M6 (Phase-0 integrity gate): NEVER resolve `@latest`. An unsigned `npx @latest`
@@ -101,7 +103,7 @@ def _pkg_spec(pin_version):
     return "@xmarts/genius-setup@%s" % PINNED_FALLBACK
 
 
-def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
+def _maybe_self_update(cfg, force_epoch=None, pin_version=None, mcp_epoch=None):
     """Keep the consultant on the SERVER-PINNED Genius package with ZERO action: at most
     once/day, silently re-run the installer in the background. New hooks, MCP
     tools, settings and the CLAUDE.md protocol then flow automatically — the
@@ -129,6 +131,18 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
                 forced = fe > last
             except Exception:
                 forced = False
+        # MCP fan-out reconvergence: a newer manifest epoch forces an immediate
+        # re-run (re-provisions ~/.claude.json + Desktop), bypassing the daily TTL.
+        if not forced and mcp_epoch:
+            try:
+                me = int(mcp_epoch)
+                lastm = 0
+                if os.path.exists(MCP_EPOCH_STAMP):
+                    with open(MCP_EPOCH_STAMP) as fh:
+                        lastm = int((fh.read() or "0").strip() or 0)
+                forced = me > lastm
+            except Exception:
+                pass
         if not forced and os.path.exists(SELF_UPDATE_STAMP) and (
                 time.time() - os.path.getmtime(SELF_UPDATE_STAMP)) < SELF_UPDATE_TTL:
             return
@@ -140,6 +154,9 @@ def _maybe_self_update(cfg, force_epoch=None, pin_version=None):
             if force_epoch:
                 with open(FORCE_STAMP, "w") as fh:
                     fh.write(str(int(force_epoch)))
+            if mcp_epoch:
+                with open(MCP_EPOCH_STAMP, "w") as fh:
+                    fh.write(str(int(mcp_epoch)))
         except Exception:
             return
         env = dict(os.environ)
@@ -174,11 +191,12 @@ def main():
         _maybe_self_update(cfg)   # TTL-only on priming
         _emit("SessionStart", SESSION_PRIMER)
     else:
-        context, force_epoch, pin_version = _inject(cfg, event.get("prompt") or "")
+        context, force_epoch, pin_version, mcp_epoch = _inject(cfg, event.get("prompt") or "")
         # The inject call already round-tripped the server, so honour any
         # admin-pushed force-update epoch here (bypasses the daily TTL) and install
-        # the exact server-pinned version (never @latest).
-        _maybe_self_update(cfg, force_epoch, pin_version)
+        # the exact server-pinned version (never @latest). A newer MCP manifest
+        # epoch likewise forces an immediate re-provision of the fan-out servers.
+        _maybe_self_update(cfg, force_epoch, pin_version, mcp_epoch)
         _emit("UserPromptSubmit", context)
 
 

package/hooks/plan_committee_guard.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+plan_committee_guard.py — machine enforcement of the canonical Genius rule:
+
+    "Plan o comité ⇒ captura MANDATORIA al Brain"  (CLAUDE.md §6 / CLAUDE_PROTOCOL.md)
+
+Fires on the Claude Code **Stop** event (end of a main-agent turn). It scans the
+session transcript: if this session generated a PLAN (plan mode / ExitPlanMode, a
+`~/.claude/plans/` file, or the writing-plans skill) or convened a COMMITTEE (a
+`Workflow` run or a subagent fan-out) but captured ZERO learnings to the Genius Brain
+(`mcp__beesmart_genius__capture_learning`), it BLOCKS the Stop once with a directive
+telling Claude to distill the plan/committee into the Brain before finishing.
+
+This is the enforcement layer for THIS session and for EVERY consultant session —
+it ships with @xmarts/genius-setup (npx rail → ~/.genius/hooks/) and the
+`xmarts-genius` plugin (plugin/hooks/hooks.json → ${CLAUDE_PLUGIN_ROOT}/hooks/).
+
+DESIGN GUARANTEES (the §15 "never break a session" discipline):
+  * FAILS OPEN — any parse/IO/unknown error → exit 0 (allow the Stop). A hook must
+    never trap or crash a consultant's session.
+  * BLOCKS AT MOST ONCE per session (state file under ~/.genius/state/). After the
+    single nudge it degrades to a non-blocking log line, so if the Brain is
+    unreachable or Claude can't capture, the user is NEVER trapped in a loop.
+  * Honors `stop_hook_active` to avoid stop-loops.
+  * Only nudges once REAL post-plan work exists (a mutation after the plan signal, or
+    >= MIN_TURNS_AFTER_SIGNAL assistant turns), so it doesn't interrupt mid-planning.
+  * The block is delivered as STDOUT JSON {"decision":"block","reason":...} + exit 0,
+    so it survives the installer's `... || true` command wrapper (which only forces the
+    exit code, not stdout).
+  * Mode override per machine via env:
+        XMA_PLAN_GUARD_MODE = block (default) | warn (log only, never blocks) | off
+
+A single deliberate capture_learning call clears the debt — the guard never audits
+"enough" captures, it only insists the plan/committee was fed to the Brain at all.
+"""
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+# --- tunables (env-overridable) ---------------------------------------------
+MODE = (os.environ.get("XMA_PLAN_GUARD_MODE", "block") or "block").strip().lower()
+try:
+    MIN_TURNS_AFTER_SIGNAL = int(os.environ.get("XMA_PLAN_GUARD_MIN_TURNS", "3"))
+except Exception:
+    MIN_TURNS_AFTER_SIGNAL = 3
+MAX_BLOCKS_PER_SESSION = 1
+SUBAGENT_THRESHOLD = 4  # >= this many Task/Agent subagent calls ≈ a committee fan-out
+
+# --- signal vocabulary ------------------------------------------------------
+PLAN_TOOLS = {"ExitPlanMode", "EnterPlanMode"}
+PLAN_SKILLS = {"writing-plans", "executing-plans"}
+PLAN_FILE_HINT = "/.claude/plans/"
+COMMITTEE_TOOLS = {"Workflow"}
+COMMITTEE_SKILLS = {"dispatching-parallel-agents", "subagent-driven-development"}
+SUBAGENT_TOOLS = {"Task", "Agent"}
+CAPTURE_SUFFIX = "__capture_learning"
+MUTATION_TOOLS = {"Edit", "Write", "MultiEdit", "NotebookEdit", "Bash"}
+MUTATION_SUBSTR = ("create_record", "update_record", "delete_record",
+                   "manage_module", "manage_webapp", "execute_orm", "execute_method")
+
+STATE_DIR = Path(os.path.expanduser("~/.genius/state/plan_committee_guard"))
+LOG_FILE = STATE_DIR / "guard.log"
+
+
+def _log(msg):
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(LOG_FILE, "a") as f:
+            f.write("%s %s\n" % (time.strftime("%Y-%m-%dT%H:%M:%S"), msg))
+    except Exception:
+        pass
+
+
+def _allow():
+    """Allow the Stop (success, no block)."""
+    sys.exit(0)
+
+
+def _iter_tool_uses(obj):
+    """Yield (name, input_dict) for every tool_use block in a transcript line object."""
+    if not isinstance(obj, dict):
+        return
+    msg = obj.get("message")
+    content = msg.get("content") if isinstance(msg, dict) else None
+    if isinstance(content, list):
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "tool_use":
+                yield (item.get("name") or ""), (item.get("input") or {})
+
+
+def _is_assistant(obj):
+    if not isinstance(obj, dict):
+        return False
+    if obj.get("type") == "assistant":
+        return True
+    msg = obj.get("message")
+    return isinstance(msg, dict) and msg.get("role") == "assistant"
+
+
+def _is_mutation(name):
+    if name in MUTATION_TOOLS:
+        return True
+    return any(s in name for s in MUTATION_SUBSTR)
+
+
+def scan(transcript_path):
+    """One pass over the JSONL transcript. Returns detections (cheap pre-filter then parse)."""
+    plan = committee = False
+    capture_count = 0
+    subagent_count = 0
+    committee_from_subagent = False
+    signal_idx = None          # index of first plan/committee signal line
+    mutation_after = False
+    assistant_turns_after = 0
+
+    with open(transcript_path, "r", errors="ignore") as f:
+        for idx, line in enumerate(f):
+            # cheap pre-filter: skip lines that cannot carry a tool_use or an assistant turn
+            if ('"tool_use"' not in line) and ('"assistant"' not in line):
+                continue
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+
+            line_has_signal = False
+            for name, inp in _iter_tool_uses(obj):
+                # --- plan signals ---
+                if name in PLAN_TOOLS:
+                    plan = True
+                    line_has_signal = True
+                if name == "Skill":
+                    sk = (inp.get("skill") or inp.get("command") or "") if isinstance(inp, dict) else ""
+                    if sk in PLAN_SKILLS:
+                        plan = True
+                        line_has_signal = True
+                    if sk in COMMITTEE_SKILLS:
+                        committee = True
+                        line_has_signal = True
+                if name in ("Write", "Edit", "MultiEdit", "NotebookEdit"):
+                    fp = ""
+                    if isinstance(inp, dict):
+                        fp = inp.get("file_path") or inp.get("notebook_path") or ""
+                    if PLAN_FILE_HINT in fp:
+                        plan = True
+                        line_has_signal = True
+                # --- committee signals ---
+                if name in COMMITTEE_TOOLS:
+                    committee = True
+                    line_has_signal = True
+                if name in SUBAGENT_TOOLS:
+                    subagent_count += 1
+                # --- capture (clears the debt) ---
+                if name.endswith(CAPTURE_SUFFIX):
+                    capture_count += 1
+                # --- mutation-after bookkeeping ---
+                if signal_idx is not None and idx > signal_idx and _is_mutation(name):
+                    mutation_after = True
+
+            # subagent fan-out crossing the threshold is itself a committee signal (once)
+            if (not committee_from_subagent) and subagent_count >= SUBAGENT_THRESHOLD:
+                committee = True
+                committee_from_subagent = True
+                line_has_signal = True
+
+            if line_has_signal and signal_idx is None:
+                signal_idx = idx
+
+            if signal_idx is not None and idx > signal_idx and _is_assistant(obj):
+                assistant_turns_after += 1
+
+    return {
+        "plan": plan,
+        "committee": committee,
+        "capture_count": capture_count,
+        "subagent_count": subagent_count,
+        "signal_idx": signal_idx,
+        "mutation_after": mutation_after,
+        "assistant_turns_after": assistant_turns_after,
+    }
+
+
+def main():
+    raw = sys.stdin.read()
+    try:
+        data = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        _allow()
+
+    if MODE == "off":
+        _allow()
+
+    event = data.get("hook_event_name") or ""
+    if event and event != "Stop":
+        # Defensive: this guard only enforces on Stop. Any other wiring → allow.
+        _allow()
+
+    transcript = os.path.expanduser(data.get("transcript_path") or "")
+    if not transcript or not os.path.exists(transcript):
+        _allow()
+
+    try:
+        det = scan(transcript)
+    except Exception as e:
+        _log("scan-error %s" % e)
+        _allow()
+
+    debt = (det["plan"] or det["committee"]) and det["capture_count"] == 0
+    if not debt:
+        _allow()
+
+    kind = "plan" if det["plan"] else "comité"
+    session_id = str(data.get("session_id") or "unknown")
+
+    # never loop on a stop-hook continuation
+    if data.get("stop_hook_active"):
+        _log("session=%s debt=%s stop_hook_active -> allow" % (session_id, kind))
+        _allow()
+
+    # substantial-work gate: don't nudge mid-planning (wait for real post-plan work)
+    substantial = det["mutation_after"] or det["assistant_turns_after"] >= MIN_TURNS_AFTER_SIGNAL
+    if not substantial:
+        _log("session=%s debt=%s not-yet-substantial -> allow" % (session_id, kind))
+        _allow()
+
+    # block-once-per-session state
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state_file = STATE_DIR / ("%s.json" % session_id.replace("/", "_"))
+    state = {}
+    if state_file.exists():
+        try:
+            state = json.loads(state_file.read_text())
+        except Exception:
+            state = {}
+    blocks = int(state.get("blocks", 0))
+
+    if MODE == "warn" or blocks >= MAX_BLOCKS_PER_SESSION:
+        _log("session=%s debt=%s mode=%s blocks=%d -> advise-only (allow)"
+             % (session_id, kind, MODE, blocks))
+        _allow()
+
+    state["blocks"] = blocks + 1
+    state["last"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+    state["kind"] = kind
+    try:
+        state_file.write_text(json.dumps(state))
+    except Exception:
+        pass
+    _log("session=%s debt=%s BLOCK#%d" % (session_id, kind, blocks + 1))
+
+    reason = (
+        u"⛔ Captura-debt al Genius Brain (regla canónica CLAUDE.md §6 / "
+        u"Protocolo de Consultor).\n"
+        u"Esta sesión generó un %s pero NO se capturó ningún learning al Brain "
+        u"(0 llamadas a capture_learning).\n\n"
+        u"ANTES de cerrar: destilá el %s al Brain vía mcp__beesmart_genius__capture_learning "
+        u"(central/universal — SIN target_client). Capturá, como mínimo: la move-list / "
+        u"decisiones, los hallazgos clave + alternativas rechazadas, los gotchas / breaking-changes, "
+        u"y los pasos human-gated — cada uno con su forward_directive (category best_practice o "
+        u"pattern).\n\n"
+        u"Si ya capturaste fuera de esta sesión, o el Brain está inalcanzable: anotalo en una "
+        u"línea y entonces sí podés cerrar (este recordatorio es de UNA sola vez por sesión)."
+    ) % (kind, kind)
+
+    sys.stdout.write(json.dumps({"decision": "block", "reason": reason}))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as e:  # absolute backstop — never break a session
+        _log("fatal %s" % e)
+        sys.exit(0)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xmarts/genius-setup",
-  "version": "1.7.2",
-  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + CLAUDE.md protocol). Secret-free onboarding via single-use setup-token exchange (no Bearer in the GET-able bootstrap). Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
+  "version": "1.9.0",
+  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + plan/committee→Brain enforcement + CLAUDE.md protocol + MCP fan-out: provisions the consultant's granted MCP servers into Claude Code & Claude Desktop). Secret-free onboarding via single-use setup-token exchange. Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
   "bin": {
     "genius-setup": "bin/genius-setup.js"
   },
@@ -9,6 +9,7 @@
     "bin/genius-setup.js",
     "hooks/genius_inject.py",
     "hooks/genius_capture.py",
+    "hooks/plan_committee_guard.py",
     "CLAUDE_PROTOCOL.md",
     "README.md"
   ],