delimit-cli 4.1.6 → 4.1.8

package/lib/cross-model-hooks.js

@@ -790,26 +790,52 @@ function getTopStrategyItem() {
  */
 async function hookSessionStart() {
     const config = loadHookConfig();
-    if (!config.session_start) {
-        return;
-    }
+    // Always show status — even if session_start is false in config
+    // This is the first thing a user sees. Make it count.
 
     const lines = [];
-    lines.push('[Delimit] Governance check');
-    lines.push('');
+    lines.push('=== Delimit Status ===');
+
+    // Server status + tool count
+    const home = getHome();
+    const serverFile = path.join(home, '.delimit', 'server', 'ai', 'server.py');
+    if (fs.existsSync(serverFile)) {
+        try {
+            const content = fs.readFileSync(serverFile, 'utf-8');
+            const toolCount = (content.match(/@mcp\.tool\(\)/g) || []).length;
+            lines.push(`Server: ready (${toolCount} tools)`);
+        } catch {
+            lines.push('Server: ready');
+        }
+    } else {
+        lines.push('Server: not installed -- run npx delimit-cli setup');
+    }
 
-    // Check for delimit.yml or .delimit.yml
+    // Governance status
     const cwd = process.cwd();
     const hasPolicy = fs.existsSync(path.join(cwd, 'delimit.yml'))
         || fs.existsSync(path.join(cwd, '.delimit.yml'))
         || fs.existsSync(path.join(cwd, '.delimit', 'policies.yml'));
 
     if (hasPolicy) {
-        lines.push('[Delimit] Policy file found -- governance active');
+        lines.push('Governance: active');
     } else {
-        lines.push('[Delimit] No policy file found -- run "delimit init" to set up governance');
+        lines.push('Governance: not initialized -- run npx delimit-cli init');
     }
 
+    // Last session context (prevents cross-session drift)
+    const sessionsDir = path.join(home, '.delimit', 'sessions');
+    try {
+        if (fs.existsSync(sessionsDir)) {
+            const sessions = fs.readdirSync(sessionsDir).filter(f => f.startsWith('session_')).sort().reverse();
+            if (sessions.length > 0) {
+                const latest = JSON.parse(fs.readFileSync(path.join(sessionsDir, sessions[0]), 'utf-8'));
+                const summary = (latest.summary || '').substring(0, 150);
+                if (summary) lines.push(`Last session: ${summary}`);
+            }
+        }
+    } catch {}
+
     // Auto-update check + install
     try {
         const pkgPath = path.join(__dirname, '..', 'package.json');
@@ -896,9 +922,7 @@ async function hookSessionStart() {
         }
     } catch { /* not in git repo */ }
 
-    // Remind AI to start inbox daemon
-    lines.push('[Delimit] Action required: call delimit_inbox_daemon(action="start") to enable email-based approvals');
-
+    lines.push('=== Delimit Ready ===');
     lines.push('');
     process.stdout.write(lines.join('\n') + '\n');
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.1.6",
+  "version": "4.1.8",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [

package/bin/delimit-os.sh

@@ -1,105 +0,0 @@
-#!/bin/bash
-# Delimit OS — the AI developer operating system
-# Type 'delimit' to launch the TUI, or 'delimit <command>' for CLI tools
-#
-# Usage:
-#   delimit              → Launch TUI (interactive terminal dashboard)
-#   delimit --quick      → Quick status (non-interactive)
-#   delimit think        → Trigger deliberation
-#   delimit build        → Start autonomous build loop
-#   delimit ask <query>  → Ask the swarm
-#   delimit lint <spec>  → Lint an API spec
-#   delimit init         → Initialize governance in current repo
-#   delimit setup        → Configure AI assistants
-
-set -e
-
-DELIMIT_HOME="${DELIMIT_HOME:-$HOME/.delimit}"
-GATEWAY="$DELIMIT_HOME/server/ai"
-
-# If no args, launch TUI (interactive if terminal, quick if piped)
-if [ $# -eq 0 ]; then
-    if [ -f "$GATEWAY/tui.py" ]; then
-        if [ -t 1 ] && [ -t 0 ]; then
-            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui
-        else
-            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
-        fi
-    else
-        # Fallback to npm CLI
-        exec delimit-cli "$@"
-    fi
-fi
-
-# Route commands
-case "$1" in
-    --quick|-q)
-        if [ -f "$GATEWAY/tui.py" ]; then
-            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
-        else
-            exec delimit-cli status
-        fi
-        ;;
-    think|deliberate)
-        shift
-        QUESTION="${*:-What should we build next based on the current ledger and signals?}"
-        echo "[Delimit OS] Triggering deliberation..."
-        cd "$DELIMIT_HOME/server" && python3 -c "
-from ai.deliberation import deliberate
-import json
-result = deliberate('''$QUESTION''', mode='dialogue', max_rounds=3)
-if 'error' in result:
-    print(f'Error: {result[\"error\"]}')
-elif result.get('mode') == 'single_model_reflection':
-    print(f'Model: {result.get(\"model\", \"?\")}')
-    print(f'\\nAdvocate:\\n{result.get(\"advocate\", \"\")[:500]}')
-    print(f'\\nCritic:\\n{result.get(\"critic\", \"\")[:500]}')
-    print(f'\\nSynthesis:\\n{result.get(\"synthesis\", \"\")}')
-else:
-    print(f'Verdict: {result.get(\"final_verdict\", \"no consensus\")[:500]}')
-    print(f'Rounds: {result.get(\"rounds\", 0)}')
-" 2>&1
-        ;;
-    build|loop)
-        shift
-        echo "[Delimit OS] Starting autonomous build loop..."
-        echo "Checking ledger for next task..."
-        cd "$DELIMIT_HOME/server" && python3 -c "
-from ai.ledger_manager import get_context
-import json
-result = get_context()
-items = result.get('next_up', [])
-if items:
-    print(f'Next up: {items[0].get(\"id\", \"?\")} [{items[0].get(\"priority\", \"?\")}] {items[0].get(\"title\", \"?\")[:60]}')
-    print(f'Total open: {result.get(\"open_items\", 0)}')
-else:
-    print('Ledger is clear — nothing to build.')
-" 2>&1
-        ;;
-    ask)
-        shift
-        QUERY="$*"
-        if [ -z "$QUERY" ]; then
-            echo "Usage: delimit ask <question>"
-            exit 1
-        fi
-        echo "[Delimit OS] Checking context..."
-        cd "$DELIMIT_HOME/server" && python3 -c "
-from ai.ledger_manager import get_context
-import json
-result = get_context()
-print(json.dumps(result, indent=2)[:2000])
-" 2>&1
-        ;;
-    status)
-        if [ -f "$GATEWAY/tui.py" ]; then
-            cd "$GATEWAY/.." && exec python3 -m ai.tui --quick
-        else
-            exec delimit-cli status
-        fi
-        ;;
-    *)
-        # Pass through to delimit-cli for all other commands
-        exec delimit-cli "$@"
-        ;;
-esac

