delimit-cli 4.0.4 → 4.0.6

package/bin/delimit-cli.js

@@ -1318,7 +1318,7 @@ program
             }
         }
 
-        // Auto-detect OpenAPI spec files
+        // Auto-detect OpenAPI spec files — flat patterns + recursive scan
         const specPatterns = [
             'openapi.yaml', 'openapi.yml', 'openapi.json',
             'swagger.yaml', 'swagger.yml', 'swagger.json',
@@ -1329,9 +1329,146 @@ program
             'api/openapi.yaml', 'api/openapi.json',
             'contrib/openapi.json',
         ];
-        const foundSpecs = specPatterns.filter(p => fs.existsSync(path.join(projectDir, p)));
+        let foundSpecs = specPatterns.filter(p => fs.existsSync(path.join(projectDir, p)));
+
+        // Recursive scan: search common directories for OpenAPI/Swagger files
+        const specDirs = ['swagger', 'api', 'docs', 'spec', 'specs', 'openapi', 'schema', 'schemas', 'config', 'src'];
+        const specExtensions = ['.yaml', '.yml', '.json'];
+        const specKeywords = ['openapi', 'swagger', 'api-spec', 'api_spec'];
+        function scanDirForSpecs(dir, depth = 0) {
+            if (depth > 2) return [];  // limit recursion depth
+            const results = [];
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'vendor') continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory() && depth < 2) {
+                        results.push(...scanDirForSpecs(fullPath, depth + 1));
+                    } else if (entry.isFile() && specExtensions.includes(path.extname(entry.name).toLowerCase())) {
+                        // Check if file looks like an OpenAPI/Swagger spec
+                        const nameLower = entry.name.toLowerCase();
+                        const isLikelySpec = specKeywords.some(kw => nameLower.includes(kw)) || nameLower === 'api.yaml' || nameLower === 'api.yml' || nameLower === 'api.json';
+                        if (isLikelySpec) {
+                            results.push(path.relative(projectDir, fullPath));
+                        } else {
+                            // Peek inside to check for openapi/swagger key
+                            try {
+                                const head = fs.readFileSync(fullPath, 'utf-8').slice(0, 512);
+                                if (head.includes('"openapi"') || head.includes("openapi:") || head.includes('"swagger"') || head.includes("swagger:")) {
+                                    results.push(path.relative(projectDir, fullPath));
+                                }
+                            } catch {}
+                        }
+                    }
+                }
+            } catch {}
+            return results;
+        }
+        for (const sd of specDirs) {
+            const sdPath = path.join(projectDir, sd);
+            if (fs.existsSync(sdPath)) {
+                const deepSpecs = scanDirForSpecs(sdPath);
+                for (const ds of deepSpecs) {
+                    if (!foundSpecs.includes(ds)) foundSpecs.push(ds);
+                }
+            }
+        }
+        // Also scan root-level yaml/json files for OpenAPI markers
+        try {
+            const rootEntries = fs.readdirSync(projectDir, { withFileTypes: true });
+            for (const entry of rootEntries) {
+                if (!entry.isFile()) continue;
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!specExtensions.includes(ext)) continue;
+                const rel = entry.name;
+                if (foundSpecs.includes(rel)) continue;
+                try {
+                    const head = fs.readFileSync(path.join(projectDir, rel), 'utf-8').slice(0, 512);
+                    if (head.includes('"openapi"') || head.includes("openapi:") || head.includes('"swagger"') || head.includes("swagger:")) {
+                        foundSpecs.push(rel);
+                    }
+                } catch {}
+            }
+        } catch {}
         const specPath = foundSpecs.length > 0 ? foundSpecs[0] : null;
 
