@omnitype-code/cli 0.1.3 → 0.1.4

package/src/__tests__/ToolHookInstallersCoverage.test.ts

@@ -0,0 +1,237 @@
+/**
+ * ToolHookInstallers coverage tests — targets uncovered tool installers:
+ * Windsurf, Codex, Gemini, Droid, Firebender, Cline, Copilot, Amp, OpenCode, Pi
+ */
+
+import * as fs   from 'fs';
+import * as os   from 'os';
+import * as path from 'path';
+
+import {
+  installAllToolHooks,
+  checkHookStatus,
+  HOOK_VERSION,
+} from '../core/ToolHookInstallers';
+
+const HOME = os.homedir();
+
+function makeScratchDir(name: string): string {
+  const d = path.join(HOME, `.omnitype-cov-test-${name}-${Date.now()}`);
+  fs.mkdirSync(d, { recursive: true });
+  return d;
+}
+function rmDir(d: string) { fs.rmSync(d, { recursive: true, force: true }); }
+function readJson(p: string) { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; } }
+
+// ── Universal hook command content ────────────────────────────────────────────
+
+describe('ToolHookInstallers — universal hook command (all tools)', () => {
+  // Install into a scratch ~/.claude and read the command back
+  let cmd: string;
+  let scratchClaude: string;
+  const realClaude = path.join(HOME, '.claude');
+  const backup = path.join(HOME, `.claude-backup-cov-${Date.now()}`);
+  let hadReal = false;
+
+  beforeAll(() => {
+    scratchClaude = makeScratchDir('claude');
+    if (fs.existsSync(realClaude)) { fs.renameSync(realClaude, backup); hadReal = true; }
+    fs.renameSync(scratchClaude, realClaude);
+    installAllToolHooks();
+    const s = readJson(path.join(realClaude, 'settings.json'));
+    cmd = s?.hooks?.PreToolUse?.[0]?.hooks?.[0]?.command ?? '';
+    rmDir(realClaude);
+    if (hadReal) fs.renameSync(backup, realClaude);
+  });
+
+  it('tries j.model (Cursor/Codex field)', () => {
+    expect(cmd).toContain('j.model');
+  });
+  it('tries j.model_name (Windsurf field)', () => {
+    expect(cmd).toContain('j.model_name');
+  });
+  it('tries j.modelName (camelCase variant)', () => {
+    expect(cmd).toContain('j.modelName');
+  });
+  it('tries j.modelID', () => {
+    expect(cmd).toContain('j.modelID');
+  });
+  it('tries j.data.model (nested variant)', () => {
+    expect(cmd).toContain('j?.data?.model');
+  });
+  it('falls back to transcript_path JSONL', () => {
+    expect(cmd).toContain('j.transcript_path');
+    expect(cmd).toContain('extractModelFromJsonl');
+  });
+  it('falls back to env var last', () => {
+    expect(cmd).toContain('CLAUDE_MODEL');
+    expect(cmd).toContain('ANTHROPIC_MODEL');
+  });
+});
+
+// ── Windsurf installer ────────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Windsurf', () => {
+  let scratchCodium: string;
+  const realCodium = path.join(HOME, '.codeium');
+  const backup = path.join(HOME, `.codeium-backup-${Date.now()}`);
+  let hadReal = false;
+
+  beforeEach(() => {
+    scratchCodium = makeScratchDir('codeium');
+    if (fs.existsSync(realCodium)) { fs.renameSync(realCodium, backup); hadReal = true; }
+    fs.renameSync(scratchCodium, realCodium);
+  });
+
+  afterEach(() => {
+    rmDir(realCodium);
+    if (hadReal) { fs.renameSync(backup, realCodium); hadReal = false; }
+  });
+
+  it('installs hook into windsurf/hooks.json', () => {
+    // The installer skips if neither hookPath nor its parent dir exists.
+    // Create the parent dir so it proceeds.
+    const windsurfDir = path.join(realCodium, 'windsurf');
+    fs.mkdirSync(windsurfDir, { recursive: true });
+    installAllToolHooks();
+    const hooks = readJson(path.join(windsurfDir, 'hooks.json'));
+    const cmds: string[] = (hooks?.hooks?.pre_write_code ?? []).map((h: any) => h?.command ?? '');
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for windsurf', () => {
+    installAllToolHooks();
+    const statuses = checkHookStatus();
+    const ws = statuses.find(s => s.tool === 'windsurf');
+    expect(ws?.status).toBe('installed');
+  });
+
+  it('checkHookStatus returns stale when old hook present', () => {
+    const hooksDir = path.join(realCodium, 'windsurf');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(path.join(hooksDir, 'hooks.json'), JSON.stringify({
+      hooks: { pre_write_code: [{ command: 'node -e "/*omnitype-hook-v3*/.omnitype"' }] }
+    }));
+    const statuses = checkHookStatus();
+    const ws = statuses.find(s => s.tool === 'windsurf');
+    expect(ws?.status).toBe('stale');
+  });
+});
+
+// ── Gemini CLI installer ──────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Gemini CLI', () => {
+  let scratchGemini: string;
+  const realGemini = path.join(HOME, '.gemini');
+  const backup = path.join(HOME, `.gemini-backup-${Date.now()}`);
+  let hadReal = false;
+
+  beforeEach(() => {
+    scratchGemini = makeScratchDir('gemini');
+    if (fs.existsSync(realGemini)) { fs.renameSync(realGemini, backup); hadReal = true; }
+    fs.renameSync(scratchGemini, realGemini);
+  });
+
+  afterEach(() => {
+    rmDir(realGemini);
+    if (hadReal) { fs.renameSync(backup, realGemini); hadReal = false; }
+  });
+
+  it('installs hook into gemini settings.json BeforeTool', () => {
+    installAllToolHooks();
+    const s = readJson(path.join(realGemini, 'settings.json'));
+    const cmds: string[] = (s?.BeforeTool ?? []).flatMap((e: any) => e?.hooks?.map((h: any) => h?.command ?? '') ?? []);
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for gemini-cli', () => {
+    installAllToolHooks();
+    const statuses = checkHookStatus();
+    const g = statuses.find(s => s.tool === 'gemini-cli');
+    expect(g?.status).toBe('installed');
+  });
+});
+
+// ── Codex installer ───────────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Codex', () => {
+  let scratchCodex: string;
+  const realCodex = path.join(HOME, '.codex');
+  const backup = path.join(HOME, `.codex-backup-${Date.now()}`);
+  let hadReal = false;
+
+  beforeEach(() => {
+    scratchCodex = makeScratchDir('codex');
+    if (fs.existsSync(realCodex)) { fs.renameSync(realCodex, backup); hadReal = true; }
+    fs.renameSync(scratchCodex, realCodex);
+  });
+
+  afterEach(() => {
+    rmDir(realCodex);
+    if (hadReal) { fs.renameSync(backup, realCodex); hadReal = false; }
+  });
+
+  it('installs hook into codex hooks.json PreToolUse', () => {
+    installAllToolHooks();
+    const s = readJson(path.join(realCodex, 'hooks.json'));
+    const cmds: string[] = (s?.PreToolUse ?? []).map((h: any) => h?.command ?? '');
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for codex', () => {
+    installAllToolHooks();
+    const statuses = checkHookStatus();
+    const c = statuses.find(s => s.tool === 'codex');
+    expect(c?.status).toBe('installed');
+  });
+});
+
+// ── Cline installer ───────────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Cline hook script content', () => {
+  it('Cline script contains version token', () => {
+    // The CLINE_HOOK_SCRIPT is embedded — verify via installing if dir exists
+    // otherwise just verify the constant is referenced in the module
+    const clineDir = path.join(HOME, 'Documents', 'Cline', 'Hooks');
+    if (!fs.existsSync(clineDir)) {
+      // Can't install, but we can verify the exported status
+      const statuses = checkHookStatus();
+      const c = statuses.find(s => s.tool === 'cline');
+      expect(c?.status).toBe('tool-absent');
+      return;
+    }
+    installAllToolHooks();
+    const script = fs.readFileSync(path.join(clineDir, 'PreToolUse'), 'utf8');
+    expect(script).toContain(HOOK_VERSION);
+    expect(script).toContain('extractModelFromJsonl');
+    expect(script).toContain('session.model_change');
+  });
+});
+
+// ── installAllToolHooks — silent on missing dirs ──────────────────────────────
+
+describe('ToolHookInstallers — installAllToolHooks resilience', () => {
+  it('does not throw even when all tool dirs are absent', () => {
+    // All real tool dirs may or may not exist — the function is always silent
+    expect(() => installAllToolHooks()).not.toThrow();
+  });
+
+  it('checkHookStatus returns array with entries for every tracked tool', () => {
+    const statuses = checkHookStatus();
+    const tools = statuses.map(s => s.tool);
+    expect(tools).toContain('claude-code');
+    expect(tools).toContain('cursor');
+    expect(tools).toContain('windsurf');
+    expect(tools).toContain('codex');
+    expect(tools).toContain('cline');
+    expect(tools).toContain('gemini-cli');
+  });
+
+  it('every status entry has valid status value', () => {
+    const valid = new Set(['installed', 'stale', 'not-installed', 'tool-absent']);
+    const statuses = checkHookStatus();
+    for (const s of statuses) {
+      expect(valid.has(s.status)).toBe(true);
+    }
+  });
+});

