@omnitype-code/cli 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Changelog
+
+All notable changes to the **@omnitype-code/cli** package are documented here.
+
+---
+
+## [0.1.3] — 2026-05-16
+
+### Added
+- **`omnitype doctor`** — New command showing hook status for every detected tool: `installed`, `stale`, `not-installed`, or `tool-absent`. `--fix` flag auto-installs or upgrades missing hooks. Fires market-analysis telemetry (signed-in users only).
+- **`omnitype status` workspace fix** — Status command now passes `process.cwd()` into model detection, scoping Claude Code transcript scanning to the current workspace. Sessions from other concurrently open projects no longer bleed in.
+- **Per-project sentinel** — Hooks write to `<project_root>/.omnitype/active-model.json` (`process.cwd()` at invocation) in addition to `~/.omnitype/` fallback. `status` and `daemon` check project-local first, eliminating cross-window contamination.
+- **`initWorkspace()` in daemon** — `startDaemon()` creates `.omnitype/` in the watched directory and appends `.omnitype/` to `.gitignore` on first run.
+- **New hooks auto-installed** — Gemini CLI (`~/.gemini/settings.json` BeforeTool/AfterTool), Droid / Factory (`~/.factory/settings.json` PreToolUse), Firebender (`~/.firebender/hooks.json`), GitHub Copilot (`~/.copilot/hooks/omnitype.json`).
+- **New TS plugins** — Amp (`~/.config/amp/plugins/omnitype.ts`), OpenCode (`~/.config/opencode/plugins/omnitype.ts`), Pi (`~/.pi/agent/extensions/omnitype.ts`). Each dual-writes to project-local and global paths.
+- **New transcript readers** — `TranscriptScanner` now covers Continue (`~/.continue/sessions/`), Copilot CLI (`~/.copilot/session-state/`), and Droid (`~/.factory/sessions/`).
+- **`ToolDetector` updated** — Gemini CLI, Droid, Firebender, Amp, OpenCode, and Pi marked `hooked`.
+
+### Changed
+- **`HOOK_VERSION` bumped to `v4`** — All stale v3 hooks auto-replaced on next activation.
+- **Attribution Protocol upgraded to v1.2** — See `PROTOCOL.md`.
+
+---
+
+## [0.1.2] — 2026-05-16
+
+### Fixed
+- **Sentinel race condition** — Replaced 10s time-window TTL with path-gated matching. Sentinel is only trusted if `sentinel.file === changedPath`, eliminating cross-file attribution contamination.
+- **TranscriptScanner** — Added as a detection tier between env vars and IDE config parsing. Reads the 50KB tail of the most recent JSONL session file per tool, with a 60s cache.
+- **Claude Code hook** — Added to `installAllToolHooks` — was missing from the CLI installer in v0.1.1.
+- **Hook model fallbacks removed** — Hook writer now skips write if the model cannot be resolved. No more hardcoded `claude-sonnet-4-6` fallback.
+- **`SENTINEL_MAX_AGE_MS`** raised from 10s to 30s for the strict (no file field) fallback path.
+
+### Changed
+- Detection pipeline order is now: sentinel (universal) → sentinel (hooks) → env vars → transcript scan → IDE configs → ps → lsof.
+
+### Added
+- **Cline hook installer** — drops a `PreToolUse` script into `~/Documents/Cline/Hooks/` on startup. Idempotent, fires only for file-modifying tools.
+- `installAllToolHooks` now covers Claude Code, Cursor, Windsurf, Codex, and Cline.
+
+---
+
+## [0.1.1] — 2026-05-14
+
+### Added
+- **`omnitype signal --model <name>`** — Manually report active AI models from scripts or unsupported tools.
+- **`omnitype blame <file>`** — ANSI-colored per-line attribution with model names.
+- **`omnitype daemon`** — Editor-agnostic file watching for Cursor, Windsurf, JetBrains, Neovim, and any other editor. Auto-yields to the VS Code extension for live-tracked workspaces (30-second yield guard).
+- **`omnitype hooks install`** — Installs a pre-push git hook that writes git notes and syncs attribution to the cloud.
+- **`omnitype syncNow`** — Manual provenance sync command.
+- **Smart Claude hook** — Automatically detects model preferences from `~/.claude/settings.json`.
+- **Protocol v1.1 support** — Writes `file` and `genId` fields in sentinel output.
+- **Rich CLI UI** — Colors, progress spinners, and structured error reporting.
+- **Org-only cloud storage** — Individual users remain local-only. Cloud sync gates on organization membership.
+- **Provenance routes modularized** — Internal route handlers split into separate files.
+
+---
+
+## [0.1.0] — 2026-05-13
+
+### Added
+- Initial CLI package.
+- Git hook manager for push coverage — hooks written per-repo on install.
+- AI model attribution tracking wired into personal vs. org project storage.
+- File deletion tracking with per-line timestamps in provenance metadata.
+- Cloud sync to S3 blobs with MongoDB manifest references.
+
+---

