@omnitype-code/cli 0.1.2 → 0.1.3

package/dist/core/TranscriptScanner.js

@@ -131,12 +131,119 @@ function extractAmp(filePath) {
     catch { }
     return undefined;
 }
+/**
+ * Claude Code encodes a project path as the absolute path with '/' replaced by '-'.
+ * e.g. /Users/foo/myproject → -Users-foo-myproject
+ */
+function claudeProjectDir(cwd, base) {
+    return path.join(base, 'projects', cwd.replace(/\//g, '-'));
+}
+/**
+ * Returns the VS Code workspaceStorage root, then filters subdirs to those
+ * whose workspace.json `folder` URI matches the given cwd.
+ * Falls back to returning all copilot transcript dirs if cwd is unknown.
+ */
+function copilotDirs(cwd) {
+    const roots = [];
+    switch (process.platform) {
+        case 'darwin':
+            roots.push(path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage'));
+            break;
+        case 'win32':
+            if (process.env.APPDATA)
+                roots.push(path.join(process.env.APPDATA, 'Code', 'User', 'workspaceStorage'));
+            break;
+        default:
+            roots.push(path.join(HOME, '.config', 'Code', 'User', 'workspaceStorage'));
+            break;
+    }
+    // Also check Insiders
+    if (process.platform === 'darwin')
+        roots.push(path.join(HOME, 'Library', 'Application Support', 'Code - Insiders', 'User', 'workspaceStorage'));
+    const result = [];
+    for (const root of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (!e.isDirectory())
+                continue;
+            const transcriptsDir = path.join(root, e.name, 'GitHub.copilot-chat', 'transcripts');
+            if (!fs.existsSync(transcriptsDir))
+                continue;
+            if (cwd) {
+                // Read workspace.json to check if this workspace matches the cwd
+                try {
+                    const wj = JSON.parse(fs.readFileSync(path.join(root, e.name, 'workspace.json'), 'utf8'));
+                    const folder = (wj?.folder ?? '').replace(/^file:\/\//, '').replace(/%20/g, ' ');
+                    if (folder !== cwd && !folder.startsWith(cwd + '/'))
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+            }
+            result.push(transcriptsDir);
+        }
+    }
+    return result;
+}
+/** Extract model from a Copilot JSONL event stream line. */
+function extractCopilotJsonl(filePath) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'r');
+        const size = fs.fstatSync(fd).size;
+        if (!size) {
+            fs.closeSync(fd);
+            return undefined;
+        }
+        const readSize = Math.min(TAIL_BYTES, size);
+        const buf = Buffer.alloc(readSize);
+        fs.readSync(fd, buf, 0, readSize, size - readSize);
+        fs.closeSync(fd);
+        fd = undefined;
+        const lines = buf.toString('utf8').split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const t = lines[i].trim();
+            if (!t)
+                continue;
+            try {
+                const j = JSON.parse(t);
+                // assistant.message carries modelId in data
+                const m = j?.data?.modelId ?? j?.data?.model ?? j?.model ?? j?.message?.model;
+                if (typeof m === 'string' && m)
+                    return m;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    finally {
+        if (fd !== undefined)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    return undefined;
+}
 const SPECS = [
     {
         tool: 'claude-code',
-        dirs: () => {
+        dirs: (cwd) => {
             const base = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, '.claude');
             const alt = path.join(HOME, '.config', 'claude');
+            if (cwd) {
+                // Scope to the current workspace so other projects don't bleed in.
+                return [claudeProjectDir(cwd, base), claudeProjectDir(cwd, alt)];
+            }
             return [path.join(base, 'projects'), path.join(alt, 'projects')];
         },
         ext: '.jsonl',
@@ -166,12 +273,48 @@ const SPECS = [
         ext: '.json',
         extract: extractAmp,
     },
+    {
+        tool: 'copilot',
+        dirs: (cwd) => copilotDirs(cwd),
+        ext: '.jsonl',
+        extract: extractCopilotJsonl,
+    },
     {
         tool: 'windsurf',
         dirs: () => [path.join(HOME, '.codeium', 'windsurf', 'conversations')],
         ext: '.jsonl',
         extract: extractJsonl,
     },
+    {
+        tool: 'continue',
+        dirs: () => [path.join(HOME, '.continue', 'sessions')],
+        ext: '.json',
+        extract: (filePath) => {
+            try {
+                const msgs = JSON.parse(fs.readFileSync(filePath, 'utf8'))?.history ?? [];
+                for (let i = msgs.length - 1; i >= 0; i--) {
+                    const m = msgs[i]?.message?.model ?? msgs[i]?.model;
+                    if (typeof m === 'string' && m)
+                        return m;
+                }
+            }
+            catch { }
+            return undefined;
+        },
+    },
+    {
+        // Copilot CLI: ~/.copilot/session-state/*/events.jsonl
+        tool: 'copilot-cli',
+        dirs: () => [path.join(HOME, '.copilot', 'session-state')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'droid',
+        dirs: () => [path.join(HOME, '.factory', 'sessions')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
 ];
 // ── Directory scanner: finds the newest file with the given extension ─────────
 function newestFile(dirs, ext) {
@@ -207,16 +350,19 @@ function newestFile(dirs, ext) {
 // ── Public API ────────────────────────────────────────────────────────────────
 let _cache;
 let _cacheAt = 0;
+let _cacheCwd;
 /**
- * Returns the model from the most recently modified AI session transcript,
- * across all supported tools. Result is cached for 60 s.
+ * Returns the model from the most recently modified AI session transcript.
+ * When `cwd` is provided, claude-code scanning is scoped to that workspace
+ * so activity from other projects doesn't bleed into the result.
+ * Result is cached for 60 s (cache is busted when cwd changes).
  */
-function scanTranscripts() {
-    if (_cache && Date.now() - _cacheAt < CACHE_TTL)
+function scanTranscripts(cwd) {
+    if (_cache && _cacheCwd === cwd && Date.now() - _cacheAt < CACHE_TTL)
         return _cache;
     let best;
     for (const spec of SPECS) {
-        const file = newestFile(spec.dirs(), spec.ext);
+        const file = newestFile(spec.dirs(cwd), spec.ext);
         if (!file)
             continue;
         if (best && file.mtime <= best.mtime)
@@ -228,6 +374,7 @@ function scanTranscripts() {
     }
     _cache = best;
     _cacheAt = Date.now();
+    _cacheCwd = cwd;
     return best;
 }
 function invalidateTranscriptCache() { _cache = undefined; _cacheAt = 0; }

package/dist/daemon.js

@@ -91,9 +91,23 @@ function startDaemon(opts) {
         UI_1.UI.error('Not signed in. Run: omnitype login');
         process.exit(1);
     }
-    // Auto-install preToolUse hooks into Cursor, Windsurf, Codex if present.
+    // Auto-install preToolUse hooks into all supported tools.
     (0, ToolHookInstallers_1.installAllToolHooks)();
     const watchPath = path.resolve(opts.watchPath);
+    // Initialize per-project .omnitype/ dir and ensure it is in .gitignore.
+    const omniDir = path.join(watchPath, '.omnitype');
+    try {
+        fs.mkdirSync(omniDir, { recursive: true });
+    }
+    catch { }
+    try {
+        const gitignore = path.join(watchPath, '.gitignore');
+        const current = fs.existsSync(gitignore) ? fs.readFileSync(gitignore, 'utf8') : '';
+        if (!current.split('\n').some(l => l.trim() === '.omnitype' || l.trim() === '.omnitype/')) {
+            fs.appendFileSync(gitignore, (current.length && !current.endsWith('\n') ? '\n' : '') + '.omnitype/\n');
+        }
+    }
+    catch { }
     const projectName = opts.projectName;
     const branch = opts.branch ?? gitBranch(watchPath);
     console.log(UI_1.UI.box(`${chalk_1.default.bold('Project:')} ${chalk_1.default.cyan(projectName)}\n` +

package/dist/index.js

@@ -50,6 +50,8 @@ const daemon_1 = require("./daemon");
 const blame_1 = require("./blame");
 const GitNotes_1 = require("./core/GitNotes");
 const UI_1 = require("./core/UI");
+const ToolHookInstallers_1 = require("./core/ToolHookInstallers");
+const ToolDetector_1 = require("./core/ToolDetector");
 const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
 const program = new commander_1.Command();
 program
@@ -109,40 +111,135 @@ program
     .description('Show current auth and model detection status')
     .action(() => {
     const api = new ApiClient_1.ApiClient();
-    const detection = new ModelDetector_1.ModelDetector().detect();
-    let content = '';
-    // Account Section
+    const cwd = process.cwd();
+    const detection = new ModelDetector_1.ModelDetector().detect(undefined, cwd);
+    const lines = [];
+    const col1 = 10;
+    const lbl = (k) => chalk_1.default.bold(chalk_1.default.hex(UI_1.COLORS.primary)(k.padEnd(col1)));
+    // Account
     if (api.isSignedIn) {
-        content += `${chalk_1.default.bold('Account:')}  ${chalk_1.default.cyan(api.username)}\n`;
-        content += `${chalk_1.default.bold('Server:')}   ${UI_1.UI.dim(api.apiUrl)}\n`;
+        lines.push(`${lbl('Account')} ${chalk_1.default.cyan(api.username)}`);
+        lines.push(`${lbl('Server')} ${UI_1.UI.dim(api.apiUrl)}`);
     }
     else {
-        content += `${chalk_1.default.bold('Account:')}  ${chalk_1.default.red('Not signed in')} ${UI_1.UI.dim('(run: omnitype login)')}\n`;
-    }
-    content += `\n`;
-    // Detection Section
-    content += `${chalk_1.default.bold('Current Context:')}\n`;
-    const modelColor = detection.model.includes('claude') ? '#D97757' : (detection.model.includes('gpt') ? '#10A37F' : UI_1.COLORS.ai);
-    content += `  ${chalk_1.default.bold('Model:')}  ${chalk_1.default.hex(modelColor)(detection.model)}\n`;
-    content += `  ${chalk_1.default.bold('Tool:')}   ${chalk_1.default.white(detection.tool)}\n`;
-    const confColors = {
-        deterministic: chalk_1.default.green('Deterministic'),
-        high: chalk_1.default.green('High'),
-        medium: chalk_1.default.yellow('Medium'),
-        low: chalk_1.default.red('Low'),
+        lines.push(`${lbl('Account')} ${chalk_1.default.red('not signed in')}  ${UI_1.UI.dim('→ omnitype login')}`);
+    }
+    lines.push('');
+    // AI context
+    const toolColor = (t) => t.includes('claude') ? '#D97757' : t.includes('gpt') || t.includes('openai') ? '#10A37F'
+        : t.includes('gemini') ? '#4285F4' : t.includes('copilot') ? '#6E40C9' : UI_1.COLORS.ai;
+    const modelStr = detection.model === 'unknown'
+        ? chalk_1.default.gray('none detected')
+        : chalk_1.default.bold(chalk_1.default.hex(toolColor(detection.model))(detection.model));
+    const toolStr = detection.tool === 'unknown'
+        ? chalk_1.default.gray('—')
+        : chalk_1.default.hex(toolColor(detection.tool))(detection.tool);
+    const confBadge = {
+        deterministic: chalk_1.default.bgGreen.black(' HOOK '),
+        high: chalk_1.default.bgCyan.black(' HIGH '),
+        medium: chalk_1.default.bgYellow.black(' MED  '),
+        low: chalk_1.default.bgRed.black('  LOW '),
     };
-    content += `  ${chalk_1.default.bold('Conf:')}   ${confColors[detection.confidence] || detection.confidence}\n`;
-    // Repo Section
+    lines.push(`${lbl('Model')} ${modelStr}`);
+    lines.push(`${lbl('Tool')} ${toolStr}`);
+    lines.push(`${lbl('Confidence')} ${confBadge[detection.confidence] ?? detection.confidence}`);
+    // Repo
     try {
-        const gitBranch = require('child_process').execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
-        const gitRepo = path.basename(process.cwd());
-        content += `\n`;
-        content += `${chalk_1.default.bold('Repository:')}\n`;
-        content += `  ${chalk_1.default.bold('Project:')} ${gitRepo}\n`;
-        content += `  ${chalk_1.default.bold('Branch:')}  ${chalk_1.default.magenta(gitBranch)}`;
+        const cp = require('child_process');
+        const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const remote = (() => { try {
+            return cp.execSync('git remote get-url origin', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim().replace(/^https?:\/\/[^/]+\//, '').replace(/\.git$/, '');
+        }
+        catch {
+            return '';
+        } })();
+        lines.push('');
+        lines.push(`${lbl('Project')} ${chalk_1.default.white(path.basename(cwd))}`);
+        lines.push(`${lbl('Branch')} ${chalk_1.default.magenta(branch)}`);
+        if (remote)
+            lines.push(`${lbl('Remote')} ${UI_1.UI.dim(remote)}`);
     }
     catch { }
-    console.log(UI_1.UI.box(content, `${UI_1.UI.logo()} Status`));
+    console.log(UI_1.UI.box(lines.join('\n'), `${UI_1.UI.logo()} Status`));
+});
+// ── omnitype doctor ─────────────────────────────────────────────────────────
+program
+    .command('doctor')
+    .description('Check hook status for all detected AI tools')
+    .option('--fix', 'Auto-install or upgrade any missing/stale hooks')
+    .action((opts) => {
+    const api = new ApiClient_1.ApiClient();
+    const installed = (0, ToolDetector_1.detectInstalledTools)();
+    const hookStatuses = (0, ToolHookInstallers_1.checkHookStatus)();
+    const hookMap = new Map(hookStatuses.map(s => [s.tool, s.status]));
+    const col = 20;
+    const lbl = (k) => chalk_1.default.bold(k.padEnd(col));
+    const hookBadge = {
+        'installed': chalk_1.default.bgGreen.black('  HOOKED  '),
+        'stale': chalk_1.default.bgYellow.black('  STALE   '),
+        'not-installed': chalk_1.default.bgRed.black(' NOT HOOKED'),
+        'tool-absent': '',
+    };
+    const lines = [];
+    let needsFix = false;
+    const hookedTools = installed.filter(t => t.hookSupport === 'hooked');
+    const configOnlyTools = installed.filter(t => t.hookSupport === 'config-only');
+    const unhooked = installed.filter(t => t.hookSupport === 'no-hook');
+    // ── Tools with sentinel hook support ──
+    if (hookedTools.length > 0) {
+        lines.push(chalk_1.default.bold(chalk_1.default.hex(UI_1.COLORS.primary)('Sentinel hooks:')));
+        for (const tool of hookedTools) {
+            const status = hookMap.get(tool.id) ?? 'not-installed';
+            lines.push(`  ${lbl(tool.name)} ${hookBadge[status]}`);
+            if (status === 'stale' || status === 'not-installed')
+                needsFix = true;
+        }
+    }
+    else {
+        lines.push(chalk_1.default.gray('No hookable AI tools detected on this machine.'));
+    }
+    // ── Config-only tools (model readable, no hook API) ──
+    if (configOnlyTools.length > 0) {
+        lines.push('');
+        lines.push(chalk_1.default.bold(chalk_1.default.hex(UI_1.COLORS.secondary)('Config-readable (no hook API):')));
+        for (const tool of configOnlyTools) {
+            lines.push(`  ${lbl(tool.name)} ${chalk_1.default.hex(UI_1.COLORS.secondary)(' DETECTED ')}  ${UI_1.UI.dim('model readable from config')}`);
+        }
+    }
+    // ── Detected tools we don't support yet ──
+    if (unhooked.length > 0) {
+        lines.push('');
+        lines.push(chalk_1.default.bold(chalk_1.default.hex(UI_1.COLORS.warning)('Detected (not yet supported):')));
+        for (const tool of unhooked) {
+            lines.push(`  ${lbl(tool.name)} ${chalk_1.default.gray('— support coming soon')}`);
+        }
+    }
+    // ── Nothing detected at all ──
+    if (installed.length === 0) {
+        lines.push(chalk_1.default.gray('No AI coding tools detected on this machine.'));
+        lines.push(UI_1.UI.dim('Install Claude Code, Cursor, Windsurf, or another tool and re-run.'));
+    }
+    // ── Fix prompt ──
+    if (needsFix) {
+        lines.push('');
+        if (opts.fix) {
+            (0, ToolHookInstallers_1.installAllToolHooks)();
+            lines.push(chalk_1.default.hex(UI_1.COLORS.success)('✔ Hooks installed/upgraded. Run doctor again to verify.'));
+        }
+        else {
+            lines.push(chalk_1.default.yellow('→ Run with --fix to install or upgrade missing/stale hooks.'));
+            lines.push(UI_1.UI.dim('  Hooks give deterministic (100% accurate) model attribution.'));
+        }
+    }
+    else if (hookedTools.length > 0) {
+        lines.push('');
+        lines.push(chalk_1.default.hex(UI_1.COLORS.success)('✔ All hooks up to date.'));
+    }
+    console.log(UI_1.UI.box(lines.join('\n'), `${UI_1.UI.logo()} Doctor`));
+    // Market analysis telemetry — fire and forget
+    if (installed.length > 0) {
+        api.reportToolEnvironment(installed.map(t => ({ id: t.id, name: t.name, hookSupport: t.hookSupport })));
+    }
 });
 // ── omnitype daemon ─────────────────────────────────────────────────────────
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnitype-code/cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "OmniType CLI — editor-agnostic code provenance tracking",
   "license": "MIT",
   "bin": {
@@ -10,7 +10,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "ts-node src/index.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
     "boxen": "^5.1.2",

package/scripts/postinstall.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+'use strict';
+
+// Runs after `npm install -g @omnitype-code/cli`.
+// Silently installs sentinel hooks into any AI tools already on the machine,
+// then prints a short welcome guide so the user knows what just happened.
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── Silent hook install + telemetry ───────────────────────────────────────
+// We call the compiled output directly so this script works without ts-node.
+let detectedTools = [];
+try {
+  const { installAllToolHooks } = require('../dist/core/ToolHookInstallers');
+  installAllToolHooks();
+} catch { /* dist not built yet (e.g. dev install) — skip */ }
+
+try {
+  const { detectInstalledTools } = require('../dist/core/ToolDetector');
+  detectedTools = detectInstalledTools();
+} catch {}
+
+// Fire-and-forget telemetry (only if user is already signed in from a prior install)
+try {
+  const { ApiClient } = require('../dist/core/ApiClient');
+  const api = new ApiClient();
+  if (detectedTools.length > 0) {
+    api.reportToolEnvironment(detectedTools.map(t => ({ id: t.id, name: t.name, hookSupport: t.hookSupport })));
+  }
+} catch {}
+
+// ── Welcome guide ──────────────────────────────────────────────────────────
+const dim   = s => `\x1b[2m${s}\x1b[0m`;
+const bold  = s => `\x1b[1m${s}\x1b[0m`;
+const cyan  = s => `\x1b[36m${s}\x1b[0m`;
+const green = s => `\x1b[32m${s}\x1b[0m`;
+const gray  = s => `\x1b[90m${s}\x1b[0m`;
+
+const box = (lines, title) => {
+  const width = Math.max(...lines.map(l => stripAnsi(l).length), stripAnsi(title).length) + 4;
+  const hr = '─'.repeat(width - 2);
+  const pad = s => {
+    const visible = stripAnsi(s).length;
+    return s + ' '.repeat(width - 2 - visible);
+  };
+  return [
+    `╭${hr}╮`,
+    `│ ${bold(cyan(title))}${' '.repeat(width - 2 - stripAnsi(title).length - 1)}│`,
+    `├${hr}┤`,
+    ...lines.map(l => `│ ${pad(l)}│`),
+    `╰${hr}╯`,
+  ].join('\n');
+};
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+const hookedTools   = detectedTools.filter(t => t.hookSupport === 'hooked').map(t => t.name);
+const unhookedTools = detectedTools.filter(t => t.hookSupport === 'no-hook').map(t => t.name);
+
+const lines = [
+  bold(green('✔ OmniType installed!')),
+  '',
+  bold('What it does:'),
+  `  Tracks which AI model wrote each line of code across`,
+  `  any editor — Claude Code, Cursor, Windsurf, Cline, etc.`,
+  '',
+  bold('Hooks installed for:'),
+  hookedTools.length
+    ? hookedTools.map(t => `  ${green('✔')} ${t}`).join('\n')
+    : `  ${gray('No hookable AI tools detected yet.')}`,
+  ...(unhookedTools.length ? [
+    '',
+    bold('Also detected (hook support coming):'),
+    unhookedTools.map(t => `  ${gray('○')} ${t}`).join('\n'),
+  ] : []),
+  '',
+  bold('Next steps:'),
+  `  ${cyan('omnitype login')}           Sign in to sync provenance to cloud`,
+  `  ${cyan('omnitype doctor')}          Check hook status for all tools`,
+  `  ${cyan('omnitype doctor --fix')}    Install/upgrade any missing hooks`,
+  `  ${cyan('omnitype status')}          Show active model in current workspace`,
+  '',
+  dim('Hooks give deterministic (100% accurate) model attribution.'),
+  dim('Without them attribution falls back to heuristics.'),
+];
+
+// Flatten nested arrays from the tools join
+const flat = lines.flatMap(l => typeof l === 'string' ? [l] : l.split('\n'));
+
+console.log('\n' + box(flat, 'OmniType — Code Provenance') + '\n');

package/src/core/ApiClient.ts

@@ -156,6 +156,21 @@ export 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: Array<{ id: string; name: string; hookSupport: string }>): void {
+    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
+  }
+
   private async _postWithRetry(url: string, body: unknown, attempts: number, label: string): Promise<void> {
     const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
     for (let i = 0; i < attempts; i++) {

package/src/core/ModelDetector.ts

@@ -11,9 +11,12 @@ export interface ModelDetectionResult {
 }
 
 const UNKNOWN: ModelDetectionResult = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-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 SENTINEL_MAX_AGE_MS = 30_000;
+const GLOBAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+
+function projectSentinelPath(cwd?: string): string {
+  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;
@@ -49,12 +52,12 @@ const PROC_MAP: Array<{ match: string; tool: string }> = [
 ];
 
 export class ModelDetector {
-  detect(changedFilePath?: string): ModelDetectionResult {
+  detect(changedFilePath?: string, cwd?: string): ModelDetectionResult {
     return (
-      this._sentinel(UNIVERSAL_PATH, changedFilePath) ??
-      this._sentinel(HOOKS_PATH, changedFilePath) ??
+      this._sentinel(projectSentinelPath(cwd), changedFilePath) ??
+      this._sentinel(GLOBAL_SENTINEL_PATH, changedFilePath) ??
       this._fromEnv() ??
-      this._fromTranscripts() ??
+      this._fromTranscripts(cwd) ??
       this._fromIdeConfigs() ??
       this._fromPs() ??
       (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
@@ -62,8 +65,8 @@ export class ModelDetector {
     );
   }
 
-  private _fromTranscripts(): ModelDetectionResult | undefined {
-    const r = scanTranscripts();
+  private _fromTranscripts(cwd?: string): ModelDetectionResult | undefined {
+    const r = scanTranscripts(cwd);
     if (!r) return undefined;
     return { model: r.model, tool: r.tool, confidence: 'high' };
   }
@@ -100,6 +103,37 @@ export class ModelDetector {
       const scan = this._scanIdeSettings(appName);
       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;
+  }
+
+  private _fromCopilotConfig(): ModelDetectionResult | undefined {
+    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;
   }