package/src/__tests__/TranscriptScanner.test.ts

@@ -0,0 +1,201 @@
+/**
+ * TranscriptScanner Tests
+ *
+ * Tests the JSONL model-extraction logic and directory-scanning behaviour.
+ * All file I/O uses tmp directories — real ~/.claude is never touched.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// We import and test the public API plus the cache invalidation helper.
+import { scanTranscripts, invalidateTranscriptCache } from '../core/TranscriptScanner';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'omnitype-ts-'));
+}
+
+function rmTmp(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+/** Write a JSONL file with the given lines and return its path. */
+function writeJsonl(dir: string, name: string, lines: object[]): string {
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, name);
+  fs.writeFileSync(filePath, lines.map(l => JSON.stringify(l)).join('\n') + '\n', 'utf8');
+  return filePath;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('TranscriptScanner — extractJsonl (via scanTranscripts)', () => {
+  let tmp: string;
+  let origEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    tmp = makeTmp();
+    origEnv = { ...process.env };
+    invalidateTranscriptCache();
+    // Override CLAUDE_CONFIG_DIR so the scanner looks in our tmp dir
+    process.env.CLAUDE_CONFIG_DIR = tmp;
+  });
+
+  afterEach(() => {
+    process.env = origEnv;
+    invalidateTranscriptCache();
+    rmTmp(tmp);
+  });
+
+  it('reads model from message.model field in JSONL tail', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-project');
+    writeJsonl(projectDir, 'session1.jsonl', [
+      { type: 'system', content: 'hello' },
+      { type: 'assistant', message: { model: 'claude-sonnet-4-5', role: 'assistant' }, content: '' },
+    ]);
+
+    const result = scanTranscripts();
+    expect(result).toBeDefined();
+    expect(result!.model).toBe('claude-sonnet-4-5');
+  });
+
+  it('reads model from session.model_change event', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-model-change');
+    writeJsonl(projectDir, 'session2.jsonl', [
+      { type: 'system', content: 'start' },
+      { type: 'session.model_change', data: { newModel: 'claude-opus-4' } },
+    ]);
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    expect(result).toBeDefined();
+    expect(result!.model).toBe('claude-opus-4');
+  });
+
+  it('skips <synthetic> model values', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-synthetic');
+    writeJsonl(projectDir, 'session_synth.jsonl', [
+      { type: 'assistant', message: { model: '<synthetic>', role: 'assistant' }, content: '' },
+    ]);
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    // <synthetic> should be skipped — no valid model found
+    if (result) {
+      expect(result.model).not.toBe('<synthetic>');
+    }
+    // Result is either undefined or from another tool dir — not the synthetic value
+  });
+
+  it('returns undefined for empty JSONL file', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-empty');
+    const filePath = path.join(projectDir, 'empty.jsonl');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(filePath, '', 'utf8');
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined when no session files exist', () => {
+    // tmp has CLAUDE_CONFIG_DIR but no projects dir at all
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    expect(result).toBeUndefined();
+  });
+
+  it('caches results and does not re-scan within TTL', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-cache');
+    writeJsonl(projectDir, 'sess.jsonl', [
+      { type: 'assistant', message: { model: 'claude-haiku-3', role: 'assistant' }, content: '' },
+    ]);
+
+    invalidateTranscriptCache();
+    const first = scanTranscripts();
+    expect(first?.model).toBe('claude-haiku-3');
+
+    // Now add a new file with a different model — but cache should return stale result
+    const projectDir2 = path.join(tmp, 'projects', '-tmp-cache2');
+    writeJsonl(projectDir2, 'sess2.jsonl', [
+      { type: 'assistant', message: { model: 'claude-opus-4', role: 'assistant' }, content: '' },
+    ]);
+
+    const second = scanTranscripts(); // still within TTL
+    // Cache should return same result (the mtime of the new file might actually be newer
+    // in practice due to clock resolution — we verify the cache object is the same reference)
+    expect(second).toBe(first);
+  });
+
+  it('picks the most recently modified file when multiple sessions exist', async () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-multi');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    // Write older file first
+    const older = path.join(projectDir, 'old.jsonl');
+    fs.writeFileSync(older, JSON.stringify({ type: 'assistant', message: { model: 'claude-haiku-3' } }) + '\n');
+    // Set mtime to 1 second ago
+    const oldTime = new Date(Date.now() - 1000);
+    fs.utimesSync(older, oldTime, oldTime);
+
+    // Write newer file
+    const newer = path.join(projectDir, 'new.jsonl');
+    fs.writeFileSync(newer, JSON.stringify({ type: 'assistant', message: { model: 'claude-sonnet-4-5' } }) + '\n');
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    expect(result?.model).toBe('claude-sonnet-4-5');
+  });
+
+  it('falls back to head scan when file is large and model_change is near start', () => {
+    const projectDir = path.join(tmp, 'projects', '-tmp-large');
+    fs.mkdirSync(projectDir, { recursive: true });
+    const filePath = path.join(projectDir, 'large.jsonl');
+
+    // First line: model_change event
+    const firstLine = JSON.stringify({ type: 'session.model_change', data: { newModel: 'claude-opus-4' } }) + '\n';
+    // Pad with >50KB of data so the tail read won't include the first line
+    const padding = JSON.stringify({ type: 'padding', data: 'x'.repeat(512) }) + '\n';
+    let content = firstLine;
+    // Add enough padding lines to exceed 51200 bytes
+    while (content.length < 55000) {
+      content += padding;
+    }
+    fs.writeFileSync(filePath, content, 'utf8');
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    // The head fallback should find the model_change in the first line
+    expect(result).toBeDefined();
+    expect(result!.model).toBe('claude-opus-4');
+  });
+
+  it('scopes claude-code scanning to the given cwd', () => {
+    // Write sessions for two different projects
+    const cwdA = '/fake/project-a';
+    const cwdB = '/fake/project-b';
+    const keyA = cwdA.replace(/\//g, '-');
+    const keyB = cwdB.replace(/\//g, '-');
+
+    const dirA = path.join(tmp, 'projects', keyA);
+    const dirB = path.join(tmp, 'projects', keyB);
+
+    writeJsonl(dirA, 'sess.jsonl', [
+      { type: 'assistant', message: { model: 'claude-haiku-3' } },
+    ]);
+    writeJsonl(dirB, 'sess.jsonl', [
+      { type: 'assistant', message: { model: 'claude-opus-4' } },
+    ]);
+
+    invalidateTranscriptCache();
+    const resultA = scanTranscripts(cwdA);
+    invalidateTranscriptCache();
+    const resultB = scanTranscripts(cwdB);
+
+    expect(resultA?.model).toBe('claude-haiku-3');
+    expect(resultB?.model).toBe('claude-opus-4');
+  });
+});