package/dist/core/ApiClient.js

@@ -193,6 +193,21 @@ class ApiClient {
         if (failed.length)
             throw new Error(`Push failed for chunks: ${failed.join(', ')}`);
     }
+    /**
+     * Fire-and-forget: reports which AI tools are detected on this machine.
+     * Used for market analysis — understanding which tools users have alongside OmniType.
+     * Never throws. Only sends if the user is signed in (respects opt-in via login).
+     */
+    reportToolEnvironment(tools) {
+        if (!this.isSignedIn)
+            return;
+        const body = { tools, platform: process.platform, ts: Date.now() };
+        fetch(`${this.apiUrl}/telemetry/tools`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${this.config.token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        }).catch(() => { }); // best-effort, never surface errors
+    }
     async _postWithRetry(url, body, attempts, label) {
         const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
         for (let i = 0; i < attempts; i++) {

package/dist/core/ModelDetector.js

@@ -1,15 +1,4 @@
 "use strict";
-/**
- * CLI ModelDetector — editor-agnostic model detection.
- *
- * Detection tiers:
- *   1. Universal sentinel   (~/.omnitype/active-model.json)
- *   2. Hooks sentinel file  (~/.claude/provenance-hook.json)
- *   3. Host IDE config      (Cursor/Windsurf/Zed settings.json — scanned generically)
- *   4. Config files         (per-tool config paths: .aider.conf.yml, etc.)
- *   5. Environment variables (CLAUDE_MODEL, AIDER_MODEL, etc.)
- *   6. Process detection    (lsof / ps — identifies the writing process)
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -49,116 +38,145 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const TranscriptScanner_1 = require("./TranscriptScanner");
 const UNKNOWN = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-const HOOKS_SENTINEL_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
-const UNIVERSAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
-const SENTINEL_MAX_AGE_MS = 10000;
-const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[1234](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
-// Maps known CLI/IDE env vars to their tool
+const SENTINEL_MAX_AGE_MS = 30000;
+const GLOBAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+function projectSentinelPath(cwd) {
+    return path.join(cwd ?? process.cwd(), '.omnitype', 'active-model.json');
+}
+// Matches model identifier strings from all major providers.
+const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[134](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
+// Each tool lists its OWN env vars only. Shared vars (OPENAI_MODEL) are NOT duplicated
+// across tools — the first matching entry wins, so ambiguous vars are assigned to
+// the most common owner (openai). Tools with a dedicated var (CODEX_MODEL) are checked
+// earlier so they can claim edits even when OPENAI_MODEL is also set.
 const ENV_VARS = [
-    { vars: ['CLAUDE_MODEL', 'CLAUDE_CODE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
+    { vars: ['CLAUDE_CODE_MODEL', 'CLAUDE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
     { vars: ['AIDER_MODEL'], tool: 'aider' },
+    { vars: ['CODEX_MODEL'], tool: 'codex' }, // before generic OPENAI_MODEL
     { vars: ['OPENAI_MODEL', 'OPENAI_API_MODEL'], tool: 'openai' },
-    { vars: ['GEMINI_MODEL', 'GEMINI_API_KEY'], tool: 'gemini-cli' },
+    { vars: ['GEMINI_MODEL'], tool: 'gemini-cli' },
     { vars: ['OLLAMA_MODEL'], tool: 'ollama' },
     { vars: ['COPILOT_MODEL'], tool: 'copilot' },
     { vars: ['LLM_MODEL'], tool: 'openhands' },
     { vars: ['TABBY_MODEL'], tool: 'tabby' },
 ];
-const KNOWN_FORKS = [
-    'Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'
-];
-// lsof command-name → tool mapping
-const LSOF_CMD_MAP = [
+const KNOWN_FORKS = ['Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'];
+const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+// Host IDE processes: always running — their presence does NOT mean they caused the edit.
+const HOST_IDE_PROCS = new Set(['cursor', 'windsurf', 'antigravity', 'pearai', 'void', 'trae', 'zed']);
+const PROC_MAP = [
     { match: 'claude', tool: 'claude-code' },
     { match: 'aider', tool: 'aider' },
-    { match: 'cursor', tool: 'cursor' },
-    { match: 'windsurf', tool: 'windsurf' },
-    { match: 'zed', tool: 'zed' },
-    { match: 'pearai', tool: 'pearai' },
-    { match: 'void', tool: 'void' },
-    { match: 'tabby', tool: 'tabby' },
     { match: 'goose', tool: 'goose' },
-    { match: 'node', tool: 'unknown-cli' },
-    { match: 'python', tool: 'unknown-cli' },
+    { match: 'codex', tool: 'codex' },
+    { match: 'tabby', tool: 'tabby' },
 ];
 class ModelDetector {
-    detect(changedFilePath) {
-        return (this._fromUniversalSentinel() ??
-            this._fromHooksSentinel() ??
-            this._fromIdeConfigs() ??
+    detect(changedFilePath, cwd) {
+        return (this._sentinel(projectSentinelPath(cwd), changedFilePath) ??
+            this._sentinel(GLOBAL_SENTINEL_PATH, changedFilePath) ??
             this._fromEnv() ??
-            this._fromPsPatterns() ??
+            this._fromTranscripts(cwd) ??
+            this._fromIdeConfigs() ??
+            this._fromPs() ??
             (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
             UNKNOWN);
     }
-    _fromUniversalSentinel() {
-        try {
-            const stat = fs.statSync(UNIVERSAL_SENTINEL_PATH);
-            if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS)
-                return undefined;
-            const data = JSON.parse(fs.readFileSync(UNIVERSAL_SENTINEL_PATH, 'utf8'));
-            if (!data?.model || data.model === 'unknown')
-                return undefined;
-            return { model: data.model, tool: data.tool ?? 'unknown-tool', confidence: 'deterministic' };
-        }
-        catch {
+    _fromTranscripts(cwd) {
+        const r = (0, TranscriptScanner_1.scanTranscripts)(cwd);
+        if (!r)
             return undefined;
-        }
+        return { model: r.model, tool: r.tool, confidence: 'high' };
     }
-    _fromHooksSentinel() {
+    _sentinel(filePath, changedPath) {
         try {
-            const stat = fs.statSync(HOOKS_SENTINEL_PATH);
-            if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS)
+            const mtime = fs.statSync(filePath).mtimeMs;
+            const d = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (!d?.model || d.model === 'unknown')
                 return undefined;
-            const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
-            if (!data?.model || data.model === 'unknown')
+            if (d.file && changedPath) {
+                // File-path gated: trust only if the sentinel targets this exact file.
+                // Use a generous TTL since path specificity eliminates cross-file contamination.
+                if (d.file !== changedPath)
+                    return undefined;
+                if (Date.now() - mtime > 120000)
+                    return undefined; // 2 min max
+            }
+            else {
+                // No path info: fall back to strict TTL to minimise false attribution.
+                if (Date.now() - mtime > SENTINEL_MAX_AGE_MS)
+                    return undefined;
+            }
+            if (!d?.model || d.model === 'unknown')
                 return undefined;
-            return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+            return { model: d.model, tool: d.tool ?? 'unknown-tool', confidence: 'deterministic' };
         }
         catch {
             return undefined;
         }
     }
+    _fromEnv() {
+        for (const { vars, tool } of ENV_VARS)
+            for (const v of vars) {
+                const val = process.env[v];
+                if (val && MODEL_PATTERN.test(val))
+                    return { model: val, tool, confidence: 'high' };
+            }
+        return undefined;
+    }
     _fromIdeConfigs() {
         for (const appName of KNOWN_FORKS) {
             const scan = this._scanIdeSettings(appName);
-            if (scan) {
-                return {
-                    model: scan.model,
-                    tool: appName.toLowerCase(),
-                    confidence: scan.isAuto ? 'medium' : 'high'
-                };
-            }
+            if (scan)
+                return { model: scan.model, tool: appName.toLowerCase(), confidence: scan.isAuto ? 'medium' : 'high' };
         }
+        // Copilot: no hook API, but model is readable from VS Code / fork settings.json
+        const copilot = this._fromCopilotConfig();
+        if (copilot)
+            return copilot;
         return undefined;
     }
-    _fromEnv() {
-        for (const { vars, tool } of ENV_VARS) {
-            for (const v of vars) {
-                const val = process.env[v];
-                if (val && MODEL_PATTERN.test(val)) {
-                    return { model: val, tool, confidence: 'high' };
+    _fromCopilotConfig() {
+        const COPILOT_KEYS = [
+            'github.copilot.advanced.model',
+            'github.copilot.selectedModel',
+            'github.copilot.chat.models.default',
+            'github.copilot.chat.agent.model',
+        ];
+        // Check VS Code and every known fork's settings.json
+        const vscodePaths = (() => {
+            switch (process.platform) {
+                case 'darwin': return [path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json')];
+                case 'win32': return [path.join(process.env.APPDATA ?? '', 'Code', 'User', 'settings.json')];
+                default: return [path.join(os.homedir(), '.config', 'Code', 'User', 'settings.json')];
+            }
+        })();
+        for (const settingsPath of vscodePaths) {
+            try {
+                const flat = this._flatten(JSON.parse(fs.readFileSync(settingsPath, 'utf8')));
+                for (const key of COPILOT_KEYS) {
+                    const val = flat[key];
+                    if (typeof val === 'string' && val && MODEL_PATTERN.test(val))
+                        return { model: val.toLowerCase(), tool: 'copilot', confidence: 'high' };
                 }
             }
+            catch { }
         }
         return undefined;
     }
-    _fromPsPatterns() {
+    _fromPs() {
         if (process.platform === 'win32')
             return undefined;
         try {
             const lines = (0, child_process_1.execFileSync)('ps', ['ax', '-o', 'args='], { timeout: 800, encoding: 'utf8' }).split('\n');
-            for (const line of lines) {
-                for (const entry of LSOF_CMD_MAP) {
-                    if (line.toLowerCase().includes(entry.match)) {
-                        // Fallback model name
-                        return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-                    }
-                }
-            }
+            for (const line of lines)
+                for (const { match, tool } of PROC_MAP)
+                    if (line.toLowerCase().includes(match) && !HOST_IDE_PROCS.has(tool))
+                        return { model: `${tool}-default`, tool, confidence: 'low' };
         }
-        catch { /* ps unavailable */ }
+        catch { }
         return undefined;
     }
     _fromLsof(filePath) {
@@ -170,53 +188,42 @@ class ModelDetector {
                 if (!line.startsWith('c'))
                     continue;
                 const cmd = line.slice(1).toLowerCase();
-                for (const entry of LSOF_CMD_MAP) {
-                    if (cmd.includes(entry.match)) {
-                        return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-                    }
-                }
+                for (const { match, tool } of PROC_MAP)
+                    if (cmd.includes(match) && !HOST_IDE_PROCS.has(tool))
+                        return { model: `${tool}-default`, tool, confidence: 'low' };
             }
         }
