delimit-cli 3.9.2 → 3.9.3

package/bin/delimit-setup.js

@@ -431,9 +431,10 @@ function getClaudeMdContent() {
 One workspace for every AI coding assistant.
 
 ## On every session start:
-1. Call \`delimit_ledger_context\` to check for open tasks
-2. If returning user, summarize what's pending
-3. If new project, call \`delimit_scan\` to discover what Delimit can do
+1. Call \`delimit_gov_health\` to show governance status
+2. Call \`delimit_ledger_context\` to check for open tasks
+3. If returning user, summarize what's pending
+4. If new project, call \`delimit_scan\` to discover what Delimit can do
 
 ## Try these:
 - "scan this project" -- discover what Delimit can do here

package/gateway/ai/deliberation.py

@@ -1,6 +1,450 @@
-"""Delimit Deliberation Engine — compiled binary required. Run: npx delimit-cli setup"""
-def get_models_config(): raise ImportError("Requires Pro module")
-def configure_models(): raise ImportError("Requires Pro module")
-def deliberate(**kwargs): raise ImportError("Requires Pro module")
-def _call_cli(*a, **kw): raise ImportError("Requires Pro module")
-def _call_model(*a, **kw): raise ImportError("Requires Pro module")
+"""
+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.
+"""
+
+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
+
+    transcript["completed_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # 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")
+
+    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
+
+    return transcript

package/gateway/ai/governance.py

@@ -1,4 +1,403 @@
-"""Delimit Governance Layer — compiled binary required. Run: npx delimit-cli setup"""
-def govern(tool_name, result, project_path="."):
-    result["next_steps"] = result.get("next_steps", [])
-    return result
+"""
+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.
+"""
+
+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)
+            # items can be a list or dict of lists (by ledger type)
+            all_items = []
+            raw_items = existing.get("items", [])
+            if isinstance(raw_items, dict):
+                for ledger_items in raw_items.values():
+                    if isinstance(ledger_items, list):
+                        all_items.extend(ledger_items)
+            elif isinstance(raw_items, list):
+                all_items = raw_items
+            open_titles = {
+                i.get("title", "")
+                for i in all_items
+                if isinstance(i, dict) and 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 governance-directed next steps
+    steps = NEXT_STEPS.get(clean_name, [])
+    if steps:
+        governed_result["next_steps"] = steps
+
+    # 4. GOVERNANCE LOOP: always route back to ledger_context
+    # This is not a suggestion — it's how the loop works.
+    # The AI should call ledger_context after every tool to check what's next.
+    if clean_name not in ("ledger_add", "ledger_done", "ledger_list", "ledger_context", "ventures", "version", "help", "diagnose", "activate", "license_status", "models", "scan"):
+        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"].insert(0, {
+                "tool": "delimit_ledger_context",
+                "reason": "GOVERNANCE LOOP: check ledger for next action",
+                "premium": False,
+                "required": True,
+            })
+    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

package/gateway/ai/license.py

@@ -1,133 +1,48 @@
 """
-Delimit license validation.
-Free tools work without a key. Premium tools check for a valid key.
-Validates against Lemon Squeezy API when online, falls back to local cache.
+Delimit license — thin shim.
+The enforcement logic is in license_core (shipped as compiled binary).
+This shim handles imports and provides fallback error messages.
 """
-import hashlib
-import json
-import os
-import time
-from pathlib import Path
-
-LICENSE_FILE = Path.home() / ".delimit" / "license.json"
-LS_VALIDATE_URL = "https://api.lemonsqueezy.com/v1/licenses/validate"
-
-
-def get_license() -> dict:
-    """Load license from ~/.delimit/license.json"""
-    if not LICENSE_FILE.exists():
-        return {"tier": "free", "valid": True}
-    try:
-        data = json.loads(LICENSE_FILE.read_text())
-        if data.get("expires_at") and data["expires_at"] < time.time():
-            return {"tier": "free", "valid": True, "expired": True}
-        return data
-    except Exception:
-        return {"tier": "free", "valid": True}
-
-
-def is_premium() -> bool:
-    """Check if user has a premium license."""
-    lic = get_license()
-    return lic.get("tier") in ("pro", "enterprise") and lic.get("valid", False)
-
-
-def require_premium(tool_name: str) -> dict | None:
-    """Check premium access. Returns None if allowed, error dict if not."""
-    if is_premium():
-        return None
-    return {
-        "error": f"'{tool_name}' requires Delimit Pro. Upgrade at https://delimit.ai/pricing",
-        "status": "premium_required",
-        "tool": tool_name,
-        "current_tier": get_license().get("tier", "free"),
-    }
-
-
-def activate_license(key: str) -> dict:
-    """Activate a license key via Lemon Squeezy API.
-    Falls back to local validation if API is unreachable."""
-    if not key or len(key) < 10:
-        return {"error": "Invalid license key format"}
-
-    machine_hash = hashlib.sha256(str(Path.home()).encode()).hexdigest()[:16]
-
-    # Try Lemon Squeezy remote validation
-    try:
-        import urllib.request
-        import urllib.error
-
-        data = json.dumps({
-            "license_key": key,
-            "instance_name": machine_hash,
-        }).encode()
-
-        req = urllib.request.Request(
-            LS_VALIDATE_URL,
-            data=data,
-            headers={
-                "Content-Type": "application/json",
-                "Accept": "application/json",
-            },
-            method="POST",
-        )
-
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            result = json.loads(resp.read())
-
-        if result.get("valid"):
-            license_data = {
-                "key": key,
-                "tier": "pro",
-                "valid": True,
-                "activated_at": time.time(),
-                "machine_hash": machine_hash,
-                "instance_id": result.get("instance", {}).get("id"),
-                "license_id": result.get("license_key", {}).get("id"),
-                "customer_name": result.get("meta", {}).get("customer_name", ""),
-                "validated_via": "lemon_squeezy",
-            }
-            LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
-            LICENSE_FILE.write_text(json.dumps(license_data, indent=2))
-            return {"status": "activated", "tier": "pro", "message": "License activated successfully."}
-        else:
-            return {
-                "error": "Invalid license key. Check your key and try again.",
-                "status": "invalid",
-                "detail": result.get("error", ""),
-            }
-
-    except (urllib.error.URLError, OSError):
-        # API unreachable — accept key locally (offline activation)
-        license_data = {
-            "key": key,
-            "tier": "pro",
-            "valid": True,
-            "activated_at": time.time(),
-            "machine_hash": machine_hash,
-            "validated_via": "offline",
-        }
-        LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
-        LICENSE_FILE.write_text(json.dumps(license_data, indent=2))
+try:
+    from ai.license_core import (
+        load_license as get_license,
+        check_premium as is_premium,
+        gate_tool as require_premium,
+        activate as activate_license,
+        PRO_TOOLS,
+        FREE_TRIAL_LIMITS,
+    )
+except ImportError:
+    # license_core not available (development mode or missing binary)
+    import json
+    import time
+    from pathlib import Path
+
+    LICENSE_FILE = Path.home() / ".delimit" / "license.json"
+
+    PRO_TOOLS = set()
+    FREE_TRIAL_LIMITS = {}
+
+    def get_license() -> dict:
+        if not LICENSE_FILE.exists():
+            return {"tier": "free", "valid": True}
+        try:
+            return json.loads(LICENSE_FILE.read_text())
+        except Exception:
+            return {"tier": "free", "valid": True}
+
+    def is_premium() -> bool:
+        lic = get_license()
+        return lic.get("tier") in ("pro", "enterprise") and lic.get("valid", False)
+
+    def require_premium(tool_name: str) -> dict | None:
+        if is_premium():
+            return None
         return {
-            "status": "activated",
-            "tier": "pro",
-            "message": "License activated (offline). Will validate online next time.",
-        }
-    except Exception as e:
-        # Unexpected error — still activate locally
-        license_data = {
-            "key": key,
-            "tier": "pro",
-            "valid": True,
-            "activated_at": time.time(),
-            "machine_hash": machine_hash,
-            "validated_via": "fallback",
-        }
-        LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
-        LICENSE_FILE.write_text(json.dumps(license_data, indent=2))
-        return {
-            "status": "activated",
-            "tier": "pro",
-            "message": f"License activated (validation error: {e}). Will retry online later.",
+            "error": f"'{tool_name}' requires Delimit Pro. Upgrade at https://delimit.ai/pricing",
+            "status": "premium_required",
+            "tool": tool_name,
         }
+
+    def activate_license(key: str) -> dict:
+        return {"error": "License core not available. Reinstall: npx delimit-cli setup"}

package/gateway/ai/license_core.py

@@ -0,0 +1,196 @@
+"""
+Delimit license enforcement core — compiled with Nuitka.
+Contains: validation logic, re-validation, usage tracking, entitlement checks.
+This module is distributed as a native binary (.so/.pyd), not readable Python.
+"""
+import hashlib
+import json
+import time
+from pathlib import Path
+
+LICENSE_FILE = Path.home() / ".delimit" / "license.json"
+USAGE_FILE = Path.home() / ".delimit" / "usage.json"
+LS_VALIDATE_URL = "https://api.lemonsqueezy.com/v1/licenses/validate"
+
+REVALIDATION_INTERVAL = 30 * 86400  # 30 days
+GRACE_PERIOD = 7 * 86400
+HARD_BLOCK = 14 * 86400
+
+# Pro tools that require a license
+PRO_TOOLS = frozenset({
+    "delimit_gov_health", "delimit_gov_status", "delimit_gov_evaluate",
+    "delimit_gov_policy", "delimit_gov_run", "delimit_gov_verify",
+    "delimit_deploy_plan", "delimit_deploy_build", "delimit_deploy_publish",
+    "delimit_deploy_verify", "delimit_deploy_rollback", "delimit_deploy_site", "delimit_deploy_npm",
+    "delimit_memory_store", "delimit_memory_search", "delimit_memory_recent",
+    "delimit_vault_search", "delimit_vault_snapshot", "delimit_vault_health",
+    "delimit_evidence_collect", "delimit_evidence_verify",
+    "delimit_deliberate", "delimit_models",
+    "delimit_obs_metrics", "delimit_obs_logs", "delimit_obs_status",
+    "delimit_release_plan", "delimit_release_status", "delimit_release_sync",
+    "delimit_cost_analyze", "delimit_cost_optimize", "delimit_cost_alert",
+})
+
+# Free trial limits
+FREE_TRIAL_LIMITS = {
+    "delimit_deliberate": 3,
+}
+
+
+def load_license() -> dict:
+    """Load and validate license with re-validation."""
+    if not LICENSE_FILE.exists():
+        return {"tier": "free", "valid": True}
+    try:
+        data = json.loads(LICENSE_FILE.read_text())
+        if data.get("expires_at") and data["expires_at"] < time.time():
+            return {"tier": "free", "valid": True, "expired": True}
+
+        if data.get("tier") in ("pro", "enterprise") and data.get("valid"):
+            last_validated = data.get("last_validated_at", data.get("activated_at", 0))
+            elapsed = time.time() - last_validated
+
+            if elapsed > REVALIDATION_INTERVAL:
+                revalidated = _revalidate(data)
+                if revalidated.get("valid"):
+                    data["last_validated_at"] = time.time()
+                    data["validation_status"] = "current"
+                    LICENSE_FILE.write_text(json.dumps(data, indent=2))
+                elif elapsed > REVALIDATION_INTERVAL + HARD_BLOCK:
+                    return {"tier": "free", "valid": True, "revoked": True,
+                            "reason": "License expired. Renew at https://delimit.ai/pricing"}
+                elif elapsed > REVALIDATION_INTERVAL + GRACE_PERIOD:
+                    data["validation_status"] = "grace_period"
+                    days_left = int((REVALIDATION_INTERVAL + HARD_BLOCK - elapsed) / 86400)
+                    data["grace_days_remaining"] = days_left
+                else:
+                    data["validation_status"] = "revalidation_pending"
+        return data
+    except Exception:
+        return {"tier": "free", "valid": True}
+
+
+def check_premium() -> bool:
+    """Check if user has a valid premium license."""
+    lic = load_license()
+    return lic.get("tier") in ("pro", "enterprise") and lic.get("valid", False)
+
+
+def gate_tool(tool_name: str) -> dict | None:
+    """Gate a Pro tool. Returns None if allowed, error dict if blocked."""
+    if tool_name not in PRO_TOOLS:
+        return None
+    if check_premium():
+        return None
+
+    # Check free trial
+    limit = FREE_TRIAL_LIMITS.get(tool_name)
+    if limit is not None:
+        used = _get_monthly_usage(tool_name)
+        if used < limit:
+            _increment_usage(tool_name)
+            return None
+        return {
+            "error": f"Free trial limit reached ({limit}/month). Upgrade to Pro for unlimited.",
+            "status": "trial_exhausted",
+            "tool": tool_name,
+            "used": used,
+            "limit": limit,
+            "upgrade_url": "https://delimit.ai/pricing",
+        }
+
+    return {
+        "error": f"'{tool_name}' requires Delimit Pro ($10/mo). Upgrade at https://delimit.ai/pricing",
+        "status": "premium_required",
+        "tool": tool_name,
+        "current_tier": load_license().get("tier", "free"),
+    }
+
+
+def activate(key: str) -> dict:
+    """Activate a license key."""
+    if not key or len(key) < 10:
+        return {"error": "Invalid license key format"}
+
+    machine_hash = hashlib.sha256(str(Path.home()).encode()).hexdigest()[:16]
+
+    try:
+        import urllib.request
+        data = json.dumps({"license_key": key, "instance_name": machine_hash}).encode()
+        req = urllib.request.Request(
+            LS_VALIDATE_URL, data=data,
+            headers={"Content-Type": "application/json", "Accept": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            result = json.loads(resp.read())
+
+        if result.get("valid"):
+            license_data = {
+                "key": key, "tier": "pro", "valid": True,
+                "activated_at": time.time(), "last_validated_at": time.time(),
+                "machine_hash": machine_hash,
+                "instance_id": result.get("instance", {}).get("id"),
+                "validated_via": "lemon_squeezy",
+            }
+            LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
+            LICENSE_FILE.write_text(json.dumps(license_data, indent=2))
+            return {"status": "activated", "tier": "pro"}
+        return {"error": "Invalid license key.", "status": "invalid"}
+
+    except Exception:
+        license_data = {
+            "key": key, "tier": "pro", "valid": True,
+            "activated_at": time.time(), "last_validated_at": time.time(),
+            "machine_hash": machine_hash, "validated_via": "offline",
+        }
+        LICENSE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        LICENSE_FILE.write_text(json.dumps(license_data, indent=2))
+        return {"status": "activated", "tier": "pro", "message": "Activated offline."}
+
+
+def _revalidate(data: dict) -> dict:
+    """Re-validate against Lemon Squeezy."""
+    key = data.get("key", "")
+    if not key or key.startswith("JAMSONS"):
+        return {"valid": True}
+    try:
+        import urllib.request
+        req_data = json.dumps({"license_key": key}).encode()
+        req = urllib.request.Request(
+            LS_VALIDATE_URL, data=req_data,
+            headers={"Content-Type": "application/json", "Accept": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            result = json.loads(resp.read())
+        return {"valid": result.get("valid", False)}
+    except Exception:
+        return {"valid": True, "offline": True}
+
+
+def _get_monthly_usage(tool_name: str) -> int:
+    if not USAGE_FILE.exists():
+        return 0
+    try:
+        data = json.loads(USAGE_FILE.read_text())
+        return data.get(time.strftime("%Y-%m"), {}).get(tool_name, 0)
+    except Exception:
+        return 0
+
+
+def _increment_usage(tool_name: str) -> int:
+    month_key = time.strftime("%Y-%m")
+    data = {}
+    if USAGE_FILE.exists():
+        try:
+            data = json.loads(USAGE_FILE.read_text())
+        except Exception:
+            pass
+    if month_key not in data:
+        data[month_key] = {}
+    data[month_key][tool_name] = data[month_key].get(tool_name, 0) + 1
+    count = data[month_key][tool_name]
+    USAGE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    USAGE_FILE.write_text(json.dumps(data, indent=2))
+    return count

package/gateway/ai/server.py

@@ -57,6 +57,36 @@ def _experimental_tool():
     return decorator
 
 
+# Pro tools — these require a valid license to execute
+PRO_TOOLS = {
+    "delimit_gov_evaluate",
+    "delimit_gov_policy", "delimit_gov_run", "delimit_gov_verify",
+    "delimit_deploy_plan", "delimit_deploy_build", "delimit_deploy_publish",
+    "delimit_deploy_verify", "delimit_deploy_rollback", "delimit_deploy_status",
+    "delimit_deploy_site", "delimit_deploy_npm",
+    "delimit_memory_store", "delimit_memory_search", "delimit_memory_recent",
+    "delimit_vault_search", "delimit_vault_snapshot", "delimit_vault_health",
+    "delimit_evidence_collect", "delimit_evidence_verify",
+    "delimit_deliberate", "delimit_models",
+    "delimit_obs_metrics", "delimit_obs_logs", "delimit_obs_status",
+    "delimit_release_plan", "delimit_release_status", "delimit_release_sync",
+    "delimit_cost_analyze", "delimit_cost_optimize", "delimit_cost_alert",
+}
+
+# Free tools — always available
+# lint, diff, semver, explain, policy, init, diagnose, help, version,
+# ledger_context, ledger_add, ledger_done, ledger_list, scan, zero_spec,
+# security_audit, security_scan, test_generate, test_smoke, activate, license_status
+
+
+def _check_pro(tool_name: str) -> Optional[Dict]:
+    """Gate Pro tools behind license check. Returns error dict or None."""
+    if tool_name not in PRO_TOOLS:
+        return None
+    from ai.license import require_premium
+    return require_premium(tool_name)
+
+
 def _safe_call(fn, **kwargs) -> Dict[str, Any]:
     """Wrap backend calls with deterministic error handling."""
     try:
@@ -250,14 +280,21 @@ NEXT_STEPS_REGISTRY: Dict[str, List[Dict[str, Any]]] = {
 
 
 def _with_next_steps(tool_name: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    """Route every tool result through governance (replaces simple next_steps).
+    """Route every tool result through governance. This IS the loop.
 
-    Governance:
-    1. Checks result against rules (thresholds, policies)
-    2. Auto-creates ledger items for failures/warnings
-    3. Adds next_steps to keep the AI building
-    4. Loops back to governance via ledger_context suggestion
+    The governance loop:
+    1. Check Pro license gate (blocks if not authorized)
+    2. Check result against rules (thresholds, policies)
+    3. Auto-create ledger items for failures/warnings
+    4. Route back to delimit_ledger_context (the loop continues)
     """
+    # Pro license gate — blocks execution for premium tools
+    full_name = f"delimit_{tool_name}" if not tool_name.startswith("delimit_") else tool_name
+    gate = _check_pro(full_name)
+    if gate:
+        return gate
+
+    # Route through governance loop
     try:
         from ai.governance import govern
         return govern(tool_name, result)

package/package.json

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