package/src/core/ToolHookInstallers.ts

@@ -19,11 +19,9 @@ export const GLOBAL_OMNITYPE_DIR = path.join(os.homedir(), '.omnitype');
 
 // Version token embedded in every hook command.
 // Bump whenever hook logic changes so stale installs are replaced automatically.
-export const HOOK_VERSION = 'omnitype-hook-v4';
+export const HOOK_VERSION = 'omnitype-hook-v5';
 
 // Shared sentinel-write snippet: resolves dir from process.cwd(), falls back to ~/.omnitype/.
-// `modelExpr` is a JS expression that evaluates to the model string (already extracted).
-// `tool` is the literal tool name string.
 const WRITE_SENTINEL = (tool: string) =>
   `const fs=require('fs'),p=require('path'),os=require('os');` +
   `const dir=p.join(process.cwd(),'.omnitype');` +
@@ -34,33 +32,54 @@ const WRITE_SENTINEL = (tool: string) =>
   `fs.writeFileSync(p.join(dir,'active-model.json'),payload);` +
   `fs.writeFileSync(p.join(fbDir,'active-model.json'),payload);`;
 
-// Generic hook: reads model from stdin JSON, writes sentinel to project root + global fallback.
-function buildHookCommand(tool: string, modelField: string): string {
+// Extracts model from a JSONL transcript by reading the tail (last 50KB).
+// Looks for message.model on assistant turns, or session.model_change events.
+// Same approach as git-ai's extract_model_from_jsonl_tail.
+const EXTRACT_MODEL_FROM_JSONL =
+  `function extractModelFromJsonl(tp){` +
+  `try{` +
+  `const _fs=require('fs');` +
+  `const stat=_fs.statSync(tp);` +
+  `const readSize=Math.min(51200,stat.size);` +
+  `const buf=Buffer.alloc(readSize);` +
+  `const fd=_fs.openSync(tp,'r');` +
+  `_fs.readSync(fd,buf,0,readSize,stat.size-readSize);` +
+  `_fs.closeSync(fd);` +
+  `const lines=buf.toString('utf8').split('\\n').reverse();` +
+  `for(const line of lines){` +
+  `if(!line.trim())continue;` +
+  `try{const o=JSON.parse(line);` +
+  `if(o.type==='session.model_change'&&o.data&&o.data.newModel)return o.data.newModel;` +
+  `const m=o?.message?.model||o?.model;` +
+  `if(m&&m!=='<synthetic>')return m;` +
+  `}catch{}` +
+  `}` +
+  `}catch{}` +
+  `return null;` +
+  `}`;
+
+// Universal hook: works for every tool without per-tool customization.
+// Resolution order:
+//   1. Direct payload fields (covers Cursor, Windsurf, Codex, Cline, Gemini, etc.)
+//   2. transcript_path JSONL tail (covers Claude Code, Gemini — same as git-ai)
+//   3. Env vars as last resort
+function buildHookCommand(tool: string): string {
   return (
-    `node -e "/*${HOOK_VERSION}*/let b='';process.stdin.on('data',c=>b+=c);` +
-    `process.stdin.on('end',()=>{` +
+    `node -e "/*${HOOK_VERSION}*/` +
+    EXTRACT_MODEL_FROM_JSONL +
+    `let b='';process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{` +
     `try{const j=JSON.parse(b);` +
-    `let m=j['${modelField}']||j.model;` +
-    `if(!m)return;` +
     `let file;try{file=j?.tool_input?.path||j?.tool_input?.file_path||j?.toolInput?.path;}catch{}` +
+    `let m=j.model||j.model_name||j.modelName||j.modelID||j?.data?.model||null;` +
+    `if(!m&&j.transcript_path)m=extractModelFromJsonl(j.transcript_path);` +
+    `if(!m)m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL||null;` +
+    `if(!m)return;` +
     WRITE_SENTINEL(tool) +
     `}catch{}})"`
   );
 }
 
-// Claude Code hook: reads model from stdin first, then env, then settings.json.
-const CLAUDE_HOOK_CMD =
-  `node -e "/*${HOOK_VERSION}*/let b='';process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{` +
-  `try{` +
-  `let m,file;` +
-  `try{const j=JSON.parse(b);m=j.model;file=j?.tool_input?.path||j?.tool_input?.file_path||j?.toolInput?.path;}catch{}` +
-  `if(!m)m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL;` +
-  `if(!m){try{const _fs=require('fs'),_p=require('path'),_os=require('os');` +
-  `const s=JSON.parse(_fs.readFileSync(_p.join(_os.homedir(),'.claude','settings.json'),'utf8'));` +
-  `m=s.model||s.defaultModel;}catch{}}` +
-  `if(!m)return;` +
-  WRITE_SENTINEL('claude-code') +
-  `}catch{}})"`;
+const CLAUDE_HOOK_CMD = buildHookCommand('claude-code');
 function readJson(filePath: string): Record<string, any> {
   try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return {}; }
 }