+        // Detect test files and count them
+        let testFileCount = 0;
+        let testFramework = null;
+        function countTestFiles(dir, depth = 0) {
+            if (depth > 3) return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'vendor' || entry.name === '__pycache__') continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (entry.name === '__tests__' || entry.name === 'test' || entry.name === 'tests' || entry.name === 'spec') {
+                            countTestFiles(fullPath, depth + 1);
+                        } else if (depth < 2) {
+                            countTestFiles(fullPath, depth + 1);
+                        }
+                    } else if (entry.isFile()) {
+                        const name = entry.name.toLowerCase();
+                        if (name.endsWith('.test.js') || name.endsWith('.test.ts') || name.endsWith('.test.tsx') || name.endsWith('.spec.js') || name.endsWith('.spec.ts')) {
+                            testFileCount++;
+                        } else if (name.startsWith('test_') && name.endsWith('.py')) {
+                            testFileCount++;
+                        } else if (name.endsWith('_test.go')) {
+                            testFileCount++;
+                        }
+                    }
+                }
+            } catch {}
+        }
+        countTestFiles(projectDir);
+        // Detect test framework
+        if (fs.existsSync(pkgJsonPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (allDeps['jest'] || (pkg.scripts && pkg.scripts.test && pkg.scripts.test.includes('jest'))) testFramework = 'jest';
+                else if (allDeps['vitest']) testFramework = 'vitest';
+                else if (allDeps['mocha']) testFramework = 'mocha';
+            } catch {}
+        }
+        if (!testFramework && fs.existsSync(requirementsPath)) {
+            try {
+                const content = fs.readFileSync(requirementsPath, 'utf-8').toLowerCase();
+                if (content.includes('pytest')) testFramework = 'pytest';
+            } catch {}
+        }
+
+        // Quick security scan
+        const securityFindings = [];
+        // Check for common secret patterns in spec files
+        for (const sp of foundSpecs.slice(0, 5)) {
+            try {
+                const content = fs.readFileSync(path.join(projectDir, sp), 'utf-8');
+                if (/(?:api[_-]?key|secret|password|token)\s*[:=]\s*["'][^"']{8,}/i.test(content)) {
+                    securityFindings.push({ severity: 'high', file: sp, issue: 'Possible hardcoded secret in spec file' });
+                }
+                if (/http:\/\/(?!localhost|127\.0\.0\.1)/i.test(content)) {
+                    securityFindings.push({ severity: 'medium', file: sp, issue: 'Non-localhost HTTP URL in spec (should use HTTPS)' });
+                }
+            } catch {}
+        }
+        // Check for .env files committed (not in .gitignore)
+        const envFiles = ['.env', '.env.local', '.env.production'];
+        const gitignorePath = path.join(projectDir, '.gitignore');
+        let gitignoreContent = '';
+        try { gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8'); } catch {}
+        for (const envFile of envFiles) {
+            if (fs.existsSync(path.join(projectDir, envFile))) {
+                if (!gitignoreContent.includes(envFile)) {
+                    securityFindings.push({ severity: 'high', file: envFile, issue: `${envFile} exists and is not in .gitignore` });
+                }
+            }
+        }
+        // Check for package-lock.json / yarn.lock (dependency lockfile)
+        const hasLockfile = fs.existsSync(path.join(projectDir, 'package-lock.json')) || fs.existsSync(path.join(projectDir, 'yarn.lock')) || fs.existsSync(path.join(projectDir, 'pnpm-lock.yaml'));
+
         // Check for CI
         const hasGitHub = fs.existsSync(path.join(projectDir, '.github'));
         const hasGitLabCI = fs.existsSync(path.join(projectDir, '.gitlab-ci.yml'));
@@ -1340,11 +1477,33 @@ program
         // Display detection results
         console.log(`  Project:   ${chalk.bold(projectName)}`);
         if (frameworkLabel) console.log(`  Framework: ${chalk.bold(frameworkLabel)}`);
-        if (specPath) console.log(`  Spec:      ${chalk.bold(specPath)}`);
-        else if (['fastapi', 'nestjs', 'express'].includes(framework))
+        if (foundSpecs.length > 1) {
+            console.log(`  Specs:     ${chalk.bold(foundSpecs.length + ' found')}`);
+            for (const sp of foundSpecs.slice(0, 5)) {
+                console.log(`             ${chalk.gray('-')} ${sp}`);
+            }
+            if (foundSpecs.length > 5) console.log(`             ${chalk.gray(`... and ${foundSpecs.length - 5} more`)}`);
+        } else if (specPath) {
+            console.log(`  Spec:      ${chalk.bold(specPath)}`);
+        } else if (['fastapi', 'nestjs', 'express'].includes(framework)) {
             console.log(`  Spec:      ${chalk.gray('none found')} (Zero-Spec Mode available for ${frameworkLabel})`);
-        else console.log(`  Spec:      ${chalk.gray('none found')}`);
+        } else {
+            console.log(`  Spec:      ${chalk.gray('none found')}`);
+        }
+        if (testFileCount > 0) {
+            console.log(`  Tests:     ${chalk.bold(testFileCount + ' file' + (testFileCount !== 1 ? 's' : ''))}${testFramework ? chalk.gray(' (' + testFramework + ')') : ''}`);
+        } else {
+            console.log(`  Tests:     ${chalk.gray('none detected')}`);
+        }
         if (ciProvider !== 'none') console.log(`  CI:        ${chalk.bold(ciProvider === 'github' ? 'GitHub Actions' : 'GitLab CI')}`);
+        if (securityFindings.length > 0) {
+            console.log(`  Security:  ${chalk.yellow(securityFindings.length + ' finding' + (securityFindings.length !== 1 ? 's' : ''))}`);
+        } else {
+            console.log(`  Security:  ${chalk.green('clean (quick scan)')}`);
+        }
+        if (!hasLockfile && fs.existsSync(pkgJsonPath)) {
+            console.log(`  Lockfile:  ${chalk.yellow('missing — consider committing a lockfile')}`);
+        }
         console.log('');
 
         // Step 2: Choose preset
@@ -1596,7 +1755,7 @@ jobs:
             }
         }
 