-        catch { /* lsof unavailable */ }
+        catch { }
         return undefined;
     }
     _scanIdeSettings(appName) {
-        for (const p of this._getIdeSettingsPaths(appName)) {
+        for (const p of this._idePaths(appName)) {
             try {
-                const raw = fs.readFileSync(p, 'utf8');
-                const json = JSON.parse(raw);
-                const flat = this._flattenObject(json);
-                const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+                const flat = this._flatten(JSON.parse(fs.readFileSync(p, 'utf8')));
                 const candidates = [];
                 for (const [key, value] of Object.entries(flat)) {
-                    if (typeof value !== 'string' || !value)
-                        continue;
-                    if (!key.toLowerCase().includes('model'))
+                    if (typeof value !== 'string' || !key.toLowerCase().includes('model'))
                         continue;
                     if (AUTO_SENTINELS.has(value.toLowerCase())) {
                         candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
                         continue;
                     }
-                    if (MODEL_PATTERN.test(value)) {
+                    if (MODEL_PATTERN.test(value))
                         candidates.push({ key, value: value.toLowerCase() });
-                    }
-                }
-                if (candidates.length > 0) {
-                    const real = candidates.filter(c => !c.value.endsWith('-auto'));
-                    const pick = real.length > 0
-                        ? real.sort((a, b) => b.key.length - a.key.length)[0]
-                        : candidates.sort((a, b) => b.key.length - a.key.length)[0];
-                    return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
                 }
+                if (!candidates.length)
+                    continue;
+                const real = candidates.filter(c => !c.value.endsWith('-auto'));
+                const pick = (real.length ? real : candidates).sort((a, b) => b.key.length - a.key.length)[0];
+                return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
             }
-            catch { /* absent */ }
+            catch { }
         }
         return undefined;
     }
-    _getIdeSettingsPaths(appName) {
-        const toolId = appName.toLowerCase().replace(/\s+/g, '-');
-        const dirCandidates = [...new Set([appName, toolId])];
-        return dirCandidates.map(dir => {
+    _idePaths(appName) {
+        const id = appName.toLowerCase().replace(/\s+/g, '-');
+        return [...new Set([appName, id])].map(dir => {
             switch (process.platform) {
                 case 'darwin': return path.join(os.homedir(), 'Library', 'Application Support', dir, 'User', 'settings.json');
                 case 'win32': return path.join(process.env.APPDATA ?? '', dir, 'User', 'settings.json');
@@ -224,18 +231,16 @@ class ModelDetector {
             }
         });
     }
-    _flattenObject(obj, prefix = '', depth = 0) {
+    _flatten(obj, prefix = '', depth = 0) {
         if (depth > 5)
             return {};
         const out = {};
         for (const [k, v] of Object.entries(obj)) {
             const key = prefix ? `${prefix}.${k}` : k;
-            if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
-                Object.assign(out, this._flattenObject(v, key, depth + 1));
-            }
-            else {
+            if (v !== null && typeof v === 'object' && !Array.isArray(v))
+                Object.assign(out, this._flatten(v, key, depth + 1));
+            else
                 out[key] = v;
-            }
         }
         return out;
     }

package/dist/core/ToolDetector.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * Detects every AI coding tool present on the machine, whether or not OmniType
+ * has a hook for it. Used by the doctor command and for market-analysis telemetry.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_TOOLS = void 0;
+exports.detectAllTools = detectAllTools;
+exports.detectInstalledTools = detectInstalledTools;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const HOME = os.homedir();
+function exists(...parts) {
+    try {
+        fs.accessSync(path.join(...parts));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function inPath(bin) {
+    try {
+        (0, child_process_1.execFileSync)('which', [bin], { timeout: 500, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function macApp(name) {
+    if (process.platform !== 'darwin')
+        return false;
+    return exists('/Applications', name) || exists(HOME, 'Applications', name);
+}
+exports.KNOWN_TOOLS = [
+    // ── Tools with OmniType hooks ────────────────────────────────────────────
+    {
+        id: 'claude-code',
+        name: 'Claude Code',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.claude') || inPath('claude'),
+    },
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.cursor') || macApp('Cursor.app'),
+    },
+    {
+        id: 'windsurf',
+        name: 'Windsurf',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.codeium') || macApp('Windsurf.app'),
+    },
+    {
+        id: 'codex',
+        name: 'Codex CLI',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.codex') || inPath('codex'),
+    },
+    {
+        id: 'cline',
+        name: 'Cline',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, 'Documents', 'Cline', 'Hooks') || exists(HOME, 'Documents', 'Cline'),
+    },
+    {
+        id: 'gemini-cli',
+        name: 'Gemini CLI',
+        hookSupport: 'hooked',
+        detect: () => inPath('gemini') || exists(HOME, '.gemini'),
+    },
+    {
+        id: 'droid',
+        name: 'Droid (Factory)',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.factory'),
+    },
+    {
+        id: 'firebender',
+        name: 'Firebender',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.firebender'),
+    },
+    {
+        id: 'amp',
+        name: 'Amp',
+        hookSupport: 'hooked',
+        detect: () => {
+            const xdg = process.env.XDG_DATA_HOME ?? path.join(HOME, '.local', 'share');
+            return inPath('amp') || exists(xdg, 'amp') ||
+                (process.platform === 'win32' && exists(process.env.LOCALAPPDATA ?? '', 'amp'));
+        },
+    },
+    {
+        id: 'opencode',
+        name: 'OpenCode',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.config', 'opencode') || inPath('opencode'),
+    },
+    {
+        id: 'pi',
+        name: 'Pi',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.pi'),
+    },
+    // ── Tools detected but no hook yet ──────────────────────────────────────
+    {
+        id: 'aider',
+        name: 'Aider',
+        hookSupport: 'no-hook',
+        detect: () => inPath('aider') || exists(HOME, '.aider.conf.yml') || exists(HOME, '.aider'),
+    },
+    {
+        id: 'continue',
+        name: 'Continue',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.continue') || inPath('continue'),
+    },
+    {
+        id: 'antigravity',
+        name: 'Antigravity',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Antigravity.app') || macApp('Google Antigravity.app'),
+    },
+    {
+        id: 'pearai',
+        name: 'PearAI',
+        hookSupport: 'no-hook',
+        detect: () => macApp('PearAI.app') || exists(HOME, '.pearai'),
+    },
+    {
+        id: 'void',
+        name: 'Void',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Void.app') || exists(HOME, '.void'),
+    },
+    {
+        id: 'zed',
+        name: 'Zed',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Zed.app') ||
+            (process.platform === 'linux' && (inPath('zed') || exists(HOME, '.config', 'zed'))),
+    },
+    {
+        id: 'roo-cline',
+        name: 'Roo Code',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.roo') || exists(HOME, '.roo-cline'),
+    },
+    {
+        id: 'tabnine',
+        name: 'Tabnine',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.tabnine') || exists(HOME, '.config', 'tabnine'),
+    },
+    {
+        id: 'supermaven',
+        name: 'Supermaven',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.supermaven'),
+    },
+    {
+        id: 'codeium',
+        name: 'Codeium',
+        hookSupport: 'no-hook',
+        // .codeium overlaps with Windsurf — only count if Windsurf isn't the reason
+        detect: () => exists(HOME, '.codeium', 'codeium') || exists(HOME, '.codeium', 'config'),
+    },
+    {
+        id: 'copilot',
+        name: 'GitHub Copilot',
+        // Copilot supports PreToolUse/PostToolUse hooks at ~/.copilot/hooks/
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.copilot') ||
+            exists(HOME, '.vscode') ||
+            exists(HOME, 'Library', 'Application Support', 'Code') ||
+            exists(HOME, '.config', 'github-copilot'),
+    },
+    {
+        id: 'trae',
+        name: 'Trae',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Trae.app') || exists(HOME, '.trae'),
+    },
+    {
+        id: 'goose',
+        name: 'Goose',
+        hookSupport: 'no-hook',
+        detect: () => inPath('goose') || exists(HOME, '.config', 'goose'),
+    },
+    {
+        id: 'openai-codex-legacy',
+        name: 'OpenAI Codex (legacy)',
+        hookSupport: 'no-hook',
+        detect: () => !!process.env.OPENAI_API_KEY && !exists(HOME, '.codex'),
+    },
+];
+/** Returns all known tools with a detected flag. */
+function detectAllTools() {
+    return exports.KNOWN_TOOLS.map(tool => {
+        let detected = false;
+        try {
+            detected = tool.detect();
+        }
+        catch { }
+        return { tool, detected };
+    });
+}
+/** Returns only the tools that are actually installed. */
+function detectInstalledTools() {
+    return detectAllTools().filter(r => r.detected).map(r => r.tool);
+}