@omnitype-code/cli 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to the **@omnitype-code/cli** package are documented here.
+
+---
+
+## [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/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,111 @@ 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; // 30 s — covers slow multi-file AI diffs
+const UNIVERSAL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+const HOOKS_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.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() ??
+        return (this._sentinel(UNIVERSAL_PATH, changedFilePath) ??
+            this._sentinel(HOOKS_PATH, changedFilePath) ??
             this._fromEnv() ??
-            this._fromPsPatterns() ??
+            this._fromTranscripts() ??
+            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() {
+        const r = (0, TranscriptScanner_1.scanTranscripts)();
+        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;
         }
     }
-    _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'
-                };
-            }
-        }
-        return undefined;
-    }
     _fromEnv() {
-        for (const { vars, tool } of ENV_VARS) {
+        for (const { vars, tool } of ENV_VARS)
             for (const v of vars) {
                 const val = process.env[v];
-                if (val && MODEL_PATTERN.test(val)) {
+                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' };
         }
         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 +154,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 +197,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/ToolHookInstallers.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Auto-installs OmniType model-detection hooks into AI tools that support
+ * a preToolUse/postToolUse hook system: Claude Code, Cursor, Windsurf, Codex, Cline.
+ *
+ * Hooks write {model, tool, ts, file} to ~/.omnitype/active-model.json.
+ * Including the target file path lets the detector use path-matching instead
+ * of a short TTL — eliminating the race between human and AI edits.
+ *
+ * Each installer is idempotent — safe to call on every startup.
+ * Fails silently so it never breaks the CLI for the user.
+ */
+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.installAllToolHooks = installAllToolHooks;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const OMNITYPE_DIR = path.join(os.homedir(), '.omnitype');
+// Reads stdin JSON, extracts model + file path, writes sentinel.
+// `modelField` is the tool-specific key for model in the hook payload.
+function buildHookCommand(tool, modelField) {
+    return (`node -e "let b='';process.stdin.on('data',c=>b+=c);` +
+        `process.stdin.on('end',()=>{` +
+        `try{const j=JSON.parse(b),` +
+        `m=j['${modelField}']||j.model,` +
+        `fs=require('fs'),p=require('path'),os=require('os'),` +
+        `dir=p.join(os.homedir(),'.omnitype');` +
+        `if(!m)return;` +
+        `let file;try{file=j?.tool_input?.path||j?.tool_input?.file_path;}catch{}` +
+        `fs.mkdirSync(dir,{recursive:true});` +
+        `fs.writeFileSync(p.join(dir,'active-model.json'),` +
+        `JSON.stringify(Object.assign({model:m,tool:'${tool}',ts:Date.now()},file&&{file})))}catch{}})"`);
+}
+// Claude doesn't expose model in hook stdin — reads from env/settings instead.
+// Still reads stdin to extract the target file path for path-gated matching.
+const CLAUDE_HOOK_CMD = `node -e "let b='';process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{` +
+    `const fs=require('fs'),os=require('os'),p=require('path');` +
+    `const dir=p.join(os.homedir(),'.omnitype');` +
+    `let m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL;` +
+    `if(!m){try{const s=JSON.parse(fs.readFileSync(p.join(os.homedir(),'.claude','settings.json'),'utf8'));` +
+    `m=s.model||s.defaultModel;}catch{}}` +
+    `if(!m)return;` +
+    `let file;try{const j=JSON.parse(b);file=j?.tool_input?.path||j?.tool_input?.file_path;}catch{}` +
+    `fs.mkdirSync(dir,{recursive:true});` +
+    `fs.writeFileSync(p.join(dir,'active-model.json'),` +
+    `JSON.stringify(Object.assign({model:m,tool:'claude-code',ts:Date.now()},file&&{file})))})"`;
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJsonAtomic(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+    fs.renameSync(tmp, filePath);
+}
+// ── Claude Code ───────────────────────────────────────────────────────────────
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_HOOK_ENTRY = {
+    matcher: 'Write|Edit|MultiEdit|NotebookEdit',
+    hooks: [{ type: 'command', command: CLAUDE_HOOK_CMD }],
+};
+function installClaudeHooks() {
+    if (!fs.existsSync(CLAUDE_DIR))
+        return;
+    const s = readJson(CLAUDE_SETTINGS);
+    if (!s.hooks)
+        s.hooks = {};
+    if (!Array.isArray(s.hooks.PreToolUse))
+        s.hooks.PreToolUse = [];
+    const already = s.hooks.PreToolUse.some((h) => typeof h?.hooks?.[0]?.command === 'string' && h.hooks[0].command.includes('.omnitype'));
+    if (!already) {
+        s.hooks.PreToolUse.push(CLAUDE_HOOK_ENTRY);
+        writeJsonAtomic(CLAUDE_SETTINGS, s);
+    }
+}
+// ── Cursor ────────────────────────────────────────────────────────────────────
+const CURSOR_HOOKS_PATH = path.join(os.homedir(), '.cursor', 'hooks.json');
+const CURSOR_CMD = buildHookCommand('cursor', 'model');
+function installCursorHooks() {
+    if (!fs.existsSync(path.join(os.homedir(), '.cursor')))
+        return;
+    const settings = readJson(CURSOR_HOOKS_PATH);
+    if (!settings.hooks)
+        settings.hooks = {};
+    let changed = false;
+    for (const event of ['preToolUse', 'postToolUse']) {
+        if (!Array.isArray(settings.hooks[event]))
+            settings.hooks[event] = [];
+        const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+        if (!already) {
+            settings.hooks[event].push({ command: CURSOR_CMD });
+            changed = true;
+        }
+    }
+    if (!settings.version)
+        settings.version = 1;
+    if (changed)
+        writeJsonAtomic(CURSOR_HOOKS_PATH, settings);
+}
+// ── Windsurf ──────────────────────────────────────────────────────────────────
+const WINDSURF_HOOK_PATHS = [
+    path.join(os.homedir(), '.codeium', 'windsurf', 'hooks.json'),
+    path.join(os.homedir(), '.codeium', 'hooks.json'),
+];
+const WINDSURF_EVENTS = ['pre_write_code', 'post_write_code', 'pre_run_command', 'post_run_command'];
+const WINDSURF_CMD = buildHookCommand('windsurf', 'model_name');
+function installWindsurfHooks() {
+    if (!fs.existsSync(path.join(os.homedir(), '.codeium')))
+        return;
+    for (const hookPath of WINDSURF_HOOK_PATHS) {
+        if (!fs.existsSync(hookPath) && !fs.existsSync(path.dirname(hookPath)))
+            continue;
+        const settings = readJson(hookPath);
+        if (!settings.hooks)
+            settings.hooks = {};
+        let changed = false;
+        for (const event of WINDSURF_EVENTS) {
+            if (!Array.isArray(settings.hooks[event]))
+                settings.hooks[event] = [];
+            const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+            if (!already) {
+                settings.hooks[event].push({ command: WINDSURF_CMD });
+                changed = true;
+            }
+        }
+        if (changed)
+            writeJsonAtomic(hookPath, settings);
+    }
+}
+// ── Codex ─────────────────────────────────────────────────────────────────────
+const CODEX_HOOKS_PATH = path.join(os.homedir(), '.codex', 'hooks.json');
+const CODEX_CMD = buildHookCommand('codex', 'model');
+function installCodexHooks() {
+    if (!fs.existsSync(path.join(os.homedir(), '.codex')))
+        return;
+    const settings = readJson(CODEX_HOOKS_PATH);
+    let changed = false;
+    for (const event of ['PreToolUse', 'PostToolUse']) {
+        if (!Array.isArray(settings[event]))
+            settings[event] = [];
+        const already = settings[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+        if (!already) {
+            settings[event].push({ type: 'command', command: CODEX_CMD });
+            changed = true;
+        }
+    }
+    if (changed)
+        writeJsonAtomic(CODEX_HOOKS_PATH, settings);
+}
+// ── Cline ─────────────────────────────────────────────────────────────────────
+// Cline looks for executable scripts in ~/Documents/Cline/Hooks/ named after
+// hook events. We drop a PreToolUse script that reads stdin JSON and writes
+// the sentinel only for file-modifying tools.
+const CLINE_HOOKS_DIR = path.join(os.homedir(), 'Documents', 'Cline', 'Hooks');
+const CLINE_HOOK_SCRIPT = `#!/usr/bin/env node
+const FILE_WRITE_TOOLS = new Set(['write_to_file','apply_diff','insert_content','search_and_replace']);
+let buf = '';
+process.stdin.on('data', c => buf += c);
+process.stdin.on('end', () => {
+  try {
+    const j = JSON.parse(buf);
+    if (!FILE_WRITE_TOOLS.has(j.toolName)) return;
+    const model = j.model || j.preToolUse?.model || '';
+    const fs = require('fs'), p = require('path'), os = require('os');
+    const dir = p.join(os.homedir(), '.omnitype');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p.join(dir, 'active-model.json'), JSON.stringify({ model, tool: 'cline', ts: Date.now() }));
+  } catch {}
+});
+`;
+function installClineHooks() {
+    if (!fs.existsSync(CLINE_HOOKS_DIR))
+        return;
+    const scriptPath = path.join(CLINE_HOOKS_DIR, 'PreToolUse');
+    const already = fs.existsSync(scriptPath) &&
+        fs.readFileSync(scriptPath, 'utf8').includes('.omnitype');
+    if (!already) {
+        fs.writeFileSync(scriptPath, CLINE_HOOK_SCRIPT, 'utf8');
+        fs.chmodSync(scriptPath, 0o755);
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+function installAllToolHooks() {
+    try {
+        installClaudeHooks();
+    }
+    catch { }
+    try {
+        installCursorHooks();
+    }
+    catch { }
+    try {
+        installWindsurfHooks();
+    }
+    catch { }
+    try {
+        installCodexHooks();
+    }
+    catch { }
+    try {
+        installClineHooks();
+    }
+    catch { }
+}