-        // Step 6: Save first evidence event (LED-258)
+        // Step 6: Save first evidence event + comprehensive report (LED-258)
         const evidenceDir = path.join(configDir, 'evidence');
         fs.mkdirSync(evidenceDir, { recursive: true });
         const evidenceEvent = {
@@ -1605,23 +1764,67 @@ jobs:
             type: 'governance_init',
             tool: 'delimit_init',
             model: 'cli',
-            status: 'pass',
+            status: securityFindings.some(f => f.severity === 'high') ? 'warn' : 'pass',
             summary: `Governance initialized with ${preset} preset`,
             detail: [
                 `Project: ${projectName}`,
                 frameworkLabel ? `Framework: ${frameworkLabel}` : null,
-                specPath ? `Spec: ${specPath}` : 'Mode: Zero-Spec',
+                foundSpecs.length > 0 ? `Specs found: ${foundSpecs.length} (${foundSpecs.join(', ')})` : 'Mode: Zero-Spec',
                 `Preset: ${preset}`,
+                `Test files: ${testFileCount}`,
+                testFramework ? `Test framework: ${testFramework}` : null,
                 ciProvider !== 'none' ? `CI: ${ciProvider}` : null,
+                securityFindings.length > 0 ? `Security findings: ${securityFindings.length}` : 'Security: clean',
             ].filter(Boolean).join('\n'),
             venture: projectName,
         };
         try {
             const evidenceFile = path.join(evidenceDir, 'events.jsonl');
             fs.appendFileSync(evidenceFile, JSON.stringify(evidenceEvent) + '\n');
-            console.log(chalk.green('  Evidence recorded — first governance event saved'));
         } catch {}
 