package/gateway/ai/ledger_propose.py

@@ -1,240 +0,0 @@
-"""Ledger Propose — AI-driven item generation from signals.
-
-Analyzes repo state, sensing signals, completed work, and venture priorities
-to propose 3-5 new ledger items with rationale. Runs at end of build loops
-when the queue is empty, or on-demand.
-
-Works across all AI models via MCP — no model-specific code.
-"""
-
-import json
-import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-
-SIGNALS_DIR = Path.home() / ".delimit" / "signals"
-PROPOSALS_DIR = Path.home() / ".delimit" / "proposals"
-
-
-def _gather_context(venture: str = "") -> Dict[str, Any]:
-    """Collect context from multiple sources for proposal generation."""
-    context = {
-        "timestamp": time.time(),
-        "venture": venture or "all",
-        "sources": {},
-    }
-
-    # 1. Recent ledger completions (what just shipped)
-    ledger_path = Path.home() / ".delimit" / "ledger.jsonl"
-    if ledger_path.exists():
-        recent_done = []
-        for line in ledger_path.read_text().strip().split("\n")[-100:]:
-            try:
-                item = json.loads(line)
-                if item.get("status") == "done":
-                    recent_done.append({
-                        "id": item.get("id", ""),
-                        "title": item.get("title", ""),
-                        "venture": item.get("venture", ""),
-                    })
-            except json.JSONDecodeError:
-                continue
-        context["sources"]["completed_work"] = recent_done[-10:]
-
-    # 2. Open items (what's already tracked)
-    open_items = []
-    if ledger_path.exists():
-        for line in ledger_path.read_text().strip().split("\n"):
-            try:
-                item = json.loads(line)
-                if item.get("status") == "open":
-                    open_items.append(item.get("title", ""))
-            except json.JSONDecodeError:
-                continue
-    context["sources"]["open_items_count"] = len(open_items)
-    context["sources"]["open_item_titles"] = open_items[:20]
-
-    # 3. Sensing signals (GitHub issues, Reddit, migrations)
-    signals_file = Path.home() / ".delimit" / "signals" / "recent.jsonl"
-    if signals_file.exists():
-        signals = []
-        for line in signals_file.read_text().strip().split("\n")[-20:]:
-            try:
-                sig = json.loads(line)
-                signals.append({
-                    "type": sig.get("type", ""),
-                    "title": sig.get("title", ""),
-                    "source": sig.get("source", ""),
-                    "relevance": sig.get("relevance", 0),
-                })
-            except json.JSONDecodeError:
-                continue
-        context["sources"]["signals"] = signals
-
-    # 4. Git recent activity
-    try:
-        import subprocess
-        result = subprocess.run(
-            ["git", "log", "--oneline", "-10"],
-            capture_output=True, text=True, timeout=5,
-        )
-        if result.returncode == 0:
-            context["sources"]["recent_commits"] = result.stdout.strip().split("\n")
-    except Exception:
-        pass
-
-    # 5. Swarm state
-    swarm_registry = Path.home() / ".delimit" / "swarm" / "agent_registry.json"
-    if swarm_registry.exists():
-        try:
-            reg = json.loads(swarm_registry.read_text())
-            context["sources"]["swarm_agents"] = len(reg.get("agents", {}))
-        except json.JSONDecodeError:
-            pass
-
-    return context
-
-
-def propose_items(
-    venture: str = "",
-    focus: str = "",
-    max_items: int = 5,
-) -> Dict[str, Any]:
-    """Generate proposed ledger items based on current context.
-
-    Analyzes completed work, open items, sensing signals, and repo state
-    to suggest what to work on next. Returns structured proposals that
-    can be added to the ledger with delimit_ledger_add.
-
-    This is the AI's "what should I do next?" engine. Works with any model.
-
-    Args:
-        venture: Focus proposals on a specific venture.
-        focus: Optional focus area (e.g., "outreach", "engineering", "security").
-        max_items: Maximum number of proposals to generate.
-    """
-    context = _gather_context(venture)
-
-    # Build proposal prompt from context
-    proposals = []
-    open_titles = set(context["sources"].get("open_item_titles", []))
-
-    # Strategy 1: Follow-through on completed work
-    for done in context["sources"].get("completed_work", []):
-        title = done.get("title", "")
-        if venture and done.get("venture", "") != venture:
-            continue
-        # Suggest follow-up actions
-        if "deploy" in title.lower() or "publish" in title.lower():
-            follow_up = f"Verify deployment: {title}"
-            if follow_up not in open_titles:
-                proposals.append({
-                    "title": follow_up,
-                    "rationale": f"Follow-through: '{title}' was shipped but may need verification",
-                    "priority": "P1",
-                    "type": "task",
-                    "source": "ledger_propose:follow_through",
-                })
-        if "outreach" in title.lower() or "issue" in title.lower():
-            follow_up = f"Monitor engagement: {title}"
-            if follow_up not in open_titles:
-                proposals.append({
-                    "title": follow_up,
-                    "rationale": f"Outreach needs monitoring for responses and engagement",
-                    "priority": "P1",
-                    "type": "task",
-                    "source": "ledger_propose:follow_through",
-                })
-
-    # Strategy 2: Act on unprocessed signals
-    for sig in context["sources"].get("signals", []):
-        sig_title = sig.get("title", "")
-        if sig_title and sig_title not in open_titles:
-            proposals.append({
-                "title": f"Evaluate signal: {sig_title[:80]}",
-                "rationale": f"Unprocessed {sig.get('type', 'signal')} from {sig.get('source', 'unknown')}",
-                "priority": "P1",
-                "type": "strategy",
-                "source": "ledger_propose:signal",
-            })
-
-    # Strategy 3: Detect gaps
-    has_tests = any("test" in t.lower() for t in open_titles)
-    has_docs = any("doc" in t.lower() or "readme" in t.lower() for t in open_titles)
-    has_security = any("security" in t.lower() or "audit" in t.lower() for t in open_titles)
-
-    if not has_tests and focus != "outreach":
-        proposals.append({
-            "title": f"Run test coverage analysis{f' for {venture}' if venture else ''}",
-            "rationale": "No test-related items in queue — ensure coverage hasn't regressed",
-            "priority": "P1",
-            "type": "task",
-            "source": "ledger_propose:gap_detection",
-        })
-
-    if not has_security and focus != "outreach":
-        proposals.append({
-            "title": f"Security audit{f' for {venture}' if venture else ''}",
-            "rationale": "No security items in queue — periodic audits prevent surprises",
-            "priority": "P2",
-            "type": "task",
-            "source": "ledger_propose:gap_detection",
-        })
-
-    if not has_docs:
-        proposals.append({
-            "title": f"Documentation freshness check{f' for {venture}' if venture else ''}",
-            "rationale": "No doc items in queue — ensure README/CHANGELOG reflect current state",
-            "priority": "P2",
-            "type": "task",
-            "source": "ledger_propose:gap_detection",
-        })
-
-    # Apply focus filter
-    if focus:
-        focus_lower = focus.lower()
-        proposals = [p for p in proposals if focus_lower in p.get("title", "").lower()
-                     or focus_lower in p.get("rationale", "").lower()
-                     or focus_lower in p.get("type", "").lower()]
-
-    # Deduplicate and limit
-    seen = set()
-    unique = []
-    for p in proposals:
-        key = p["title"][:50]
-        if key not in seen:
-            seen.add(key)
-            unique.append(p)
-    proposals = unique[:max_items]
-
-    # Save proposals for audit trail
-    PROPOSALS_DIR.mkdir(parents=True, exist_ok=True)
-    proposal_file = PROPOSALS_DIR / f"proposal_{int(time.time())}.json"
-    proposal_file.write_text(json.dumps({
-        "proposals": proposals,
-        "context_summary": {
-            "completed_work": len(context["sources"].get("completed_work", [])),
-            "open_items": context["sources"].get("open_items_count", 0),
-            "signals": len(context["sources"].get("signals", [])),
-            "swarm_agents": context["sources"].get("swarm_agents", 0),
-        },
-        "venture": venture,
-        "focus": focus,
-        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-    }, indent=2))
-
-    return {
-        "status": "ok",
-        "proposals": proposals,
-        "total": len(proposals),
-        "venture": venture or "all",
-        "focus": focus or "none",
-        "context": {
-            "completed_work_analyzed": len(context["sources"].get("completed_work", [])),
-            "open_items": context["sources"].get("open_items_count", 0),
-            "signals_analyzed": len(context["sources"].get("signals", [])),
-        },
-        "message": f"Generated {len(proposals)} proposal(s). "
-                   "Use delimit_ledger_add to add approved items.",
-    }

