delimit-cli 3.8.2 → 3.9.1

package/bin/delimit-setup.js

@@ -98,6 +98,25 @@ async function main() {
         fs.copyFileSync(serverSource, path.join(DELIMIT_HOME, 'server', 'mcp-server.py'));
     }
 
+    // Download compiled Pro modules (platform-specific)
+    const proDir = path.join(DELIMIT_HOME, 'server', 'ai');
+    const pyVer = (() => { try { return execSync(`${python} -c "import sys; print(f'cp{sys.version_info.major}{sys.version_info.minor}')"`, { encoding: 'utf-8' }).trim(); } catch { return 'cp310'; } })();
+    const arch = (() => { try { return execSync('uname -m', { encoding: 'utf-8' }).trim(); } catch { return 'x86_64'; } })();
+    const osName = process.platform === 'darwin' ? 'macos' : 'linux';
+    const artifact = `${osName}-${arch}-${pyVer}`;
+    const proVersion = '3.8.2';
+    const proUrl = `https://delimit.ai/releases/v${proVersion}/delimit-pro-${artifact}.tar.gz`;
+
+    try {
+        const proTarball = path.join(DELIMIT_HOME, 'pro.tar.gz');
+        execSync(`curl -sL "${proUrl}" -o "${proTarball}" --fail`, { stdio: 'pipe', timeout: 30000 });
+        execSync(`tar -xzf "${proTarball}" -C "${proDir}"`, { stdio: 'pipe' });
+        fs.unlinkSync(proTarball);
+        log(`  ${green('✓')} Pro modules installed (${artifact})`);
+    } catch {
+        log(`  ${dim('  Pro modules not available for ${artifact} — free tools work fine')}`);
+    }
+
     // Install Python deps into isolated venv with pinned versions
     log(`  ${dim('  Installing Python dependencies...')}`);
     const venvDir = path.join(DELIMIT_HOME, 'venv');

package/gateway/ai/deliberation.py

@@ -1,450 +1,20 @@
 """
-Delimit Deliberation Engine — Multi-round consensus with real model-to-model debate.
-
-Passes each model's EXACT raw response to the other models for counter-arguments.
-Rounds continue until unanimous agreement or max rounds reached.
-
-Models are configured via ~/.delimit/models.json — users choose which AI models
-to include in deliberations. Supports any OpenAI-compatible API.
+Delimit Deliberation Engine — Multi-model consensus.
+The full engine is distributed as a compiled binary (.so/.pyd).
+Install compiled modules: npx delimit-cli setup
 """
 
