delimit-cli 4.7.3 → 4.7.4

package/gateway/core/explainer.py

@@ -263,62 +263,95 @@ def _render_pr_comment(ctx: Dict) -> str:
     total = ctx["counts"]["total"]
     additive_count = ctx["counts"]["additive"]
 
-    # Header with semver badge
-    badge = {"major": "🔴 MAJOR", "minor": "🟡 MINOR", "patch": "🟢 PATCH", "none": "⚪ NONE"}
-    badge_text = badge.get(bump, bump.upper())
+    if bc == 0:
+        # ── GREEN PATH ──
+        semver_label = bump.upper() if bump != "none" else "NONE"
+        lines.append("## \U0001f6e1\ufe0f Governance Passed")
+        lines.append("")
+        if total > 0:
+            lines.append(
+                f"> **No breaking API changes detected.** "
+                f"{additive_count} additive change{'s' if additive_count != 1 else ''} "
+                f"found \u2014 Semver: **{semver_label}**"
+            )
+        else:
+            lines.append("> **No breaking API changes detected.**")
+        lines.append("")
 
-    if bc > 0:
-        lines.append(f"## {badge_text} — Breaking Changes Detected")
+        # Additive changes (collapsed)
+        additive = ctx["additive_changes"]
+        if additive:
+            lines.append("<details>")
+            lines.append(f"<summary>\u2705 New additions ({len(additive)})</summary>")
+            lines.append("")
+            for c in additive:
+                lines.append(f"- `{c['path']}` \u2014 {c['message']}")
+            lines.append("")
+            lines.append("</details>")
+            lines.append("")
     else:
-        lines.append(f"## {badge_text} — API Changes Look Good")
-    lines.append("")
+        # ── RED PATH ──
+        lines.append("## \U0001f6e1\ufe0f Breaking API Changes Detected")
+        lines.append("")
 
-    # Summary line
-    parts = [f"**{total}** change{'s' if total != 1 else ''}"]
-    if bc > 0:
-        parts.append(f"**{bc}** breaking")
-    if additive_count > 0:
-        parts.append(f"**{additive_count}** additive")
-    lines.append(" · ".join(parts))
-    lines.append("")
+        # Summary card
+        parts = [f"\U0001f534 **{bc} breaking change{'s' if bc != 1 else ''}**"]
+        parts.append("Semver: **MAJOR**")
+        separator = " \u00b7 "
+        lines.append(f"> {separator.join(parts)}")
+        lines.append("")
 
-    # Breaking changes table
-    if bc > 0:
+        # Stats table
+        lines.append("| | Count |")
+        lines.append("|---|---|")
+        lines.append(f"| Total changes | {total} |")
+        lines.append(f"| Breaking | {bc} |")
+        lines.append(f"| Additive | {additive_count} |")
+        lines.append("")
+
+        # Breaking changes table
         lines.append("### Breaking Changes")
         lines.append("")
-        lines.append("| Change | Location | Severity |")
-        lines.append("|--------|----------|----------|")
+        lines.append("| Severity | Change | Location |")
+        lines.append("|----------|--------|----------|")
         for c in ctx["breaking_changes"]:
             change_type = c.get("type", "breaking")
             severity = _pr_severity(change_type)
-            lines.append(f"| {c['message']} | `{c['path']}` | {severity} |")
+            lines.append(f"| {severity} | {c['message']} | `{c['path']}` |")
         lines.append("")
 
         # Migration guidance
         lines.append("<details>")
-        lines.append("<summary>📋 Migration guide</summary>")
+        lines.append("<summary>\U0001f4cb Migration guide</summary>")
         lines.append("")
         for i, c in enumerate(ctx["breaking_changes"], 1):
-            lines.append(f"**{i}. {c['path']}**")
-            lines.append(f"- {_pr_migration_hint(c)}")
+            lines.append(f"**{i}. `{c['path']}`**")
+            lines.append(f"{_pr_migration_hint(c)}")
             lines.append("")
         lines.append("</details>")
         lines.append("")
 