+        // Generate first evidence report (LED-258: zero-config onboarding)
+        const firstReport = {
+            generated_at: new Date().toISOString(),
+            project: projectName,
+            framework: frameworkLabel || 'unknown',
+            specs: {
+                count: foundSpecs.length,
+                files: foundSpecs,
+                primary: specPath,
+            },
+            tests: {
+                file_count: testFileCount,
+                framework: testFramework,
+            },
+            security: {
+                findings_count: securityFindings.length,
+                findings: securityFindings,
+                lockfile_present: hasLockfile,
+            },
+            governance: {
+                preset: preset,
+                compliance_template: complianceTemplate,
+                ci_provider: ciProvider,
+                gates_active: specPath || ['fastapi', 'nestjs', 'express'].includes(framework) ? ['api_lint'] : [],
+                gates_ready: ['security_audit', 'deploy_plan', 'release_validate'],
+            },
+        };
+        try {
+            const reportFile = path.join(evidenceDir, 'first-report.json');
+            fs.writeFileSync(reportFile, JSON.stringify(firstReport, null, 2));
+            console.log(chalk.green('  Evidence recorded — first governance report saved'));
+        } catch {}
+
+        // Display security findings if any
+        if (securityFindings.length > 0) {
+            console.log(chalk.bold('\n  Security Findings:'));
+            for (const finding of securityFindings) {
+                const icon = finding.severity === 'high' ? chalk.red('!') : chalk.yellow('~');
+                console.log(`    ${icon} ${chalk.bold(finding.severity.toUpperCase())} ${finding.file} — ${finding.issue}`);
+            }
+        }
+
         // Step 7: Show gate status (LED-258)
         console.log(chalk.bold('\n  Governance Gates:'));
         const gates = [
@@ -1639,15 +1842,29 @@ jobs:
         // Summary
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         console.log(chalk.bold(`\n  Setup complete in ${elapsed}s`));
-        console.log(chalk.gray(`  Evidence saved to .delimit/evidence/events.jsonl\n`));
+        console.log(chalk.gray(`  Evidence saved to .delimit/evidence/\n`));
         console.log('  Next steps:');
         if (specPath) {
             console.log(`    ${chalk.bold('delimit lint')} ${specPath} ${specPath}  — lint on every PR`);
+        } else if (['fastapi', 'nestjs', 'express'].includes(framework)) {
+            console.log(`    ${chalk.bold('delimit lint')}                           — zero-spec mode (${frameworkLabel})`);
         } else {
-            console.log(`    ${chalk.bold('delimit lint')}                           — zero-spec mode`);
+            console.log(`    ${chalk.bold('delimit lint')}                           — add an OpenAPI spec first`);
         }
         console.log(`    ${chalk.bold('delimit doctor')}                         — verify setup`);
         console.log(`    ${chalk.bold('delimit explain')}                        — human-readable report`);
+        if (securityFindings.length > 0) {
+            console.log(`    ${chalk.yellow('Fix security findings above')}            — ${securityFindings.length} issue${securityFindings.length !== 1 ? 's' : ''} found`);
+        }
+        if (testFileCount === 0) {
+            console.log(`    ${chalk.gray('Add tests')}                              — no test files detected`);
+        }
+        if (foundSpecs.length > 1) {
+            console.log(`    ${chalk.gray('Review all ' + foundSpecs.length + ' specs')}                       — multiple specs detected`);
+        }
+        if (ciProvider === 'none') {
+            console.log(`    ${chalk.gray('Add CI')}                                 — no CI detected; consider GitHub Actions`);
+        }
 
         // Beta capture after init (LED-263)
         if (!options.yes) {

package/bin/delimit-os.sh

@@ -0,0 +1,105 @@
+#!/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/tui.py

@@ -0,0 +1,296 @@
+"""Delimit TUI — Terminal User Interface (Phase 2 of Delimit OS).
+
+The proprietary terminal experience. Type 'delimit' and get an OS-like
+environment with panels for ledger, swarm, memory, and live logs.
+
+Enterprise-ready: zero JS, pure Python, works over SSH, sub-2s boot.
+Designed for devs who hate browser-based tools.
+
+Usage:
+    python -m ai.tui          # Full TUI
+    python -m ai.tui --quick  # Quick status (no interactive mode)
+"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import (
+    Header, Footer, Static, DataTable, Log, TabbedContent, TabPane,
+    Label, ProgressBar, Button, Input,
+)
+from textual.timer import Timer
+from textual import work
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+# ── Data loaders ─────────────────────────────────────────────────────
+
+LEDGER_DIR = Path.home() / ".delimit" / "ledger"
+SWARM_DIR = Path.home() / ".delimit" / "swarm"
+MEMORY_DIR = Path.home() / ".delimit" / "memory"
+SESSIONS_DIR = Path.home() / ".delimit" / "sessions"
+
+
+def _load_ledger_items(status: str = "open", limit: int = 20) -> List[Dict]:
+    items = []
+    for fname in ("operations.jsonl", "strategy.jsonl"):
+        path = LEDGER_DIR / fname
+        if not path.exists():
+            continue
+        for line in path.read_text().strip().split("\n")[-200:]:
+            try:
+                d = json.loads(line)
+                if d.get("status") == status:
+                    items.append(d)
+            except json.JSONDecodeError:
+                continue
+    items.sort(key=lambda x: (0 if x.get("priority") == "P0" else 1 if x.get("priority") == "P1" else 2))
+    return items[:limit]
+
+
+def _load_swarm_status() -> Dict[str, Any]:
+    registry = SWARM_DIR / "agent_registry.json"
+    if not registry.exists():
+        return {"agents": 0, "ventures": 0}
+    try:
+        data = json.loads(registry.read_text())
+        agents = data.get("agents", {})
+        ventures = set(a.get("venture", "") for a in agents.values())
+        return {
+            "agents": len(agents),
+            "ventures": len(ventures),
+            "by_venture": {v: sum(1 for a in agents.values() if a.get("venture") == v) for v in ventures},
+        }
+    except (json.JSONDecodeError, KeyError):
+        return {"agents": 0, "ventures": 0}
+
+
+def _load_recent_sessions(limit: int = 5) -> List[Dict]:
+    if not SESSIONS_DIR.exists():
+        return []
+    sessions = []
+    for f in sorted(SESSIONS_DIR.glob("*.json"), reverse=True)[:limit]:
+        try:
+            sessions.append(json.loads(f.read_text()))
+        except (json.JSONDecodeError, KeyError):
+            continue
+    return sessions
+
+
+# ── Widgets ──────────────────────────────────────────────────────────
+
+class LedgerPanel(Static):
+    """Live ledger view — shows open items sorted by priority."""
+
+    def compose(self) -> ComposeResult:
+        yield DataTable(id="ledger-table")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#ledger-table", DataTable)
+        table.add_columns("ID", "P", "Title", "Venture", "Type")
+        self._refresh_data()
+        self.set_interval(30, self._refresh_data)
+
+    def _refresh_data(self) -> None:
+        table = self.query_one("#ledger-table", DataTable)
+        table.clear()
+        for item in _load_ledger_items("open", 25):
+            table.add_row(
+                item.get("id", ""),
+                item.get("priority", ""),
+                item.get("title", "")[:60],
+                item.get("venture", "")[:15],
+                item.get("type", ""),
+            )
+
+
+class SwarmPanel(Static):
+    """Swarm status — agents, ventures, health."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="swarm-content")
+
+    def on_mount(self) -> None:
+        self._refresh_data()
+        self.set_interval(15, self._refresh_data)
+
+    def _refresh_data(self) -> None:
+        content = self.query_one("#swarm-content", Static)
+        swarm = _load_swarm_status()
+        lines = [
+            f"[bold cyan]Agents:[/] {swarm['agents']}  |  [bold cyan]Ventures:[/] {swarm['ventures']}",
+            "",
+        ]
+        for venture, count in swarm.get("by_venture", {}).items():
+            lines.append(f"  [green]{venture}[/]: {count} agents")
+        content.update("\n".join(lines))
+
+
+class SessionPanel(Static):
+    """Recent sessions — handoff history."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="session-content")
+
+    def on_mount(self) -> None:
+        self._refresh_data()
+
+    def _refresh_data(self) -> None:
+        content = self.query_one("#session-content", Static)
+        sessions = _load_recent_sessions(5)
+        if not sessions:
+            content.update("[dim]No sessions recorded yet.[/]")
+            return
+        lines = []
+        for s in sessions:
+            ts = s.get("timestamp", s.get("closed_at", ""))[:16]
+            summary = s.get("summary", "")[:80]
+            completed = len(s.get("items_completed", []))
+            lines.append(f"[dim]{ts}[/] — {summary}")
+            if completed:
+                lines.append(f"  [green]✓ {completed} items completed[/]")
+        content.update("\n".join(lines))
+
+
+class GovernanceBar(Static):
+    """Top status bar — governance health at a glance."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="gov-bar")
+
+    def on_mount(self) -> None:
+        self._refresh()
+        self.set_interval(60, self._refresh)
+
+    def _refresh(self) -> None:
+        bar = self.query_one("#gov-bar", Static)
+        ledger_count = len(_load_ledger_items("open", 999))
+        swarm = _load_swarm_status()
+        mode_file = Path.home() / ".delimit" / "enforcement_mode"
+        mode = mode_file.read_text().strip() if mode_file.exists() else "default"
+
+        bar.update(
+            f"  [bold magenta]</>[/] [bold]Delimit OS[/]  |  "
+            f"[cyan]Ledger:[/] {ledger_count} open  |  "
+            f"[cyan]Swarm:[/] {swarm['agents']} agents / {swarm['ventures']} ventures  |  "
+            f"[cyan]Mode:[/] {mode}  |  "
+            f"[dim]{time.strftime('%H:%M')}[/]"
+        )
+
+
+# ── Main App ─────────────────────────────────────────────────────────
+
+class DelimitOS(App):
+    """Delimit OS — the AI developer operating system."""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    #gov-bar {
+        height: 1;
+        background: $primary-background;
+        color: $text;
+        padding: 0 1;
+    }
+    TabbedContent {
+        height: 1fr;
+    }
+    DataTable {
+        height: 1fr;
+    }
+    #swarm-content, #session-content {
+        padding: 1;
+    }
+    """
+
+    TITLE = "Delimit OS"
+    SUB_TITLE = "AI Developer Operating System"
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("l", "focus_ledger", "Ledger"),
+        ("s", "focus_swarm", "Swarm"),
+        ("h", "focus_sessions", "History"),
+        ("r", "refresh", "Refresh"),
+        ("t", "think", "Think"),
+        ("b", "build", "Build"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield GovernanceBar()
+        with TabbedContent():
+            with TabPane("Ledger", id="tab-ledger"):
+                yield LedgerPanel()
+            with TabPane("Swarm", id="tab-swarm"):
+                yield SwarmPanel()
+            with TabPane("Sessions", id="tab-sessions"):
+                yield SessionPanel()
+        yield Footer()
+
+    def action_focus_ledger(self) -> None:
+        self.query_one(TabbedContent).active = "tab-ledger"
+
+    def action_focus_swarm(self) -> None:
+        self.query_one(TabbedContent).active = "tab-swarm"
+
+    def action_focus_sessions(self) -> None:
+        self.query_one(TabbedContent).active = "tab-sessions"
+
+    def action_refresh(self) -> None:
+        for panel in self.query(LedgerPanel):
+            panel._refresh_data()
+        for panel in self.query(SwarmPanel):
+            panel._refresh_data()
+        for panel in self.query(SessionPanel):
+            panel._refresh_data()
+        self.query_one(GovernanceBar)._refresh()
+
+    def action_think(self) -> None:
+        self.notify("Deliberation triggered — check ledger for results", title="Think")
+
+    def action_build(self) -> None:
+        self.notify("Build loop started — swarm dispatching tasks", title="Build")
+
+
+def main():
+    """Entry point for 'delimit' command."""
+    import sys
+    if "--quick" in sys.argv:
+        # Quick status mode — no interactive TUI
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console()
+        console.print("\n[bold magenta]</>[/] [bold]Delimit OS[/]\n")
+
+        swarm = _load_swarm_status()
+        items = _load_ledger_items("open", 10)
+
+        console.print(f"[cyan]Swarm:[/] {swarm['agents']} agents across {swarm['ventures']} ventures")
+        console.print(f"[cyan]Ledger:[/] {len(items)} open items\n")
+
+        if items:
+            table = Table(title="Open Items")
+            table.add_column("ID", style="dim")
+            table.add_column("P", style="bold")
+            table.add_column("Title")
+            table.add_column("Venture", style="green")
+            for item in items[:10]:
+                table.add_row(
+                    item.get("id", ""),
+                    item.get("priority", ""),
+                    item.get("title", "")[:60],
+                    item.get("venture", "")[:15],
+                )
+            console.print(table)
+        return
+
+    app = DelimitOS()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

package/package.json

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