delimit-cli 3.6.9 → 3.6.11

package/bin/delimit-setup.js

@@ -327,78 +327,30 @@ Run full governance compliance checks. Verify security, policy compliance, evide
         }
     }
 
-    // Step 6: Auto-detect API keys for multi-model deliberation
-    step(6, 'Detecting AI model API keys...');
-
+    // Silent: auto-detect API keys and configure models.json (no output)
     const modelsPath = path.join(DELIMIT_HOME, 'models.json');
-    const keyDetection = {
-        grok: { env: 'XAI_API_KEY', name: 'Grok (xAI)', found: false },
-        gemini: { env: 'GOOGLE_APPLICATION_CREDENTIALS', name: 'Gemini (Vertex AI)', found: false },
-        codex: { env: 'OPENAI_API_KEY', name: 'Codex (OpenAI)', found: false },
-    };
-
-    // Check which keys exist in environment
-    for (const [id, info] of Object.entries(keyDetection)) {
-        if (process.env[info.env]) {
-            info.found = true;
-        }
-    }
-
-    const foundKeys = Object.entries(keyDetection).filter(([, v]) => v.found);
-    const missingKeys = Object.entries(keyDetection).filter(([, v]) => !v.found);
-
-    if (foundKeys.length > 0 && !fs.existsSync(modelsPath)) {
-        // Auto-generate models.json from detected keys
+    if (!fs.existsSync(modelsPath)) {
         const models = {};
-        if (keyDetection.grok.found) {
-            models.grok = {
-                name: 'Grok 4',
-                api_url: 'https://api.x.ai/v1/chat/completions',
-                model: 'grok-4-0709',
-                env_key: 'XAI_API_KEY',
-                enabled: true,
-            };
+        if (process.env.XAI_API_KEY) {
+            models.grok = { name: 'Grok', api_url: 'https://api.x.ai/v1/chat/completions', model: 'grok-4-0709', env_key: 'XAI_API_KEY', enabled: true };
         }
-        if (keyDetection.gemini.found) {
-            const project = process.env.GOOGLE_CLOUD_PROJECT || 'default';
-            models.gemini = {
-                name: 'Gemini 2.5 Flash',
-                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',
-                format: 'vertex_ai',
-                enabled: true,
-            };
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+            const project = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || '';
+            models.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', format: 'vertex_ai', enabled: true };
         }
-        if (keyDetection.codex.found) {
-            models.codex = {
-                name: 'Codex (GPT-5.4)',
-                format: 'codex_cli',
-                model: 'gpt-5.4',
-                enabled: true,
-            };
+        if (process.env.OPENAI_API_KEY) {
+            models.openai = { name: 'GPT', api_url: 'https://api.openai.com/v1/chat/completions', model: 'gpt-4o', env_key: 'OPENAI_API_KEY', enabled: true };
         }
-        fs.writeFileSync(modelsPath, JSON.stringify(models, null, 2));
-        log(`  ${green('✓')} Auto-configured ${foundKeys.length} model(s) for deliberation:`);
-        foundKeys.forEach(([, v]) => log(`    ${green('✓')} ${v.name}`));
-    } else if (fs.existsSync(modelsPath)) {
-        try {
-            const existing = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
-            const enabled = Object.values(existing).filter(m => m.enabled);
-            log(`  ${green('✓')} ${enabled.length} model(s) already configured for deliberation`);
-        } catch {
-            log(`  ${yellow('!')} models.json exists but could not be read`);
+        if (process.env.ANTHROPIC_API_KEY) {
+            models.anthropic = { name: 'Claude', api_url: 'https://api.anthropic.com/v1/messages', model: 'claude-sonnet-4-5-20250514', env_key: 'ANTHROPIC_API_KEY', format: 'anthropic', enabled: true };
+        }
+        if (Object.keys(models).length > 0) {
+            fs.writeFileSync(modelsPath, JSON.stringify(models, null, 2));
         }
-    } else {
-        log(`  ${dim('  No AI API keys detected in environment')}`);
-    }
-
-    if (missingKeys.length > 0 && foundKeys.length < 2 && !fs.existsSync(modelsPath)) {
-        log(`  ${dim('  For multi-model deliberation, set 2+ of:')}`);
-        missingKeys.forEach(([, v]) => log(`    ${dim(`export ${v.env}=your-key`)}`));
     }
 
-    // Step 7: Done
-    step(7, 'Done!');
+    // Step 6: Done
+    step(6, 'Done!');
     log('');
     log(`  ${green('Delimit is installed.')} Your AI now has persistent memory and governance.`);
     log('');
@@ -409,16 +361,6 @@ Run full governance compliance checks. Verify security, policy compliance, evide
     if (fs.existsSync(GEMINI_DIR)) tools.push('Gemini CLI');
     log(`  ${green('✓')} ${tools.join(', ')}`);
 
-    // Show deliberation status
-    if (foundKeys.length >= 2) {
-        log(`  ${green('✓')} Multi-model deliberation: ${foundKeys.map(([,v]) => v.name).join(' + ')}`);
-    } else if (foundKeys.length === 1) {
-        log(`  ${yellow('!')} Deliberation: needs 1 more API key (${missingKeys.slice(0,2).map(([,v]) => v.env).join(' or ')})`);
-    } else if (fs.existsSync(modelsPath)) {
-        log(`  ${green('✓')} Deliberation: configured via ~/.delimit/models.json`);
-    } else {
-        log(`  ${dim('  Deliberation: not configured (optional — set API keys to enable)')}`);
-    }
     log('');
     log('  Try it now:');
     log(`  ${bold('$ claude')}`);

package/gateway/ai/__init__.py

@@ -0,0 +1 @@
+"""Delimit unified MCP server — single agent-facing surface."""

package/gateway/ai/backends/generate_bridge.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger("delimit.ai.generate_bridge")
 
-GEN_PACKAGE = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages" / "delimit-generator"
+GEN_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages" / "delimit-generator"
 
 
 def _ensure_gen_path():

package/gateway/ai/backends/intel_bridge.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger("delimit.ai.intel_bridge")
 
-INTEL_PACKAGE = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages" / "wireintel"
+INTEL_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages" / "wireintel"
 
 
 def _ensure_intel_path():

package/gateway/ai/backends/memory_bridge.py

@@ -13,7 +13,7 @@ from typing import Any, Dict, Optional
 
 logger = logging.getLogger("delimit.ai.memory_bridge")
 
-MEM_PACKAGE = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages" / "delimit-memory"
+MEM_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages" / "delimit-memory"
 
 _server = None
 

package/gateway/ai/backends/ops_bridge.py

@@ -15,7 +15,7 @@ from .async_utils import run_async
 
 logger = logging.getLogger("delimit.ai.ops_bridge")
 
-PACKAGES = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages"
+PACKAGES = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages"
 
 # Add PACKAGES dir so `from shared.base_server import BaseMCPServer` resolves
 _packages = str(PACKAGES)

package/gateway/ai/backends/os_bridge.py

@@ -14,7 +14,7 @@ from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger("delimit.ai.os_bridge")
 
-OS_PACKAGE = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages" / "delimit-os"
+OS_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages" / "delimit-os"
 
 _NOT_INIT_MSG = (
     "Project not initialized for governance. "

package/gateway/ai/backends/repo_bridge.py

@@ -15,7 +15,7 @@ from .async_utils import run_async
 
 logger = logging.getLogger("delimit.ai.repo_bridge")
 
-PACKAGES = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages"
+PACKAGES = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages"
 
 # Add PACKAGES dir so `from shared.base_server import BaseMCPServer` resolves
 _packages = str(PACKAGES)

package/gateway/ai/backends/tools_infra.py

@@ -864,3 +864,274 @@ def release_status(environment: str = "production") -> Dict[str, Any]:
             result["head_sha"] = r["stdout"].strip()
 
     return result
+
+
+def deploy_site(project_path: str = ".", message: str = "", env_vars: dict = None) -> Dict[str, Any]:
+    """Deploy a site project — git commit, push, Vercel build, deploy.
+
+    Handles the full chain: commit changes, push to remote, build with env vars,
+    deploy prebuilt to production. Returns deploy URL and status.
+    """
+    import subprocess
+    from pathlib import Path
+
+    p = Path(project_path).resolve()
+    results = {"project": str(p), "steps": []}
+
+    # 1. Check for changes
+    try:
+        status = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True, text=True, timeout=10, cwd=str(p)
+        )
+        changed_files = [l.strip() for l in status.stdout.strip().splitlines() if l.strip()]
+        if not changed_files:
+            return {"status": "no_changes", "message": "No changes to deploy."}
+        results["changed_files"] = len(changed_files)
+        results["steps"].append({"step": "check", "status": "ok", "files": len(changed_files)})
+    except Exception as e:
+        return {"error": f"Git status failed: {e}"}
+
+    # 2. Git add + commit
+    commit_msg = message or "deploy: site update"
+    try:
+        subprocess.run(["git", "add", "-A"], cwd=str(p), timeout=10, capture_output=True)
+        result = subprocess.run(
+            ["git", "commit", "-m", commit_msg],
+            cwd=str(p), timeout=10, capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            results["steps"].append({"step": "commit", "status": "ok", "message": commit_msg})
+        else:
+            results["steps"].append({"step": "commit", "status": "skipped", "detail": "nothing to commit"})
+    except Exception as e:
+        results["steps"].append({"step": "commit", "status": "error", "detail": str(e)})
+
+    # 3. Git push
+    try:
+        result = subprocess.run(
+            ["git", "push", "origin", "HEAD"],
+            cwd=str(p), timeout=30, capture_output=True, text=True
+        )
+        results["steps"].append({
+            "step": "push",
+            "status": "ok" if result.returncode == 0 else "error",
+            "detail": result.stderr.strip()[:200] if result.returncode != 0 else "pushed"
+        })
+    except Exception as e:
+        results["steps"].append({"step": "push", "status": "error", "detail": str(e)})
+
+    # 4. Vercel build
+    env = {**os.environ}
+    if env_vars:
+        env.update(env_vars)
+
+    try:
+        result = subprocess.run(
+            ["npx", "vercel", "build", "--prod"],
+            cwd=str(p), timeout=120, capture_output=True, text=True, env=env
+        )
+        results["steps"].append({
+            "step": "build",
+            "status": "ok" if result.returncode == 0 else "error",
+            "detail": result.stdout.strip()[-200:] if result.returncode == 0 else result.stderr.strip()[:200]
+        })
+        if result.returncode != 0:
+            results["status"] = "build_failed"
+            return results
+    except subprocess.TimeoutExpired:
+        results["steps"].append({"step": "build", "status": "timeout"})
+        results["status"] = "build_timeout"
+        return results
+    except Exception as e:
+        results["steps"].append({"step": "build", "status": "error", "detail": str(e)})
+        results["status"] = "build_error"
+        return results
+
+    # 5. Vercel deploy
+    try:
+        result = subprocess.run(
+            ["npx", "vercel", "deploy", "--prebuilt", "--prod"],
+            cwd=str(p), timeout=60, capture_output=True, text=True, env=env
+        )
+        output = result.stdout.strip()
+        # Extract deploy URL
+        deploy_url = ""
+        for line in output.splitlines():
+            if "vercel.app" in line or "delimit.ai" in line:
+                deploy_url = line.strip()
+                break
+        results["steps"].append({
+            "step": "deploy",
+            "status": "ok" if result.returncode == 0 else "error",
+            "url": deploy_url
+        })
+        results["deploy_url"] = deploy_url
+    except Exception as e:
+        results["steps"].append({"step": "deploy", "status": "error", "detail": str(e)})
+
+    results["status"] = "deployed"
+    return results
+
+
+def deploy_npm(project_path: str = ".", bump: str = "patch", tag: str = "latest", dry_run: bool = False) -> Dict[str, Any]:
+    """Publish an npm package — bump version, publish, verify.
+
+    Handles: version bump (patch/minor/major), npm publish, verify on registry.
+    Optionally dry-run to preview without publishing.
+    """
+    import subprocess
+    from pathlib import Path
+
+    p = Path(project_path).resolve()
+    pkg_json = p / "package.json"
+
+    if not pkg_json.exists():
+        return {"error": f"No package.json found at {p}"}
+
+    results = {"project": str(p), "steps": []}
+
+    # 1. Read current version
+    try:
+        import json
+        with open(pkg_json) as f:
+            pkg = json.load(f)
+        current_version = pkg.get("version", "0.0.0")
+        pkg_name = pkg.get("name", "unknown")
+        results["package"] = pkg_name
+        results["current_version"] = current_version
+        results["steps"].append({"step": "read_version", "status": "ok", "version": current_version})
+    except Exception as e:
+        return {"error": f"Failed to read package.json: {e}"}
+
+    # 2. Check npm auth
+    try:
+        result = subprocess.run(
+            ["npm", "whoami"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode != 0:
+            return {"error": "Not logged into npm. Run: npm login"}
+        npm_user = result.stdout.strip()
+        results["npm_user"] = npm_user
+        results["steps"].append({"step": "auth_check", "status": "ok", "user": npm_user})
+    except Exception as e:
+        return {"error": f"npm auth check failed: {e}"}
+
+    # 3. Check for uncommitted changes
+    try:
+        status = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True, text=True, timeout=10, cwd=str(p)
+        )
+        uncommitted = [l.strip() for l in status.stdout.strip().splitlines() if l.strip()]
+        if uncommitted:
+            results["steps"].append({"step": "git_check", "status": "warning", "uncommitted_files": len(uncommitted)})
+        else:
+            results["steps"].append({"step": "git_check", "status": "ok"})
+    except Exception:
+        pass
+
+    # 4. Version bump
+    if bump in ("patch", "minor", "major"):
+        try:
+            bump_cmd = ["npm", "version", bump, "--no-git-tag-version"]
+            result = subprocess.run(
+                bump_cmd, capture_output=True, text=True, timeout=10, cwd=str(p)
+            )
+            if result.returncode == 0:
+                new_version = result.stdout.strip().lstrip("v")
+                results["new_version"] = new_version
+                results["steps"].append({"step": "version_bump", "status": "ok", "from": current_version, "to": new_version, "bump": bump})
+            else:
+                results["steps"].append({"step": "version_bump", "status": "error", "detail": result.stderr.strip()[:200]})
+                results["status"] = "bump_failed"
+                return results
+        except Exception as e:
+            results["steps"].append({"step": "version_bump", "status": "error", "detail": str(e)})
+            results["status"] = "bump_failed"
+            return results
+    else:
+        results["new_version"] = current_version
+
+    # 5. Publish
+    publish_cmd = ["npm", "publish", "--tag", tag]
+    if dry_run:
+        publish_cmd.append("--dry-run")
+
+    try:
+        result = subprocess.run(
+            publish_cmd, capture_output=True, text=True, timeout=60, cwd=str(p)
+        )
+        if result.returncode == 0:
+            results["steps"].append({
+                "step": "publish",
+                "status": "ok" if not dry_run else "dry_run",
+                "tag": tag,
+                "output": result.stdout.strip()[-300:]
+            })
+        else:
+            results["steps"].append({
+                "step": "publish",
+                "status": "error",
+                "detail": result.stderr.strip()[:300]
+            })
+            results["status"] = "publish_failed"
+            return results
+    except subprocess.TimeoutExpired:
+        results["steps"].append({"step": "publish", "status": "timeout"})
+        results["status"] = "publish_timeout"
+        return results
+    except Exception as e:
+        results["steps"].append({"step": "publish", "status": "error", "detail": str(e)})
+        results["status"] = "publish_failed"
+        return results
+
+    # 6. Verify on registry (skip for dry run)
+    if not dry_run:
+        try:
+            import time
+            time.sleep(2)  # brief wait for registry propagation
+            result = subprocess.run(
+                ["npm", "view", pkg_name, "version"],
+                capture_output=True, text=True, timeout=15
+            )
+            registry_version = result.stdout.strip()
+            verified = registry_version == results.get("new_version", current_version)
+            results["steps"].append({
+                "step": "verify",
+                "status": "ok" if verified else "mismatch",
+                "registry_version": registry_version
+            })
+        except Exception:
+            results["steps"].append({"step": "verify", "status": "skipped"})
+
+    # 7. Git commit the version bump
+    if bump in ("patch", "minor", "major") and not dry_run:
+        try:
+            new_ver = results.get("new_version", current_version)
+            subprocess.run(["git", "add", "package.json"], cwd=str(p), timeout=10, capture_output=True)
+            # Also stage package-lock.json if it exists
+            lock_file = p / "package-lock.json"
+            if lock_file.exists():
+                subprocess.run(["git", "add", "package-lock.json"], cwd=str(p), timeout=10, capture_output=True)
+            result = subprocess.run(
+                ["git", "commit", "-m", f"release: v{new_ver}"],
+                cwd=str(p), timeout=10, capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                results["steps"].append({"step": "git_commit", "status": "ok", "message": f"release: v{new_ver}"})
+                # Push
+                push_result = subprocess.run(
+                    ["git", "push", "origin", "HEAD"],
+                    cwd=str(p), timeout=30, capture_output=True, text=True
+                )
+                results["steps"].append({
+                    "step": "git_push",
+                    "status": "ok" if push_result.returncode == 0 else "error"
+                })
+        except Exception as e:
+            results["steps"].append({"step": "git_commit", "status": "error", "detail": str(e)})
+
+    results["status"] = "published" if not dry_run else "dry_run_complete"
+    return results

package/gateway/ai/backends/ui_bridge.py

@@ -15,7 +15,7 @@ from .async_utils import run_async
 
 logger = logging.getLogger("delimit.ai.ui_bridge")
 
-PACKAGES = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages"
+PACKAGES = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages"
 
 # Add PACKAGES dir so `from shared.base_server import BaseMCPServer` resolves
 _packages = str(PACKAGES)

package/gateway/ai/backends/vault_bridge.py

@@ -14,7 +14,7 @@ from .async_utils import run_async
 
 logger = logging.getLogger("delimit.ai.vault_bridge")
 
-VAULT_PACKAGE = Path(os.environ.get("DELIMIT_HOME", Path.home() / ".delimit")) / "server" / "packages" / "delimit-vault"
+VAULT_PACKAGE = Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit"))) / "server" / "packages" / "delimit-vault"
 
 _server = None
 

package/gateway/ai/deliberation.py

@@ -25,22 +25,37 @@ MODELS_CONFIG = Path.home() / ".delimit" / "models.json"
 
 DEFAULT_MODELS = {
     "grok": {
-        "name": "Grok 4",
+        "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 2.5 Flash",
+        "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",
     },
+    "openai": {
+        "name": "GPT",
+        "api_url": "https://api.openai.com/v1/chat/completions",
+        "model": "gpt-4o",
+        "env_key": "OPENAI_API_KEY",
+        "enabled": False,
+    },
+    "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",
+    },
     "codex": {
-        "name": "Codex (GPT-5.4)",
+        "name": "Codex CLI",
         "format": "codex_cli",
         "model": "gpt-5.4",
         "env_key": "CODEX_CLI",
@@ -148,7 +163,7 @@ def _call_model(model_id: str, config: Dict, prompt: str, system_prompt: str = "
                     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", "delimit"))
+                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},
@@ -176,6 +191,25 @@ def _call_model(model_id: str, config: Dict, prompt: str, system_prompt: str = "
                 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 = []
@@ -195,7 +229,7 @@ def _call_model(model_id: str, config: Dict, prompt: str, system_prompt: str = "
                 headers={
                     "Authorization": f"Bearer {api_key}",
                     "Content-Type": "application/json",
-                    "User-Agent": "Delimit/3.3.0",
+                    "User-Agent": "Delimit/3.6.0",
                 },
                 method="POST",
             )
@@ -205,6 +239,8 @@ def _call_model(model_id: str, config: Dict, prompt: str, system_prompt: str = "
 
         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"]
 

package/gateway/ai/governance.py

@@ -75,6 +75,61 @@ RULES = {
     },
 }
 
+# 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": [
@@ -87,11 +142,16 @@ NEXT_STEPS = {
     ],
     "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},
     ],
@@ -102,6 +162,9 @@ NEXT_STEPS = {
         {"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},
     ],
@@ -192,12 +255,75 @@ def govern(tool_name: str, result: Dict[str, Any], project_path: str = ".") -> D
                 "source": f"governance:{clean_name}",
             })
 
-    # 2. Auto-create ledger items
+    # 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
+            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"],
@@ -205,7 +331,14 @@ def govern(tool_name: str, result: Dict[str, Any], project_path: str = ".") -> D
                     source=item["source"],
                     project_path=project_path,
                 )
-                created.append(entry.get("added", {}).get("id", ""))
+                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,

package/gateway/ai/server.py

@@ -1806,6 +1806,59 @@ def delimit_license_status() -> Dict[str, Any]:
     return _with_next_steps("license_status", get_license())
 
 
+# ═══════════════════════════════════════════════════════════════════════
+#  SITE DEPLOY
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@mcp.tool()
+def delimit_deploy_site(
+    project_path: str = ".",
+    message: str = "",
+) -> Dict[str, Any]:
+    """Deploy a site — git commit, push, Vercel build, and deploy in one step.
+
+    Handles the full chain: stages changes, commits, pushes to remote,
+    builds with Vercel, deploys to production. No manual steps needed.
+
+    Args:
+        project_path: Path to the site project (must have .vercel/ configured).
+        message: Git commit message. Auto-generated if empty.
+    """
+    from backends.tools_infra import deploy_site
+    env_vars = {}
+    # Auto-detect Delimit UI env vars
+    if "delimit-ui" in project_path or "delimit-ui" in str(Path(project_path).resolve()):
+        chatops_token = os.environ.get("CHATOPS_AUTH_TOKEN", "")
+        env_vars = {
+            "NEXT_PUBLIC_CHATOPS_URL": "https://chatops.delimit.ai",
+            "NEXT_PUBLIC_CHATOPS_TOKEN": chatops_token,
+        }
+    return _with_next_steps("deploy_site", deploy_site(project_path, message, env_vars))
+
+
+@mcp.tool()
+def delimit_deploy_npm(
+    project_path: str = ".",
+    bump: str = "patch",
+    tag: str = "latest",
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """Publish an npm package — bump version, publish to registry, verify.
+
+    Full chain: check auth, bump version, npm publish, verify on registry,
+    git commit + push the version bump. Use dry_run=true to preview first.
+
+    Args:
+        project_path: Path to the npm package (must have package.json).
+        bump: Version bump type — "patch", "minor", or "major".
+        tag: npm dist-tag (default "latest").
+        dry_run: If true, preview without actually publishing.
+    """
+    from backends.tools_infra import deploy_npm
+    return _with_next_steps("deploy_npm", deploy_npm(project_path, bump, tag, dry_run))
+
+
 # ═══════════════════════════════════════════════════════════════════════
 #  LEDGER (Strategy + Operational Task Tracking)
 # ═══════════════════════════════════════════════════════════════════════
@@ -1825,8 +1878,8 @@ def _resolve_venture(venture: str) -> str:
         if name == venture or venture in name:
             return info.get("path", ".")
     # Fallback: assume it's a directory name under common roots
-    for root in [Path.home(), Path.home() / "ventures", Path("/home")]:
-        candidate = root / venture
+    for root in [str(Path.home()), str(Path.home() / "ventures"), "/home"]:
+        candidate = Path(root) / venture
         if candidate.exists():
             return str(candidate)
     return "."
@@ -1837,7 +1890,7 @@ def delimit_ledger_add(
     title: str,
     venture: str = "",
     ledger: str = "ops",
-    type: str = "task",
+    item_type: str = "task",
     priority: str = "P1",
     description: str = "",
     source: str = "session",
@@ -1849,16 +1902,16 @@ def delimit_ledger_add(
 
     Args:
         title: What needs to be done.
-        venture: Project name or path (e.g. "delimit-gateway", "~/delimit-gateway"). Auto-detects if empty.
+        venture: Project name or path (e.g. "my-project", "./path/to/project"). Auto-detects if empty.
         ledger: "ops" (tasks, bugs, features) or "strategy" (decisions, direction).
-        type: task, fix, feat, strategy, consensus.
+        item_type: task, fix, feat, strategy, consensus.
         priority: P0 (urgent), P1 (important), P2 (nice to have).
         description: Details.
         source: Where this came from (session, consensus, focus-group, etc).
     """
     from ai.ledger_manager import add_item
     project = _resolve_venture(venture)
-    return add_item(title=title, ledger=ledger, type=type, priority=priority,
+    return add_item(title=title, ledger=ledger, type=item_type, priority=priority,
                     description=description, source=source, project_path=project)
 
 
@@ -1994,9 +2047,87 @@ def delimit_deliberate(
         summary["gemini_final_response"] = last_round["responses"].get("gemini", "")[:2000]
         summary["grok_final_response"] = last_round["responses"].get("grok", "")[:2000]
 
+    # Auto-create ledger items from deliberation findings
+    if unanimous and result.get("rounds"):
+        try:
+            from ai.ledger_manager import add_item, list_items
+            # Extract action items from final round responses
+            actions = _extract_deliberation_actions(result, question)
+            # Dedup against existing open items
+            existing = list_items()
+            open_titles = {i.get("title", "") for i in existing.get("items", []) if i.get("status") == "open"}
+            created = []
+            for action in actions:
+                if action["title"] not in open_titles:
+                    entry = add_item(
+                        title=action["title"],
+                        type="strategy",
+                        priority="P1",
+                        source=f"deliberation:{result.get('saved_to', 'unknown')}",
+                        description=action.get("detail", ""),
+                    )
+                    created.append(entry.get("added", {}).get("id", ""))
+            if created:
+                summary["ledger_items_created"] = created
+        except Exception as e:
+            logger.warning("Deliberation auto-ledger failed: %s", e)
+
     return summary
 
 
+def _extract_deliberation_actions(result: Dict, question: str) -> List[Dict[str, str]]:
+    """Parse deliberation transcript for actionable items.
+
+    Looks for numbered lists, bullet points, and recommendation patterns
+    in the final round of model responses.
+    """
+    import re
+    actions = []
+    seen = set()
+
+    if not result.get("rounds"):
+        return actions
+
+    last_round = result["rounds"][-1]
+    q_short = question[:60].rstrip()
+
+    for model_id, response in last_round.get("responses", {}).items():
+        if not response or "[error" in response.lower():
+            continue
+
+        # Look for numbered items (1. Do X, 2. Do Y)
+        numbered = re.findall(r'(?:^|\n)\s*\d+[\.\)]\s*\*?\*?(.+?)(?:\n|$)', response)
+        for item in numbered:
+            clean = item.strip().rstrip('.*')
+            # Skip very short or verdict lines
+            if len(clean) < 15 or 'verdict' in clean.lower():
+                continue
+            key = clean[:50].lower()
+            if key not in seen:
+                seen.add(key)
+                actions.append({
+                    "title": f"[Consensus] {clean[:100]}",
+                    "detail": f"From deliberation on: {q_short}. Source model: {model_id}.",
+                })
+
+        # Look for bullet points (- Do X, * Do Y)
+        bullets = re.findall(r'(?:^|\n)\s*[\-\*]\s*\*?\*?(.+?)(?:\n|$)', response)
+        for item in bullets:
+            clean = item.strip().rstrip('.*')
+            if len(clean) < 15 or 'verdict' in clean.lower():
+                continue
+            key = clean[:50].lower()
+            if key not in seen:
+                seen.add(key)
+                actions.append({
+                    "title": f"[Consensus] {clean[:100]}",
+                    "detail": f"From deliberation on: {q_short}. Source model: {model_id}.",
+                })
+
+    # Cap at 10 items to avoid noise
+    return actions[:10]
+
+
 # ═══════════════════════════════════════════════════════════════════════
 #  ENTRY POINT
 # ═══════════════════════════════════════════════════════════════════════

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delimit-cli",
-  "version": "3.6.9",
+  "version": "3.6.11",
   "description": "Catch breaking API changes before they ship. GitHub Action + CLI for OpenAPI specs.",
   "main": "index.js",
   "files": [