-    # Additive changes
-    additive = ctx["additive_changes"]
-    if additive:
-        lines.append("<details>")
-        lines.append(f"<summary>✅ New additions ({len(additive)})</summary>")
-        lines.append("")
-        for c in additive:
-            lines.append(f"- `{c['path']}` — {c['message']}")
-        lines.append("")
-        lines.append("</details>")
+        # Additive changes
+        additive = ctx["additive_changes"]
+        if additive:
+            lines.append("<details>")
+            lines.append(f"<summary>\u2705 New additions ({len(additive)})</summary>")
+            lines.append("")
+            for c in additive:
+                lines.append(f"- `{c['path']}` \u2014 {c['message']}")
+            lines.append("")
+            lines.append("</details>")
+            lines.append("")
+
+        lines.append("> **Fix locally:** `npx delimit-cli lint`")
         lines.append("")
 
     lines.append("---")
-    lines.append("*[Delimit](https://github.com/delimit-ai/delimit) · API governance for CI/CD*")
+    lines.append(
+        "Powered by [Delimit](https://delimit.ai) \u00b7 "
+        "[Docs](https://delimit.ai/docs) \u00b7 "
+        "[Install](https://github.com/marketplace/actions/delimit-api-governance)"
+    )
     return "\n".join(lines)
 
 

package/lib/ai-sbom-engine.js