@@ -110,7 +129,7 @@ function installClaudeHooks(): void {
 // ── Cursor ────────────────────────────────────────────────────────────────────
 
 const CURSOR_HOOKS_PATH = path.join(os.homedir(), '.cursor', 'hooks.json');
-const CURSOR_CMD = buildHookCommand('cursor', 'model');
+const CURSOR_CMD = buildHookCommand('cursor');
 
 function installCursorHooks(): void {
   if (!fs.existsSync(path.join(os.homedir(), '.cursor'))) return;
@@ -135,7 +154,7 @@ const WINDSURF_HOOK_PATHS = [
   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');
+const WINDSURF_CMD = buildHookCommand('windsurf');
 
 function installWindsurfHooks(): void {
   if (!fs.existsSync(path.join(os.homedir(), '.codeium'))) return;
@@ -158,7 +177,7 @@ function installWindsurfHooks(): void {
 // ── Codex ─────────────────────────────────────────────────────────────────────
 
 const CODEX_HOOKS_PATH = path.join(os.homedir(), '.codex', 'hooks.json');
-const CODEX_CMD = buildHookCommand('codex', 'model');
+const CODEX_CMD = buildHookCommand('codex');
 
 function installCodexHooks(): void {
   if (!fs.existsSync(path.join(os.homedir(), '.codex'))) return;
@@ -183,13 +202,37 @@ const CLINE_HOOKS_DIR = path.join(os.homedir(), 'Documents', 'Cline', 'Hooks');
 const CLINE_HOOK_SCRIPT = `#!/usr/bin/env node
 // ${HOOK_VERSION}
 const FILE_WRITE_TOOLS = new Set(['write_to_file','apply_diff','insert_content','search_and_replace']);
+function extractModelFromJsonl(tp) {
+  try {
+    const fs = require('fs');
+    const stat = fs.statSync(tp);
+    const readSize = Math.min(51200, stat.size);
+    const buf = Buffer.alloc(readSize);
+    const fd = fs.openSync(tp, 'r');
+    fs.readSync(fd, buf, 0, readSize, stat.size - readSize);
+    fs.closeSync(fd);
+    const lines = buf.toString('utf8').split('\\n').reverse();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const o = JSON.parse(line);
+        if (o.type === 'session.model_change' && o.data?.newModel) return o.data.newModel;
+        const m = o?.message?.model || o?.model;
+        if (m && m !== '<synthetic>') return m;
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
 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 m = j.model || j.preToolUse?.model || '';
+    const m = j.model || j.model_name || j.modelName || j.modelID || j?.data?.model
+      || (j.transcript_path ? extractModelFromJsonl(j.transcript_path) : null)
+      || j.preToolUse?.model || '';
     const file = j.toolInput?.path || j.toolInput?.file_path || j.tool_input?.path || undefined;
     const fs = require('fs'), p = require('path'), os = require('os');
     const dir = p.join(process.cwd(), '.omnitype');
@@ -218,7 +261,7 @@ function installClineHooks(): void {
 // ~/.gemini/settings.json — BeforeTool / AfterTool with nested hooks array
 
 const GEMINI_SETTINGS_PATH = path.join(os.homedir(), '.gemini', 'settings.json');
-const GEMINI_CMD = buildHookCommand('gemini-cli', 'model');
+const GEMINI_CMD = buildHookCommand('gemini-cli');
 const GEMINI_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: GEMINI_CMD }] };
 
 function installGeminiHooks(): void {
@@ -239,7 +282,7 @@ function installGeminiHooks(): void {
 // ~/.factory/settings.json — PreToolUse with nested hooks array
 
 const DROID_SETTINGS_PATH = path.join(os.homedir(), '.factory', 'settings.json');
-const DROID_CMD = buildHookCommand('droid', 'model');
+const DROID_CMD = buildHookCommand('droid');
 const DROID_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: DROID_CMD }] };
 
 function installDroidHooks(): void {
@@ -256,7 +299,7 @@ function installDroidHooks(): void {
 // ~/.firebender/hooks.json — preToolUse / postToolUse flat command arrays
 
 const FIREBENDER_HOOKS_PATH = path.join(os.homedir(), '.firebender', 'hooks.json');
-const FIREBENDER_CMD = buildHookCommand('firebender', 'model');
+const FIREBENDER_CMD = buildHookCommand('firebender');
 
 function installFirebenderHooks(): void {
   if (!fs.existsSync(path.join(os.homedir(), '.firebender'))) return;
@@ -393,7 +436,7 @@ function installPiPlugin(): void {
 // PreToolUse / PostToolUse arrays — same shape as Claude Code.
 
 const COPILOT_HOOKS_PATH = path.join(os.homedir(), '.copilot', 'hooks', 'omnitype.json');
-const COPILOT_CMD = buildHookCommand('copilot', 'model');
+const COPILOT_CMD = buildHookCommand('copilot');
 
 function installCopilotHooks(): void {
   // Require either ~/.copilot or ~/.vscode or VS Code settings to exist