-import json
-import logging
-import os
-import shutil
-import time
-import urllib.request
-import urllib.error
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger("delimit.deliberation")
-
-DELIBERATION_DIR = Path.home() / ".delimit" / "deliberations"
-MODELS_CONFIG = Path.home() / ".delimit" / "models.json"
-
-DEFAULT_MODELS = {
-    "grok": {
-        "name": "Grok",
-        "api_url": "https://api.x.ai/v1/chat/completions",
-        "model": "grok-4-0709",
-        "env_key": "XAI_API_KEY",
-        "enabled": False,
-    },
-    "gemini": {
-        "name": "Gemini",
-        "api_url": "https://us-central1-aiplatform.googleapis.com/v1/projects/{project}/locations/us-central1/publishers/google/models/gemini-2.5-flash:generateContent",
-        "model": "gemini-2.5-flash",
-        "env_key": "GOOGLE_APPLICATION_CREDENTIALS",
-        "enabled": False,
-        "format": "vertex_ai",
-        "prefer_cli": True,  # Use gemini CLI if available (Ultra plan), fall back to Vertex AI
-        "cli_command": "gemini",
-    },
-    "openai": {
-        "name": "OpenAI",
-        "api_url": "https://api.openai.com/v1/chat/completions",
-        "model": "gpt-4o",
-        "env_key": "OPENAI_API_KEY",
-        "enabled": False,
-        "prefer_cli": True,  # Use Codex CLI if available, fall back to API
-    },
-    "anthropic": {
-        "name": "Claude",
-        "api_url": "https://api.anthropic.com/v1/messages",
-        "model": "claude-sonnet-4-5-20250514",
-        "env_key": "ANTHROPIC_API_KEY",
-        "enabled": False,
-        "format": "anthropic",
-        "prefer_cli": True,  # Use claude CLI if available (Pro/Max), fall back to API
-        "cli_command": "claude",
-    },
-}
-
-
-def get_models_config() -> Dict[str, Any]:
-    """Load model configuration. Auto-detects available API keys."""
-    if MODELS_CONFIG.exists():
-        try:
-            return json.loads(MODELS_CONFIG.read_text())
-        except Exception:
-            pass
-
-    # Auto-detect from environment
-    config = {}
-    for model_id, defaults in DEFAULT_MODELS.items():
-        key = os.environ.get(defaults.get("env_key", ""), "")
-
-        if defaults.get("prefer_cli"):
-            # Prefer CLI (uses existing subscription) over API (extra cost)
-            import shutil
-            cli_cmd = defaults.get("cli_command", "codex")
-            cli_path = shutil.which(cli_cmd)
-            if cli_path:
-                config[model_id] = {
-                    **defaults,
-                    "format": "codex_cli",
-                    "enabled": True,
-                    "codex_path": cli_path,
-                    "backend": "cli",
-                }
-            elif key:
-                config[model_id] = {
-                    **defaults,
-                    "api_key": key,
-                    "enabled": True,
-                    "backend": "api",
-                }
-            else:
-                config[model_id] = {**defaults, "enabled": False}
-        else:
-            config[model_id] = {
-                **defaults,
-                "api_key": key,
-                "enabled": bool(key),
-            }
-
-    return config
-
-
-def configure_models() -> Dict[str, Any]:
-    """Return current model configuration and what's available."""
-    config = get_models_config()
-    available = {k: v for k, v in config.items() if v.get("enabled")}
-    missing = {k: v for k, v in config.items() if not v.get("enabled")}
-
-    model_details = {}
-    for k, v in available.items():
-        backend = v.get("backend", "api")
-        if v.get("format") == "codex_cli":
-            backend = "cli"
-        model_details[k] = {"name": v.get("name", k), "backend": backend, "model": v.get("model", "")}
-
-    return {
-        "configured_models": list(available.keys()),
-        "model_details": model_details,
-        "missing_models": {k: f"Set {v.get('env_key', 'key')} or install {v.get('cli_command', '')} CLI" for k, v in missing.items()},
-        "config_path": str(MODELS_CONFIG),
-        "note": "CLI backends use your existing subscription (no extra API cost). "
-                "API backends require separate API keys.",
-    }
-
-
-def _call_cli(prompt: str, system_prompt: str = "", cli_path: str = "", cli_command: str = "codex") -> str:
-    """Call an AI CLI tool (codex or claude) via subprocess. Uses existing subscription — no API cost."""
-    import subprocess
-
-    if not cli_path:
-        cli_path = shutil.which(cli_command) or ""
-    if not cli_path:
-        return f"[{cli_command} unavailable — CLI not found in PATH]"
-
-    full_prompt = f"{system_prompt}\n\n{prompt}" if system_prompt else prompt
-
-    # Build command based on which CLI
-    if "claude" in cli_command:
-        cmd = [cli_path, "--print", "--dangerously-skip-permissions", full_prompt]
-    else:
-        # codex
-        cmd = [cli_path, "exec", "--dangerously-bypass-approvals-and-sandbox", full_prompt]
-
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
-        output = result.stdout.strip()
-        if not output and result.stderr:
-            return f"[{cli_command} error: {result.stderr[:300]}]"
-        return output or f"[{cli_command} returned empty response]"
-    except subprocess.TimeoutExpired:
-        return f"[{cli_command} timed out after 120s]"
-    except Exception as e:
-        return f"[{cli_command} error: {e}]"
-
-
-def _call_model(model_id: str, config: Dict, prompt: str, system_prompt: str = "") -> str:
-    """Call any supported model — OpenAI-compatible API, Vertex AI, or CLI (codex/claude)."""
-    fmt = config.get("format", "openai")
-
-    # CLI-based models (codex, claude) — uses existing subscription, no API cost
-    if fmt == "codex_cli":
-        cli_path = config.get("codex_path", "")
-        cli_command = config.get("cli_command", "codex")
-        return _call_cli(prompt, system_prompt, cli_path=cli_path, cli_command=cli_command)
-
-    api_key = config.get("api_key") or os.environ.get(config.get("env_key", ""), "")
-    # Vertex AI uses service account auth, not API key
-    if not api_key and fmt != "vertex_ai":
-        return f"[{config.get('name', model_id)} unavailable — {config.get('env_key')} not set]"
-
-    api_url = config["api_url"]
-    model = config.get("model", "")
-
-    try:
-        if fmt == "vertex_ai":
-            # Vertex AI format — use google-auth for access token
-            try:
-                import google.auth
-                import google.auth.transport.requests
-                # Explicitly set credentials path if not in env
-                creds_path = "/root/.config/gcloud/application_default_credentials.json"
-                if not os.environ.get("GOOGLE_APPLICATION_CREDENTIALS") and os.path.exists(creds_path):
-                    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = creds_path
-                creds, project = google.auth.default()
-                creds.refresh(google.auth.transport.requests.Request())
-                actual_url = api_url.replace("{project}", project or os.environ.get("GOOGLE_CLOUD_PROJECT", ""))
-                data = json.dumps({
-                    "contents": [{"role": "user", "parts": [{"text": f"{system_prompt}\n\n{prompt}" if system_prompt else prompt}]}],
-                    "generationConfig": {"maxOutputTokens": 4096, "temperature": 0.7},
-                }).encode()
-                req = urllib.request.Request(
-                    actual_url,
-                    data=data,
-                    headers={
-                        "Authorization": f"Bearer {creds.token}",
-                        "Content-Type": "application/json",
-                    },
-                    method="POST",
-                )
-            except ImportError:
-                return f"[Gemini unavailable — install google-auth: pip install google-auth]"
-        elif fmt == "google":
-            # Google Generative AI format (API key)
-            data = json.dumps({
-                "contents": [{"role": "user", "parts": [{"text": f"{system_prompt}\n\n{prompt}" if system_prompt else prompt}]}],
-                "generationConfig": {"maxOutputTokens": 4096, "temperature": 0.7},
-            }).encode()
-            req = urllib.request.Request(
-                f"{api_url}?key={api_key}",
-                data=data,
-                headers={"Content-Type": "application/json"},
-                method="POST",
-            )
-        elif fmt == "anthropic":
-            # Anthropic Messages API
-            data = json.dumps({
-                "model": model,
-                "max_tokens": 4096,
-                "system": system_prompt or "You are a helpful assistant participating in a multi-model deliberation.",
-                "messages": [{"role": "user", "content": prompt}],
-            }).encode()
-            req = urllib.request.Request(
-                api_url,
-                data=data,
-                headers={
-                    "x-api-key": api_key,
-                    "anthropic-version": "2023-06-01",
-                    "Content-Type": "application/json",
-                    "User-Agent": "Delimit/3.6.0",
-                },
-                method="POST",
-            )
-        else:
-            # OpenAI-compatible format (works for xAI, OpenAI, etc.)
-            messages = []
-            if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
-            messages.append({"role": "user", "content": prompt})
-
-            data = json.dumps({
-                "model": model,
-                "messages": messages,
-                "temperature": 0.7,
-                "max_tokens": 4096,
-            }).encode()
-            req = urllib.request.Request(
-                api_url,
-                data=data,
-                headers={
-                    "Authorization": f"Bearer {api_key}",
-                    "Content-Type": "application/json",
-                    "User-Agent": "Delimit/3.6.0",
-                },
-                method="POST",
-            )
-
-        with urllib.request.urlopen(req, timeout=120) as resp:
-            result = json.loads(resp.read())
-
-        if fmt in ("google", "vertex_ai"):
-            return result["candidates"][0]["content"]["parts"][0]["text"]
-        elif fmt == "anthropic":
-            return result["content"][0]["text"]
-        else:
-            return result["choices"][0]["message"]["content"]
-
-    except Exception as e:
-        return f"[{config.get('name', model_id)} error: {e}]"
-
-
-def deliberate(
-    question: str,
-    context: str = "",
-    max_rounds: int = 3,
-    mode: str = "dialogue",
-    require_unanimous: bool = True,
-    save_path: Optional[str] = None,
-) -> Dict[str, Any]:
-    """
-    Run a multi-round deliberation across all configured AI models.
-
-    Modes:
-      - "debate": Long-form essays, models respond to each other's full arguments (3 rounds default)
-      - "dialogue": Short conversational turns, models build on each other like a group chat (6 rounds default)
-
-    Returns the full deliberation transcript + final verdict.
-    """
-    DELIBERATION_DIR.mkdir(parents=True, exist_ok=True)
-
-    config = get_models_config()
-    enabled_models = {k: v for k, v in config.items() if v.get("enabled")}
-
-    if len(enabled_models) < 2:
-        return {
-            "error": "Need at least 2 AI models for deliberation.",
-            "configured": list(enabled_models.keys()),
-            "missing": {k: f"Set {v.get('env_key', 'key')}" for k, v in config.items() if not v.get("enabled")},
-            "tip": "Set API key environment variables or create ~/.delimit/models.json",
-        }
-
-    model_ids = list(enabled_models.keys())
-
-    # Dialogue mode uses more rounds with shorter responses
-    if mode == "dialogue" and max_rounds == 3:
-        max_rounds = 6
-
-    transcript = {
-        "question": question,
-        "context": context,
-        "mode": mode,
-        "models": model_ids,
-        "started_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "rounds": [],
-        "thread": [],  # flat conversation thread for dialogue mode
-        "unanimous": False,
-        "final_verdict": None,
-    }
-
-    if mode == "dialogue":
-        system_prompt = (
-            "You are in a group chat with other AI models. Keep responses to 2-4 sentences. "
-            "Be direct and conversational — this is a discussion, not an essay. "
-            "Build on what others said. Disagree specifically if you disagree. "
-            "When you're ready to agree, say VERDICT: AGREE. "
-            "If you disagree, say VERDICT: DISAGREE — [why in one sentence]."
-        )
-    else:
-        system_prompt = (
-            "You are participating in a structured multi-model deliberation with other AI models. "
-            "You will see other models' exact responses and must engage with their specific arguments. "
-            "At the END of your response, you MUST include exactly one of these lines:\n"
-            "VERDICT: AGREE\n"
-            "VERDICT: DISAGREE — [one sentence reason]\n"
-            "VERDICT: AGREE WITH MODIFICATIONS — [one sentence modification]\n"
-            "Do not hedge. Take a clear position."
-        )
-
-    full_prompt = f"{context}\n\nQUESTION:\n{question}" if context else question
-
-    # Round 1: Independent responses
-    logger.info(f"Deliberation Round 1 ({mode} mode): Independent responses")
-    round1 = {"round": 1, "type": "independent", "responses": {}}
-
-    for model_id in model_ids:
-        if mode == "dialogue":
-            # Shorter initial prompt for dialogue
-            r1_prompt = f"{full_prompt}\n\nGive your initial take in 2-4 sentences. Don't write an essay."
-        else:
-            r1_prompt = full_prompt
-        response = _call_model(model_id, enabled_models[model_id], r1_prompt, system_prompt)
-        round1["responses"][model_id] = response
-        # Build flat thread
-        transcript["thread"].append({"model": model_id, "round": 1, "text": response})
-        logger.info(f"  {model_id}: {len(response)} chars")
-
-    transcript["rounds"].append(round1)
-
-    # Subsequent rounds: Models see each other's responses
-    for round_num in range(2, max_rounds + 1):
-        logger.info(f"Deliberation Round {round_num} ({mode})")
-        round_data = {"round": round_num, "type": "deliberation", "responses": {}}
-        prev = transcript["rounds"][-1]["responses"]
-
-        for model_id in model_ids:
-            if mode == "dialogue":
-                # Dialogue: show the full conversation thread so far
-                thread_text = f"Topic: {question}\n\nConversation so far:\n"
-                for entry in transcript["thread"]:
-                    name = enabled_models.get(entry["model"], {}).get("name", entry["model"])
-                    thread_text += f"\n[{name}]: {entry['text']}\n"
-                thread_text += (
-                    f"\nYour turn ({enabled_models[model_id]['name']}). "
-                    f"Respond in 2-4 sentences to the conversation above. "
-                    f"If you agree with the emerging consensus, say VERDICT: AGREE. "
-                    f"If not, push back specifically."
-                )
-                cross_prompt = thread_text
-            else:
-                # Debate: show other models' full responses from last round
-                others_text = ""
-                for other_id in model_ids:
-                    if other_id != model_id:
-                        others_text += (
-                            f"\n=== {enabled_models[other_id]['name'].upper()}'S EXACT RESPONSE "
-                            f"(Round {round_num - 1}) ===\n"
-                            f"{prev[other_id]}\n"
-                        )
-                cross_prompt = (
-                    f"DELIBERATION ROUND {round_num}\n\n"
-                    f"Original question: {question}\n"
-                    f"{others_text}\n"
-                    f"Respond to the other models' SPECIFIC arguments. "
-                    f"Quote them directly if you disagree. "
-                    f"End with VERDICT: AGREE / DISAGREE / AGREE WITH MODIFICATIONS."
-                )
-
-            response = _call_model(model_id, enabled_models[model_id], cross_prompt, system_prompt)
-            round_data["responses"][model_id] = response
-            transcript["thread"].append({"model": model_id, "round": round_num, "text": response})
-
-        transcript["rounds"].append(round_data)
-
-        # Check for unanimous agreement
-        all_agree = True
-        for model_id in model_ids:
-            resp = round_data["responses"][model_id].upper()
-            if "VERDICT:" in resp:
-                verdict_part = resp.split("VERDICT:")[-1].strip()
-                agrees = verdict_part.startswith("AGREE")
-                if not agrees:
-                    all_agree = False
-            else:
-                all_agree = False  # No verdict = no agreement
-
-        if all_agree:
-            transcript["unanimous"] = True
-            transcript["final_verdict"] = "UNANIMOUS AGREEMENT"
-            transcript["agreed_at_round"] = round_num
-            break
-    else:
-        # Max rounds reached
-        transcript["final_verdict"] = "MAX ROUNDS REACHED"
-        for model_id in model_ids:
-            resp = transcript["rounds"][-1]["responses"][model_id].upper()
-            verdict = "unknown"
-            if "VERDICT:" in resp:
-                verdict_part = resp.split("VERDICT:")[-1].strip()
-                verdict = "agree" if verdict_part.startswith("AGREE") else "disagree"
-            transcript[f"{model_id}_final"] = verdict
+def get_models_config():
+    raise ImportError("Deliberation engine requires Pro module. Run: npx delimit-cli setup")
 
