@omnitype-code/cli 0.1.0 → 0.1.2

package/src/core/ModelDetector.ts

@@ -1,19 +1,8 @@
-/**
- * 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)
- */
-
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { scanTranscripts } from './TranscriptScanner';
 
 export interface ModelDetectionResult {
   model: string;
@@ -22,115 +11,107 @@ export interface ModelDetectionResult {
 }
 
 const UNKNOWN: ModelDetectionResult = { 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 = 10_000;
+const SENTINEL_MAX_AGE_MS = 30_000; // 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');
 
-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;
+// 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;
 
-// Maps known CLI/IDE env vars to their tool
+// 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: Array<{ vars: string[]; tool: string }> = [
-  { 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: ['OLLAMA_MODEL'],                                         tool: 'ollama' },
-  { vars: ['COPILOT_MODEL'],                                        tool: 'copilot' },
-  { vars: ['LLM_MODEL'],                                            tool: 'openhands' },
-  { vars: ['TABBY_MODEL'],                                          tool: 'tabby' },
+  { 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'
-];
+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']);
 
-// lsof command-name → tool mapping
-const LSOF_CMD_MAP: Array<{ match: string; tool: string }> = [
-  { 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' },
+const PROC_MAP: Array<{ match: string; tool: string }> = [
+  { match: 'claude',   tool: 'claude-code' },
+  { match: 'aider',    tool: 'aider' },
+  { match: 'goose',    tool: 'goose' },
+  { match: 'codex',    tool: 'codex' },
+  { match: 'tabby',    tool: 'tabby' },
 ];
 
 export class ModelDetector {
   detect(changedFilePath?: string): ModelDetectionResult {
     return (
-      this._fromUniversalSentinel() ??
-      this._fromHooksSentinel() ??
-      this._fromIdeConfigs() ??
+      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
     );
   }
 
-  private _fromUniversalSentinel(): ModelDetectionResult | undefined {
-    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 { return undefined; }
+  private _fromTranscripts(): ModelDetectionResult | undefined {
+    const r = scanTranscripts();
+    if (!r) return undefined;
+    return { model: r.model, tool: r.tool, confidence: 'high' };
   }
 
-  private _fromHooksSentinel(): ModelDetectionResult | undefined {
+  private _sentinel(filePath: string, changedPath?: string): ModelDetectionResult | undefined {
     try {
-      const stat = fs.statSync(HOOKS_SENTINEL_PATH);
-      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
-      const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
-      if (!data?.model || data.model === 'unknown') return undefined;
-      return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+      const mtime = fs.statSync(filePath).mtimeMs;
+      const d = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (!d?.model || d.model === 'unknown') return undefined;
+
+      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 > 120_000) 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: d.model, tool: d.tool ?? 'unknown-tool', confidence: 'deterministic' };
     } catch { return undefined; }
   }
 
-  private _fromIdeConfigs(): ModelDetectionResult | undefined {
-    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' 
-        };
-      }
-    }
+  private _fromEnv(): ModelDetectionResult | undefined {
+    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;
   }
 
-  private _fromEnv(): ModelDetectionResult | undefined {
-    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' };
-        }
-      }
+  private _fromIdeConfigs(): ModelDetectionResult | undefined {
+    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;
   }
 
-  private _fromPsPatterns(): ModelDetectionResult | undefined {
+  private _fromPs(): ModelDetectionResult | undefined {
     if (process.platform === 'win32') return undefined;
     try {
       const lines = 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' };
-          }
-        }
-      }
-    } catch { /* ps unavailable */ }
+      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 {}
     return undefined;
   }
 
@@ -141,57 +122,36 @@ export class ModelDetector {
       for (const line of out.split('\n')) {
         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;
   }
 
   private _scanIdeSettings(appName: string): { model: string; isAuto: boolean } | undefined {
-    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: Array<{ key: string; value: string }> = [];
-
         for (const [key, value] of Object.entries(flat)) {
-          if (typeof value !== 'string' || !value) continue;
-          if (!key.toLowerCase().includes('model')) continue;
-
-          if (AUTO_SENTINELS.has(value.toLowerCase())) {
-            candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
-            continue;
-          }
-
-          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 (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)) candidates.push({ key, value: value.toLowerCase() });
         }
-      } catch { /* absent */ }
+        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 {}
     }
     return undefined;
   }
 
-  private _getIdeSettingsPaths(appName: string): string[] {
-    const toolId = appName.toLowerCase().replace(/\s+/g, '-');
-    const dirCandidates = [...new Set([appName, toolId])];
-
-    return dirCandidates.map(dir => {
+  private _idePaths(appName: string): string[] {
+    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');
@@ -200,16 +160,14 @@ export class ModelDetector {
     });
   }
 
-  private _flattenObject(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
+  private _flatten(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
     if (depth > 5) return {};
     const out: Record<string, unknown> = {};
     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 as Record<string, unknown>, key, depth + 1));
-      } else {
-        out[key] = v;
-      }
+      if (v !== null && typeof v === 'object' && !Array.isArray(v))
+        Object.assign(out, this._flatten(v as Record<string, unknown>, key, depth + 1));
+      else out[key] = v;
     }
     return out;
   }

package/src/core/ToolHookInstallers.ts

@@ -0,0 +1,192 @@
+/**
+ * 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.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from '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: string, modelField: string): string {
+  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: string): Record<string, any> {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return {}; }
+}
+
+function writeJsonAtomic(filePath: string, data: unknown): void {
+  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(): void {
+  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 as any[]).some(
+    (h: any) => 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(): void {
+  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] as any[]).some(
+      (h: any) => 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(): void {
+  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] as any[]).some(
+        (h: any) => 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(): void {
+  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] as any[]).some(
+      (h: any) => 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(): void {
+  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 ────────────────────────────────────────────────────────────────
+
+export function installAllToolHooks(): void {
+  try { installClaudeHooks(); } catch {}
+  try { installCursorHooks(); } catch {}
+  try { installWindsurfHooks(); } catch {}
+  try { installCodexHooks(); } catch {}
+  try { installClineHooks(); } catch {}
+}