@@ -17,6 +17,7 @@ const KNOWN_MODEL_PROVIDERS = [
     { pattern: /claude|anthropic/i, vendor: 'anthropic', family: 'claude' },
     { pattern: /openai|gpt-\d|o1|o3/i, vendor: 'openai', family: 'gpt' },
     { pattern: /gemini|vertex/i, vendor: 'google', family: 'gemini' },
+    { pattern: /antigravity|agy/i, vendor: 'google', family: 'antigravity' },
     { pattern: /codex/i, vendor: 'openai', family: 'codex' },
     { pattern: /grok|xai/i, vendor: 'xai', family: 'grok' },
     { pattern: /llama|mistral/i, vendor: 'meta-or-mistral', family: 'open-weight' },

package/lib/auth-setup.js

@@ -55,6 +55,7 @@ class DelimitAuthSetup {
             'claude': 'Anthropic Claude',
             'openai': 'OpenAI GPT',
             'gemini': 'Google Gemini',
+            'antigravity': 'Google Antigravity',
             'codex': 'GitHub Copilot'
         };
         
@@ -223,6 +224,11 @@ class DelimitAuthSetup {
                 config.projectId = await this.prompt(`  GCP Project ID (optional): `, '');
                 break;
                 
+            case 'antigravity':
+                config.apiKey = await this.promptSecret(`  Google AI API key (optional): `);
+                config.projectId = await this.prompt(`  GCP Project ID (optional): `, '');
+                break;
+                
             case 'codex':
                 config.token = await this.promptSecret(`  GitHub Copilot token: `);
                 break;
@@ -685,6 +691,9 @@ class DelimitAuthSetup {
         if (credentials.gemini?.apiKey) {
             envContent += `export GOOGLE_AI_API_KEY="${credentials.gemini.apiKey}"\n`;
         }
+        if (credentials.antigravity?.apiKey) {
+            envContent += `export ANTIGRAVITY_API_KEY="${credentials.antigravity.apiKey}"\n`;
+        }
         
         // Organization
         if (credentials.organization?.policyUrl) {
@@ -860,7 +869,7 @@ class DelimitAuthSetup {
             if (credentials.github.ghToken) console.log(chalk.gray('    - GitHub CLI configured'));
         }
         
-        for (const tool of ['claude', 'openai', 'gemini', 'codex']) {
+        for (const tool of ['claude', 'openai', 'gemini', 'antigravity', 'codex']) {
             if (credentials[tool]) {
                 console.log(chalk.white(`  • ${tool}: Configured`));
             }

package/lib/chat-repl.js

@@ -0,0 +1,244 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const { spawnSync, execSync } = require('child_process');
+
+class DelimitChatREPL {
+    constructor(options = {}) {
+        this.apiFallbackEnabled = options.apiFallback !== undefined ? 
+            !!options.apiFallback : 
+            (process.env.DELIMIT_API_FALLBACK === 'true' || false);
+        this.failedModels = new Set();
+        this.modelsConfig = this.loadModels();
+        this.routesConfig = this.loadRoutes();
+        this.agentName = 'orchestrator'; // Default agent
+    }
+
+    loadModels() {
+        const modelsPath = path.join(os.homedir(), '.delimit', 'models.json');
+        if (fs.existsSync(modelsPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
+            } catch (e) {
+                console.error(chalk.red('Failed to parse models.json'));
+            }
+        }
+        return { fallbacks: { default: [] } };
+    }
+
+    loadRoutes() {
+        const routesPath = path.join(os.homedir(), '.delimit', 'routes.json');
+        if (fs.existsSync(routesPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+            } catch (e) {}
+        }
+        return {};
+    }
+
+    getActiveChain() {
+        const chain = this.modelsConfig.fallbacks?.['default'] || [];
+        const activeModels = [];
+        
+        for (const provider of chain) {
+            if (this.failedModels.has(provider)) continue;
+            const p = this.modelsConfig[provider];
+            if (!p) continue;
+            
+            if (p.auth_mode === 'chat_login' || p.auth_mode === 'adc') {
+                activeModels.push({ id: provider, type: 'subscription' });
+            } else if (p.api_key && this.apiFallbackEnabled) {
+                activeModels.push({ id: provider, type: 'api' });
+            }
+        }
+        return activeModels;
+    }
+
+    start() {
+                console.log(chalk.magenta.bold(`
+      ____  ________    ______  _____________
+     / __ \\/ ____/ /   /  _/  |/  /  _/_  __/
+    / / / / __/ / /    / // /|_/ // /  / /   
+   / /_/ / /___/ /____/ // /  / // /  / /    
+  /_____/_____/_____/___/_/  /_/___/ /_/     
+  v4.7.3`));
+        
+        while (true) {
+            const chain = this.getActiveChain();
+            if (chain.length === 0) {
+                console.log(chalk.red('\n  Error: No active models available.'));
+                if (!this.apiFallbackEnabled) {
+                    console.log(chalk.yellow('  Auto-Phoenix stalled: All flat-rate subscription models have degraded.'));
+                    // Ask user to enable API fallback synchronously
+                    try {
+                        execSync('read -p "  Enable API Fallback to continue using paid tokens? (y/N) " yn && [ "$yn" = "y" ] || [ "$yn" = "Y" ]', {stdio: 'inherit'});
+                        this.apiFallbackEnabled = true;
+                        console.log(chalk.green('  API Fallback enabled. Resuming...\n'));
+                        continue;
+                    } catch (e) {
+                        console.log(chalk.gray('  API Fallback declined. Exiting.\n'));
+                        process.exit(1);
+                    }
+                } else {
+                    console.log(chalk.red('  Auto-Phoenix stalled: No remaining models in fallback chain.\n'));
+                    process.exit(1);
+                }
+            }
+
+            const activeModel = chain[0];
+            const chainStr = chain.map(m => m.type === 'subscription' ? chalk.green(m.id) : chalk.yellow(m.id)).join(' -> ');
+            console.log(`\n  [Agent: ${chalk.white(this.agentName)}] [API Fallback: ${this.apiFallbackEnabled ? chalk.green('ON') : chalk.gray('OFF')}]`);
+            console.log(`  Active Routing: ${chainStr}`);
+                        console.log(chalk.magenta.bold(`  [Delimit] `) + chalk.magenta(`═══════════════════════════════════════════`));
+            console.log(chalk.magenta.bold(`  [Delimit] `) + chalk.magenta(`<`) + chalk.yellow(`/`) + chalk.magenta(`> `) + chalk.bold(`GOVERNANCE ACTIVE: ${activeModel.id.toUpperCase()}`));
+            console.log(chalk.magenta.bold(`  [Delimit] `) + chalk.magenta(`═══════════════════════════════════════════\n`));
+
+            const shimPath = path.join(os.homedir(), '.delimit', 'shims', activeModel.id);
+            if (!fs.existsSync(shimPath)) {
+                console.log(chalk.red(`  Error: Shim not found for ${activeModel.id} at ${shimPath}`));
+                this.failedModels.add(activeModel.id);
+                continue;
+            }
+
+            // Probe model quota/health before entering interactive session
+            let isHealthy = true;
+            if (activeModel.id === 'claude' || activeModel.id === 'gemini' || activeModel.id === 'gemini_consumer' || activeModel.id === 'antigravity') {
+                process.stdout.write(`  Probing ${chalk.bold(activeModel.id)} quota... `);
+                
+                // Configure environment for the probe (identical to the run environment)
+                const probeEnv = { ...process.env, DELIMIT_QUIET: 'true' };
+                const p = this.modelsConfig[activeModel.id];
+                if (activeModel.id === 'claude') {
+                    if (p && p.auth_mode === 'chat_login') {
+                        delete probeEnv.ANTHROPIC_API_KEY;
+                    }
+                } else if (activeModel.id === 'gemini' || activeModel.id === 'gemini_consumer' || activeModel.id === 'antigravity') {
+                    if (!p || p.auth_mode === 'chat_login') {
+                        delete probeEnv.GOOGLE_CLOUD_PROJECT;
+                        delete probeEnv.GEMINI_USER_GCP_PROJECT;
+                        delete probeEnv.GEMINI_CLI_USE_COMPUTE_ADC;
+                        delete probeEnv.GOOGLE_APPLICATION_CREDENTIALS;
+                    }
+                }
+                
+                // Spawn the shim silently with -p "space" (timeout 6000ms)
+                const probeResult = spawnSync(shimPath, ['-p', 'space'], { env: probeEnv, timeout: 6000 });
+                
+                const isTimeout = probeResult.error && probeResult.error.code === 'ETIMEDOUT';
+                if ((probeResult.error && !isTimeout) || (probeResult.status !== null && probeResult.status !== 0)) {
+                    console.log(chalk.red('failed (out of quota/limit)'));
+                    isHealthy = false;
+                } else {
+                    console.log(chalk.green('verified'));
+                }
+            }
+            
+            if (!isHealthy) {
+                this.failedModels.add(activeModel.id);
+                continue;
+            }
+
+            const args = [];
+            if (activeModel.id.startsWith('gemini')) {
+                const p = this.modelsConfig[activeModel.id];
+                if (p && p.model) {
+                    let modelName = p.model;
+                    if (modelName.endsWith('-latest') && this.routesConfig[activeModel.id]) {
+                        const basePrefix = modelName.replace('-latest', '');
+                        const concrete = this.routesConfig[activeModel.id].find(m => m.startsWith(basePrefix) && m !== modelName);
+                        if (concrete) modelName = concrete;
+                    }
+                    args.unshift('-m', modelName);
+                }
+            }
+
+            const env = { ...process.env };
+            // Suppress the shim banner so it feels like a native session
+            env.DELIMIT_QUIET = 'true';
+            
+            const p = this.modelsConfig[activeModel.id];
+            
+            // Fix 403 Google Cloud API Error by preventing accidental enterprise routing
+            // If the model is using chat_login (consumer Google One plan), we MUST strip
+            // any global GCP env vars that would accidentally trigger Code Assist Enterprise mode.
+            if (activeModel.id === 'gemini' || activeModel.id === 'gemini_consumer' || activeModel.id === 'antigravity') {
+                if (!p || p.auth_mode === 'chat_login') {
+                    delete env.GOOGLE_CLOUD_PROJECT;
+                    delete env.GEMINI_USER_GCP_PROJECT;
+                    delete env.GEMINI_CLI_USE_COMPUTE_ADC;
+                    delete env.GOOGLE_APPLICATION_CREDENTIALS;
+                } else if (p && p.auth_mode === 'adc') {
+                    if (p.project) {
+                        env.GOOGLE_CLOUD_PROJECT = p.project;
+                        env.GEMINI_USER_GCP_PROJECT = p.project;
+                    }
+                    if (p.credentials_path) {
+                        env.GOOGLE_APPLICATION_CREDENTIALS = p.credentials_path;
+                    }
+                    env.GEMINI_CLI_USE_COMPUTE_ADC = 'true';
+                }
+            }
+
+            // Force Claude Code to use chat login rather than API keys when auth_mode is chat_login
+            if (activeModel.id === 'claude') {
+                if (p && p.auth_mode === 'chat_login') {
+                    delete env.ANTHROPIC_API_KEY;
+                }
+            }
+
+            // Execute the model interactively. Ignore SIGINT in parent while child runs
+            // to prevent Ctrl+C from killing the parent Node process.
+            const sigintHandler = () => {};
+            process.on('SIGINT', sigintHandler);
+            const result = spawnSync(shimPath, args, { stdio: 'inherit', env });
+            process.removeListener('SIGINT', sigintHandler);
+
+            if (result.status === 0) {
+                // Clean exit (user typed /exit)
+                console.log(chalk.gray('\n  Session saved. Exiting Delimit OS.'));
+                process.exit(0);
+            } else if (result.signal === 'SIGINT') {
+                console.log(chalk.yellow('\n  Session interrupted (Ctrl+C).'));
+                try {
+                    execSync('read -p "  Migrate to the next fallback model? (Y/n) " yn && [ "$yn" = "n" ] || [ "$yn" = "N" ]', {stdio: 'inherit'});
+                    console.log(chalk.yellow(`  ⚠ ${activeModel.id} interrupted. Auto-Phoenix initiating seamless migration...`));
+                    this.failedModels.add(activeModel.id);
+                    
+                    // Capture soul to preserve context before switching
+                    try {
+                        const pyCmd = `import sys; sys.path.insert(0, '/home/delimit/delimit-gateway'); from ai.session_phoenix import capture_soul; capture_soul(active_task='Auto-Phoenix migration from ${activeModel.id}')`;
+                        execSync(`python3 -c "${pyCmd}"`, { stdio: 'ignore' });
+                    } catch (e) {}
+
+                    if (chain.length > 1) {
+                        const nextModel = chain[1];
+                        console.log(chalk.green(`  ✓ Soul captured. Rehydrating into ${chalk.bold(nextModel.id)}...`));
+                    }
+                } catch (e) {
+                    console.log(chalk.gray('  Exiting Delimit OS.\n'));
+                    process.exit(0);
+                }
+            } else {
+                // The CLI crashed (e.g. 429 Quota Error or exit code != 0)
+                console.log(chalk.red(`\n  Execution failed: Model CLI exited with status ${result.status}`));
+                console.log(chalk.yellow(`  ⚠ ${activeModel.id} degraded. Auto-Phoenix initiating seamless migration...`));
+                this.failedModels.add(activeModel.id);
+                
+                // Capture soul to preserve context before switching
+                try {
+                    const pyCmd = `import sys; sys.path.insert(0, '/home/delimit/delimit-gateway'); from ai.session_phoenix import capture_soul; capture_soul(active_task='Auto-Phoenix migration from ${activeModel.id}')`;
+                    execSync(`python3 -c "${pyCmd}"`, { stdio: 'ignore' });
+                } catch (e) {}
+
+                if (chain.length > 1) {
+                    const nextModel = chain[1];
+                    console.log(chalk.green(`  ✓ Soul captured. Rehydrating into ${chalk.bold(nextModel.id)}...`));
+                }
+                // Loop continues to spawn the next model
+            }
+        }
+    }
+}
+
+module.exports = { DelimitChatREPL };

package/lib/cross-model-hooks.js

@@ -227,6 +227,29 @@ function detectAITools() {
         });
     }
 
+    // Antigravity CLI
+    const antigravityDir = path.join(getHome(), '.gemini', 'antigravity-cli');
+    let hasAntigravity = fs.existsSync(antigravityDir);
+    if (!hasAntigravity) {
+        try {
+            execSync('agy --version 2>/dev/null', { stdio: 'pipe', timeout: 3000 });
+            hasAntigravity = true;
+        } catch {
+            try {
+                execSync('antigravity --version 2>/dev/null', { stdio: 'pipe', timeout: 3000 });
+                hasAntigravity = true;
+            } catch { /* not installed */ }
+        }
+    }
+    if (hasAntigravity) {
+        detected.push({
+            id: 'antigravity',
+            name: 'Antigravity CLI',
+            configPath: path.join(antigravityDir, 'settings.json'),
+            format: 'antigravity-mcp',
+        });
+    }
+
     return detected;
 }
 
@@ -672,6 +695,58 @@ ${getDelimitSection()}
     return changes;
 }
 
+/**
+ * Install hooks for Antigravity CLI.
+ */
+function installAntigravityHooks(tool, hookConfig) {
+    const changes = [];
+    const antigravityDir = path.dirname(tool.configPath);
+    fs.mkdirSync(antigravityDir, { recursive: true });
+
+    // Update settings.json with custom instructions
+    let config = {};
+    if (fs.existsSync(tool.configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(tool.configPath, 'utf-8'));
+        } catch { config = {}; }
+    }
+
+    const govInstructions = getDelimitSectionCondensed();
+    const DELIMIT_MARKER = '<!-- delimit:start';
+
+    if (!config.customInstructions || !config.customInstructions.includes(DELIMIT_MARKER)) {
+        config.customInstructions = govInstructions;
+        changes.push('customInstructions');
+    }
+
+    fs.writeFileSync(tool.configPath, JSON.stringify(config, null, 2));
+
+    // ANTIGRAVITY.md: use the same upsert pattern as CLAUDE.md
+    const antigravityMd = path.join(getHome(), 'ANTIGRAVITY.md');
+    const managedSection = getDelimitSection();
+    if (!fs.existsSync(antigravityMd)) {
+        fs.writeFileSync(antigravityMd, managedSection + '\n');
+        changes.push('ANTIGRAVITY.md');
+    } else {
+        const existing = fs.readFileSync(antigravityMd, 'utf-8');
+        if (existing.includes(DELIMIT_MARKER) && existing.includes('<!-- delimit:end -->')) {
+            const before = existing.substring(0, existing.indexOf(DELIMIT_MARKER));
+            const after = existing.substring(existing.indexOf('<!-- delimit:end -->') + '<!-- delimit:end -->'.length);
+            const updated = before + managedSection + after;
+            if (updated !== existing) {
+                fs.writeFileSync(antigravityMd, updated);
+                changes.push('ANTIGRAVITY.md');
+            }
+        } else {
+            const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+            fs.writeFileSync(antigravityMd, existing + sep + managedSection + '\n');
+            changes.push('ANTIGRAVITY.md');
+        }
+    }
+
+    return changes;
+}
+
 /**
  * Install hooks for Gemini CLI.
  * Gemini CLI uses MCP (already handled by setup) but we add governance
@@ -744,6 +819,8 @@ function installHooksForTool(tool, hookConfig) {
             return { tool, changes: installCodexHooks(tool, hookConfig) };
         case 'gemini':
             return { tool, changes: installGeminiHooks(tool, hookConfig) };
+        case 'antigravity':
+            return { tool, changes: installAntigravityHooks(tool, hookConfig) };
         default:
             return { tool, changes: [] };
     }
@@ -880,6 +957,35 @@ function removeGeminiHooks() {
     return changed;
 }
 
+function removeAntigravityHooks() {
+    let changed = false;
+
+    // Remove custom instructions referencing delimit
+    const configPath = path.join(getHome(), '.gemini', 'antigravity-cli', 'settings.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (config.customInstructions && config.customInstructions.includes('delimit-cli hook')) {
+                delete config.customInstructions;
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+                changed = true;
+            }
+        } catch { /* ignore */ }
+    }
+
+    // Remove ANTIGRAVITY.md if it's ours
+    const antigravityMd = path.join(getHome(), 'ANTIGRAVITY.md');
+    if (fs.existsSync(antigravityMd)) {
+        const content = fs.readFileSync(antigravityMd, 'utf-8');
+        if (content.includes('Delimit Governance')) {
+            fs.unlinkSync(antigravityMd);
+            changed = true;
+        }
+    }
+
+    return changed;
+}
+
 function removeAllHooks() {
     const results = [];
 
@@ -892,6 +998,9 @@ function removeAllHooks() {
     if (removeGeminiHooks()) {
         results.push('Gemini CLI');
     }
+    if (removeAntigravityHooks()) {
+        results.push('Antigravity CLI');
+    }
 
     return results;
 }
@@ -1511,10 +1620,12 @@ module.exports = {
     installClaudeHooks,
     installCodexHooks,
     installGeminiHooks,
+    installAntigravityHooks,
     removeAllHooks,
     removeClaudeHooks,
     removeCodexHooks,
     removeGeminiHooks,
+    removeAntigravityHooks,
     loadHookConfig,
     hookSessionStart,
     hookBootstrap,

package/lib/timeline-engine.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+function generateTimeline(venturePath) {
+    const homedir = require('os').homedir();
+    const delimitHome = path.join(homedir, '.delimit');
+    const ledgerDir = path.join(delimitHome, 'ledger');
+    
+    const events = [];
+
+    // Read all ledger files
+    const files = ['operations.jsonl', 'strategy.jsonl'];
+    for (const file of files) {
+        const filePath = path.join(ledgerDir, file);
+        if (fs.existsSync(filePath)) {
+            const lines = fs.readFileSync(filePath, 'utf-8').trim().split('\n');
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const event = JSON.parse(line);
+                    events.push(event);
+                } catch (e) {}
+            }
+        }
+    }
+
+    // Sort by timestamp (fallback to 0)
+    events.sort((a, b) => new Date(a.created_at || a.ts || 0) - new Date(b.created_at || b.ts || 0));
+
+    if (events.length === 0) {
+        return "No history found in ledger.";
+    }
+
+    let output = chalk.bold.blue("\n  Delimit Venture Timeline — civilization-style retrospective\n\n");
+    
+    let lastDate = "";
+    for (const e of events) {
+        const ts = e.created_at || e.ts || new Date(0).toISOString();
+        const date = ts.split('T')[0];
+        if (date !== lastDate) {
+            output += chalk.bold.white(`\n  --- ${date} ---\n`);
+            lastDate = date;
+        }
+
+        const time = ts.split('T')[1]?.slice(0, 5) || "??:??";
+        const priority = e.priority === 'P0' ? chalk.red('P0') : e.priority === 'P1' ? chalk.yellow('P1') : chalk.gray(e.priority || 'n/a');
+        const type = e.type === 'strategy' ? chalk.magenta('STR') : chalk.cyan('OPS');
+        
+        output += `  ${chalk.gray(time)} [${type}] [${priority}] ${chalk.white(e.title || e.message || 'Untitled Event')}\n`;
+        if (e.status === 'done' || e.status === 'completed') {
+            output += `         ${chalk.green('✓ COMPLETED')}\n`;
+        }
+    }
+
+    output += chalk.dim(`\n  Total events: ${events.length}\n`);
+    return output;
+}
+
+module.exports = { generateTimeline };