-    transcript["completed_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+def configure_models():
+    raise ImportError("Deliberation engine requires Pro module. Run: npx delimit-cli setup")
 
-    # Save transcript
-    save_to = save_path
-    if not save_to:
-        ts = time.strftime("%Y%m%d_%H%M%S")
-        save_to = str(DELIBERATION_DIR / f"deliberation_{ts}.json")
+def deliberate(**kwargs):
+    raise ImportError("Deliberation engine requires Pro module. Run: npx delimit-cli setup")
 
-    Path(save_to).parent.mkdir(parents=True, exist_ok=True)
-    Path(save_to).write_text(json.dumps(transcript, indent=2))
-    transcript["saved_to"] = save_to
+def _call_cli(*args, **kwargs):
+    raise ImportError("Deliberation engine requires Pro module.")
 
-    return transcript
+def _call_model(*args, **kwargs):
+    raise ImportError("Deliberation engine requires Pro module.")

package/gateway/ai/governance.py

@@ -1,391 +1,11 @@
 """
 Delimit Governance Layer — the loop that keeps AI agents on track.
-
-Every tool flows through governance. Governance:
-1. Logs what happened (evidence)
-2. Checks result against rules (thresholds, policies)
-3. Auto-creates ledger items for failures/warnings
-4. Suggests next steps (loops back to keep building)
-
-This replaces _with_next_steps — governance IS the next step system.
+The full engine is distributed as a compiled binary (.so/.pyd).
+Install compiled modules: npx delimit-cli setup
 """
 
-import json
-import logging
-import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger("delimit.governance")
-
-
-# Governance rules — what triggers auto-ledger-creation
-RULES = {
-    "test_coverage": {
-        "threshold_key": "line_coverage",
-        "threshold": 80,
-        "comparison": "below",
-        "ledger_title": "Test coverage below {threshold}% — currently {value}%",
-        "ledger_type": "fix",
-        "ledger_priority": "P1",
-    },
-    "security_audit": {
-        "trigger_key": "vulnerabilities",
-        "trigger_if_nonempty": True,
-        "ledger_title": "Security: {count} vulnerabilities found",
-        "ledger_type": "fix",
-        "ledger_priority": "P0",
-    },
-    "security_scan": {
-        "trigger_key": "vulnerabilities",
-        "trigger_if_nonempty": True,
-        "ledger_title": "Security scan: {count} issues detected",
-        "ledger_type": "fix",
-        "ledger_priority": "P0",
-    },
-    "lint": {
-        "trigger_key": "violations",
-        "trigger_if_nonempty": True,
-        "ledger_title": "API lint: {count} violations found",
-        "ledger_type": "fix",
-        "ledger_priority": "P1",
-    },
-    "deliberate": {
-        "trigger_key": "unanimous",
-        "trigger_if_true": True,
-        "extract_actions": True,
-        "ledger_title": "Deliberation consensus reached — action items pending",
-        "ledger_type": "strategy",
-        "ledger_priority": "P1",
-    },
-    "gov_health": {
-        "trigger_key": "status",
-        "trigger_values": ["not_initialized", "degraded"],
-        "ledger_title": "Governance health: {value} — needs attention",
-        "ledger_type": "fix",
-        "ledger_priority": "P1",
-    },
-    "docs_validate": {
-        "threshold_key": "coverage_percent",
-        "threshold": 50,
-        "comparison": "below",
-        "ledger_title": "Documentation coverage below {threshold}% — currently {value}%",
-        "ledger_type": "task",
-        "ledger_priority": "P2",
-    },
-}
-
-# Milestone rules — auto-create DONE ledger items for significant completions.
-# Unlike threshold RULES (which create open items for problems), milestones
-# record achievements so the ledger reflects what was shipped.
-MILESTONES = {
-    "deploy_site": {
-        "trigger_key": "status",
-        "trigger_values": ["deployed"],
-        "ledger_title": "Deployed: {project}",
-        "ledger_type": "feat",
-        "ledger_priority": "P1",
-        "auto_done": True,
-    },
-    "deploy_npm": {
-        "trigger_key": "status",
-        "trigger_values": ["published"],
-        "ledger_title": "Published: {package}@{new_version}",
-        "ledger_type": "feat",
-        "ledger_priority": "P1",
-        "auto_done": True,
-    },
-    "deliberate": {
-        "trigger_key": "status",
-        "trigger_values": ["unanimous"],
-        "ledger_title": "Consensus reached: {question_short}",
-        "ledger_type": "strategy",
-        "ledger_priority": "P1",
-        "auto_done": True,
-    },
-    "test_generate": {
-        "threshold_key": "tests_generated",
-        "threshold": 10,
-        "comparison": "above",
-        "ledger_title": "Generated {value} tests",
-        "ledger_type": "feat",
-        "ledger_priority": "P2",
-        "auto_done": True,
-    },
-    "sensor_github_issue": {
-        "trigger_key": "has_new_activity",
-        "trigger_if_true": True,
-        "ledger_title": "Outreach response: new activity detected",
-        "ledger_type": "task",
-        "ledger_priority": "P1",
-        "auto_done": False,  # needs follow-up
-    },
-    "zero_spec": {
-        "trigger_key": "success",
-        "trigger_if_true": True,
-        "ledger_title": "Zero-spec extracted: {framework} ({paths_count} paths)",
-        "ledger_type": "feat",
-        "ledger_priority": "P2",
-        "auto_done": True,
-    },
-}
-
-# Next steps registry — what to do after each tool
-NEXT_STEPS = {
-    "lint": [
-        {"tool": "delimit_explain", "reason": "Get migration guide for violations", "premium": False},
-        {"tool": "delimit_semver", "reason": "Classify the version bump", "premium": False},
-    ],
-    "diff": [
-        {"tool": "delimit_semver", "reason": "Classify changes as MAJOR/MINOR/PATCH", "premium": False},
-        {"tool": "delimit_policy", "reason": "Check against governance policies", "premium": False},
-    ],
-    "semver": [
-        {"tool": "delimit_explain", "reason": "Generate human-readable changelog", "premium": False},
-        {"tool": "delimit_deploy_npm", "reason": "Publish the new version to npm", "premium": False},
-    ],
-    "init": [
-        {"tool": "delimit_gov_health", "reason": "Verify governance is set up correctly", "premium": True},
-        {"tool": "delimit_diagnose", "reason": "Check for any issues", "premium": False},
-    ],
-    "deploy_site": [
-        {"tool": "delimit_deploy_npm", "reason": "Publish npm package if applicable", "premium": False},
-        {"tool": "delimit_ledger_context", "reason": "Check what else needs deploying", "premium": False},
-    ],
-    "test_coverage": [
-        {"tool": "delimit_test_generate", "reason": "Generate tests for uncovered files", "premium": False},
-    ],
-    "security_audit": [
-        {"tool": "delimit_evidence_collect", "reason": "Collect evidence of findings", "premium": True},
-    ],
-    "gov_health": [
-        {"tool": "delimit_gov_status", "reason": "See detailed governance status", "premium": True},
-        {"tool": "delimit_repo_analyze", "reason": "Full repo health report", "premium": True},
-    ],
-    "deploy_npm": [
-        {"tool": "delimit_deploy_verify", "reason": "Verify the published package", "premium": True},
-    ],
-    "deploy_plan": [
-        {"tool": "delimit_deploy_build", "reason": "Build the deployment", "premium": True},
-    ],
-    "deploy_build": [
-        {"tool": "delimit_deploy_publish", "reason": "Publish the build", "premium": True},
-    ],
-    "deploy_publish": [
-        {"tool": "delimit_deploy_verify", "reason": "Verify the deployment", "premium": True},
-    ],
-    "deploy_verify": [
-        {"tool": "delimit_deploy_rollback", "reason": "Rollback if unhealthy", "premium": True},
-    ],
-    "repo_analyze": [
-        {"tool": "delimit_security_audit", "reason": "Scan for security issues", "premium": False},
-        {"tool": "delimit_gov_health", "reason": "Check governance status", "premium": True},
-    ],
-    "deliberate": [
-        {"tool": "delimit_ledger_context", "reason": "Review what's on the ledger after consensus", "premium": False},
-    ],
-    "ledger_add": [
-        {"tool": "delimit_ledger_context", "reason": "See updated ledger state", "premium": False},
-    ],
-    "diagnose": [
-        {"tool": "delimit_init", "reason": "Initialize governance if not set up", "premium": False},
-    ],
-}
-
-
-def govern(tool_name: str, result: Dict[str, Any], project_path: str = ".") -> Dict[str, Any]:
-    """
-    Run governance on a tool's result. This is the central loop.
-
-    1. Check result against rules
-    2. Auto-create ledger items if thresholds breached
-    3. Add next_steps for the AI to continue
-    4. Return enriched result
-
-    Every tool should call this before returning.
-    """
-    # Strip "delimit_" prefix for rule matching
-    clean_name = tool_name.replace("delimit_", "")
-
-    governed_result = dict(result)
-
-    # 1. Check governance rules
-    rule = RULES.get(clean_name)
-    auto_items = []
-
-    if rule:
-        triggered = False
-        context = {}
-
-        # Threshold check (e.g., coverage < 80%)
-        if "threshold_key" in rule:
-            value = _deep_get(result, rule["threshold_key"])
-            if value is not None:
-                threshold = rule["threshold"]
-                if rule.get("comparison") == "below" and value < threshold:
-                    triggered = True
-                    context = {"value": f"{value:.1f}" if isinstance(value, float) else str(value), "threshold": str(threshold)}
-
-        # Non-empty list check (e.g., vulnerabilities found)
-        if "trigger_key" in rule and "trigger_if_nonempty" in rule:
-            items = _deep_get(result, rule["trigger_key"])
-            if items and isinstance(items, list) and len(items) > 0:
-                triggered = True
-                context = {"count": str(len(items))}
-
-        # Value match check (e.g., status == "degraded")
-        if "trigger_key" in rule and "trigger_values" in rule:
-            value = _deep_get(result, rule["trigger_key"])
-            if value in rule["trigger_values"]:
-                triggered = True
-                context = {"value": str(value)}
-
-        # Boolean check (e.g., unanimous == True)
-        if "trigger_key" in rule and "trigger_if_true" in rule:
-            value = _deep_get(result, rule["trigger_key"])
-            if value:
-                triggered = True
-
-        if triggered:
-            title = rule["ledger_title"].format(**context) if context else rule["ledger_title"]
-            auto_items.append({
-                "title": title,
-                "type": rule.get("ledger_type", "task"),
-                "priority": rule.get("ledger_priority", "P1"),
-                "source": f"governance:{clean_name}",
-            })
-
-    # 1b. Check milestone rules (auto-create DONE items for achievements)
-    milestone = MILESTONES.get(clean_name)
-    if milestone:
-        m_triggered = False
-        m_context = {}
-
-        # Value match (e.g., status == "deployed")
-        if "trigger_key" in milestone and "trigger_values" in milestone:
-            value = _deep_get(result, milestone["trigger_key"])
-            if value in milestone["trigger_values"]:
-                m_triggered = True
-                m_context = {"value": str(value)}
-
-        # Boolean check (e.g., success == True)
-        if "trigger_key" in milestone and milestone.get("trigger_if_true"):
-            value = _deep_get(result, milestone["trigger_key"])
-            if value:
-                m_triggered = True
-
-        # Threshold above (e.g., tests_generated > 10)
-        if "threshold_key" in milestone:
-            value = _deep_get(result, milestone["threshold_key"])
-            if value is not None:
-                threshold = milestone["threshold"]
-                if milestone.get("comparison") == "above" and value > threshold:
-                    m_triggered = True
-                    m_context = {"value": str(value), "threshold": str(threshold)}
-
-        if m_triggered:
-            # Build context from result fields for title interpolation
-            for key in ("project", "package", "new_version", "framework", "paths_count", "repo"):
-                if key not in m_context:
-                    v = _deep_get(result, key)
-                    if v is not None:
-                        m_context[key] = str(v)
-            # Special: short question for deliberations
-            if "question_short" not in m_context:
-                q = _deep_get(result, "question") or _deep_get(result, "note") or ""
-                m_context["question_short"] = str(q)[:80]
-
-            try:
-                title = milestone["ledger_title"].format(**m_context)
-            except (KeyError, IndexError):
-                title = milestone["ledger_title"]
-
-            auto_items.append({
-                "title": title,
-                "type": milestone.get("ledger_type", "feat"),
-                "priority": milestone.get("ledger_priority", "P1"),
-                "source": f"milestone:{clean_name}",
-                "auto_done": milestone.get("auto_done", True),
-            })
-
-    # 2. Auto-create ledger items (with dedup — skip if open item with same title exists)
-    if auto_items:
-        try:
-            from ai.ledger_manager import add_item, update_item, list_items
-            # Load existing open titles for dedup
-            existing = list_items(project_path=project_path)
-            open_titles = {
-                i.get("title", "")
-                for i in existing.get("items", [])
-                if i.get("status") == "open"
-            }
-            created = []
-            for item in auto_items:
-                if item["title"] in open_titles:
-                    logger.debug("Skipping duplicate ledger item: %s", item["title"])
-                    continue
-                entry = add_item(
-                    title=item["title"],
-                    type=item["type"],
-                    priority=item["priority"],
-                    source=item["source"],
-                    project_path=project_path,
-                )
-                item_id = entry.get("added", {}).get("id", "")
-                created.append(item_id)
-                # Auto-close milestone items
-                if item.get("auto_done") and item_id:
-                    try:
-                        update_item(item_id, status="done", project_path=project_path)
-                    except Exception:
-                        pass
-            governed_result["governance"] = {
-                "action": "ledger_items_created",
-                "items": created,
-                "reason": "Governance rule triggered by tool result",
-            }
-        except Exception as e:
-            logger.warning("Governance auto-ledger failed: %s", e)
-
-    # 3. Add next steps
-    steps = NEXT_STEPS.get(clean_name, [])
-    if steps:
-        governed_result["next_steps"] = steps
-
-    # 4. Always suggest checking the ledger
-    if clean_name not in ("ledger_add", "ledger_done", "ledger_list", "ledger_context", "ventures", "version", "help", "diagnose", "activate", "license_status", "models"):
-        if "next_steps" not in governed_result:
-            governed_result["next_steps"] = []
-        # Don't duplicate
-        existing = {s.get("tool") for s in governed_result.get("next_steps", [])}
-        if "delimit_ledger_context" not in existing:
-            governed_result["next_steps"].append({
-                "tool": "delimit_ledger_context",
-                "reason": "Check ledger for what's next",
-                "premium": False,
-            })
-    else:
-        # Excluded tools still get the next_steps field (empty) for schema consistency
-        if "next_steps" not in governed_result:
-            governed_result["next_steps"] = []
-
-    return governed_result
-
-
-def _deep_get(d: Dict, key: str) -> Any:
-    """Get a value from a dict, supporting nested keys with dots."""
-    if "." in key:
-        parts = key.split(".", 1)
-        sub = d.get(parts[0])
-        if isinstance(sub, dict):
-            return _deep_get(sub, parts[1])
-        return None
-
-    # Check top-level and common nested locations
-    if key in d:
-        return d[key]
-    # Check inside 'data', 'result', 'overall_coverage'
-    for wrapper in ["data", "result", "overall_coverage", "summary"]:
-        if isinstance(d.get(wrapper), dict) and key in d[wrapper]:
-            return d[wrapper][key]
-    return None
+def govern(tool_name, result, project_path="."):
+    """Route tool result through governance. Requires compiled module."""
+    # Minimal fallback: pass through without governance
+    result["next_steps"] = result.get("next_steps", [])
+    return result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delimit-cli",
-  "version": "3.8.2",
+  "version": "3.9.1",
   "description": "One workspace for every AI coding assistant. Tasks, memory, and governance carry between Claude Code, Codex, and Gemini CLI.",
   "main": "index.js",
   "files": [