package/gateway/ai/reddit_proxy.py

@@ -1,106 +0,0 @@
-import json
-import logging
-import os
-import urllib.parse
-import urllib.request
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger("delimit.ai.reddit_proxy")
-
-def _get_proxy_config() -> Dict[str, str]:
-    """Load proxy config from private secrets or environment."""
-    config = {"proxy_url": ""}
-    
-    # 1. Check environment variable
-    env_url = os.environ.get("DELIMIT_REDDIT_PROXY")
-    if env_url:
-        config["proxy_url"] = env_url
-        return config
-
-    # 2. Check private secrets file
-    secrets_path = Path.home() / ".delimit" / "secrets" / "reddit-proxy.json"
-    if secrets_path.exists():
-        try:
-            secrets = json.loads(secrets_path.read_text())
-            config["proxy_url"] = secrets.get("proxy_url", "")
-        except Exception as e:
-            logger.debug(f"Failed to load reddit-proxy secrets: {e}")
-            
-    return config
-
-def fetch_subreddit(subreddit: str, sort: str = "new", limit: int = 10) -> List[Dict[str, Any]]:
-    """
-    Fetch posts from a single subreddit with fallback chain.
-    Returns standardized post dicts.
-    """
-    reddit_url = f"https://www.reddit.com/r/{subreddit}/{sort}.json?limit={limit}&raw_json=1"
-    
-    # 1. Try Local Proxy (Residential IP)
-    proxy_cfg = _get_proxy_config()
-    proxy_url = proxy_cfg.get("proxy_url")
-    if proxy_url:
-        try:
-            fetch_url = f"{proxy_url}?url={urllib.parse.quote(reddit_url, safe='')}"
-            req = urllib.request.Request(fetch_url, headers={"User-Agent": "Delimit/1.0"})
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                body = json.loads(resp.read().decode())
-                children = body.get("data", {}).get("children", [])
-                return [c.get("data", {}) for c in children if c.get("data")]
-        except Exception as e:
-            logger.debug(f"Local proxy failed for r/{subreddit}: {e}")
-
-    # 2. Fallback: PullPush API (Public Archive)
-    try:
-        pp_url = f"https://api.pullpush.io/reddit/search/submission/?subreddit={subreddit}&size={limit}&sort=desc"
-        req = urllib.request.Request(pp_url, headers={"User-Agent": "Delimit/1.0"})
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            body = json.loads(resp.read().decode())
-            return body.get("data", [])
-    except Exception as e:
-        logger.debug(f"PullPush fallback failed for r/{subreddit}: {e}")
-
-    # 3. Fallback: Direct (Often blocked on servers)
-    try:
-        req = urllib.request.Request(reddit_url, headers={"User-Agent": "Mozilla/5.0 (Delimit)"})
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            body = json.loads(resp.read().decode())
-            children = body.get("data", {}).get("children", [])
-            return [c.get("data", {}) for c in children if c.get("data")]
-    except Exception as e:
-        logger.warning(f"Direct fetch failed for r/{subreddit}: {e}")
-
-    return []
-
-def fetch_thread(thread_id: str) -> Optional[Dict[str, Any]]:
-    """
-    Fetch a single Reddit thread by ID with fallback chain.
-    """
-    reddit_url = f"https://www.reddit.com/comments/{thread_id}.json?raw_json=1"
-    
-    # 1. Try Local Proxy
-    proxy_cfg = _get_proxy_config()
-    proxy_url = proxy_cfg.get("proxy_url")
-    if proxy_url:
-        try:
-            fetch_url = f"{proxy_url}?url={urllib.parse.quote(reddit_url, safe='')}"
-            req = urllib.request.Request(fetch_url, headers={"User-Agent": "Delimit/1.0"})
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                data = json.loads(resp.read().decode())
-                if isinstance(data, list) and len(data) > 0:
-                    return data[0].get("data", {}).get("children", [{}])[0].get("data", {})
-        except Exception as e:
-            logger.debug(f"Local proxy failed for thread {thread_id}: {e}")
-
-    # 2. Fallback: PullPush
-    try:
-        pp_url = f"https://api.pullpush.io/reddit/search/submission/?ids={thread_id}"
-        req = urllib.request.Request(pp_url, headers={"User-Agent": "Delimit/1.0"})
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            body = json.loads(resp.read().decode())
-            data = body.get("data", [])
-            return data[0] if data else None
-    except Exception as e:
-        logger.debug(f"PullPush fallback failed for thread {thread_id}: {e}")
-
-    return None