@ai-devkit/agent-manager 0.22.1 → 0.25.0

package/dist/utils/agent-requests.d.ts

@@ -0,0 +1,10 @@
+export interface AgentRequest {
+    sessionId: string;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    timestamp: string;
+}
+export declare function getAgentRequestPath(homeDir: string, sessionId: string): string;
+export declare function readLatestAgentRequest(homeDir: string, sessionId: string): AgentRequest | null;
+export declare function writeAgentRequest(homeDir: string, entry: AgentRequest): void;
+//# sourceMappingURL=agent-requests.d.ts.map

package/dist/utils/agent-requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-requests.d.ts","sourceRoot":"","sources":["../../src/utils/agent-requests.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAO9F;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAI5E"}

package/dist/utils/agent-requests.js

@@ -0,0 +1,22 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function getAgentRequestPath(homeDir, sessionId) {
+    return path.join(homeDir, '.ai-devkit', 'agent-requests', `${sessionId}.json`);
+}
+export function readLatestAgentRequest(homeDir, sessionId) {
+    try {
+        const raw = fs.readFileSync(getAgentRequestPath(homeDir, sessionId), 'utf-8');
+        return JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+}
+export function writeAgentRequest(homeDir, entry) {
+    const filePath = getAgentRequestPath(homeDir, entry.sessionId);
+    fs.mkdirSync(path.dirname(filePath), {
+        recursive: true
+    });
+    fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), 'utf-8');
+}
+
+//# sourceMappingURL=agent-requests.js.map

package/dist/utils/agent-requests.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/agent-requests.ts"],"sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\n\nexport interface AgentRequest {\n    sessionId: string;\n    toolName: string;\n    toolInput: Record<string, unknown>;\n    timestamp: string;\n}\n\nexport function getAgentRequestPath(homeDir: string, sessionId: string): string {\n    return path.join(homeDir, '.ai-devkit', 'agent-requests', `${sessionId}.json`);\n}\n\nexport function readLatestAgentRequest(homeDir: string, sessionId: string): AgentRequest | null {\n    try {\n        const raw = fs.readFileSync(getAgentRequestPath(homeDir, sessionId), 'utf-8');\n        return JSON.parse(raw) as AgentRequest;\n    } catch {\n        return null;\n    }\n}\n\nexport function writeAgentRequest(homeDir: string, entry: AgentRequest): void {\n    const filePath = getAgentRequestPath(homeDir, entry.sessionId);\n    fs.mkdirSync(path.dirname(filePath), { recursive: true });\n    fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), 'utf-8');\n}\n"],"names":["fs","path","getAgentRequestPath","homeDir","sessionId","join","readLatestAgentRequest","raw","readFileSync","JSON","parse","writeAgentRequest","entry","filePath","mkdirSync","dirname","recursive","writeFileSync","stringify"],"mappings":"AAAA,YAAYA,QAAQ,KAAK;AACzB,YAAYC,UAAU,OAAO;AAS7B,OAAO,SAASC,oBAAoBC,OAAe,EAAEC,SAAiB;IAClE,OAAOH,KAAKI,IAAI,CAACF,SAAS,cAAc,kBAAkB,GAAGC,UAAU,KAAK,CAAC;AACjF;AAEA,OAAO,SAASE,uBAAuBH,OAAe,EAAEC,SAAiB;IACrE,IAAI;QACA,MAAMG,MAAMP,GAAGQ,YAAY,CAACN,oBAAoBC,SAASC,YAAY;QACrE,OAAOK,KAAKC,KAAK,CAACH;IACtB,EAAE,OAAM;QACJ,OAAO;IACX;AACJ;AAEA,OAAO,SAASI,kBAAkBR,OAAe,EAAES,KAAmB;IAClE,MAAMC,WAAWX,oBAAoBC,SAASS,MAAMR,SAAS;IAC7DJ,GAAGc,SAAS,CAACb,KAAKc,OAAO,CAACF,WAAW;QAAEG,WAAW;IAAK;IACvDhB,GAAGiB,aAAa,CAACJ,UAAUJ,KAAKS,SAAS,CAACN,OAAO,MAAM,IAAI;AAC/D"}

package/dist/utils/agents.d.ts

@@ -1,5 +1,5 @@
 import type { AgentType } from '../adapters/AgentAdapter.js';
-export type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'copilot' | 'gemini_cli' | 'opencode' | 'pi'>;
+export type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'copilot' | 'gemini_cli' | 'grok_cli' | 'opencode' | 'pi'>;
 export interface AgentConfig {
     /** Shell command to launch the agent (sent to tmux via `send-keys`). */
     command: string;

package/dist/utils/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/utils/agents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,SAAS,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC;AAEvH,MAAM,WAAW,WAAW;IACxB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CAC3C;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAO1D,CAAC"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/utils/agents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,SAAS,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC;AAEpI,MAAM,WAAW,WAAW;IACxB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CAC3C;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAQ1D,CAAC"}

package/dist/utils/agents.js

@@ -20,6 +20,10 @@ import path from 'path';
         command: 'gemini',
         matches: matchAnyToken('gemini')
     },
+    grok_cli: {
+        command: 'grok',
+        matches: matchArgv0('grok')
+    },
     opencode: {
         command: 'opencode',
         matches: matchArgv0('opencode')

package/dist/utils/agents.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/agents.ts"],"sourcesContent":["import path from 'path';\nimport type { AgentType } from '../adapters/AgentAdapter.js';\n\nexport type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'copilot' | 'gemini_cli' | 'opencode' | 'pi'>;\n\nexport interface AgentConfig {\n    /** Shell command to launch the agent (sent to tmux via `send-keys`). */\n    command: string;\n    /** Returns true if the given `ps` command line belongs to this agent. */\n    matches: (psCommand: string) => boolean;\n}\n\n/**\n * Per-agent configuration: launch command plus a matcher that recognizes the\n * agent's process in `ps` output. Each matcher knows that agent's distribution\n * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).\n */\nexport const AGENTS: Record<StartableAgentType, AgentConfig> = {\n    claude:     { command: 'claude',   matches: matchArgv0('claude') },\n    codex:      { command: 'codex',    matches: matchArgv0('codex') },\n    copilot:    { command: 'copilot',  matches: matchArgv0Name('copilot-cli') },\n    gemini_cli: { command: 'gemini',   matches: matchAnyToken('gemini') },\n    opencode:   { command: 'opencode', matches: matchArgv0('opencode') },\n    pi:         { command: 'pi',       matches: matchAnyBasename(['pi']) },\n};\n\nfunction matchArgv0(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        const token = psCommand.trim().split(/\\s+/)[0];\n        return token ? path.basename(token).toLowerCase() === lower : false;\n    };\n}\n\nfunction matchArgv0Name(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        const token = psCommand.trim().split(/\\s+/)[0];\n        return token ? token.toLowerCase().includes(lower) : false;\n    };\n}\n\nfunction matchAnyToken(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        for (const token of psCommand.trim().split(/\\s+/)) {\n            if (path.basename(token).toLowerCase() === lower) return true;\n        }\n        return false;\n    };\n}\n\nfunction matchAnyBasename(names: string[]): (psCommand: string) => boolean {\n    const lowers = new Set(names.map((name) => name.toLowerCase()));\n    return (psCommand) => {\n        for (const token of psCommand.trim().split(/\\s+/)) {\n            if (lowers.has(path.basename(token).toLowerCase())) return true;\n        }\n        return false;\n    };\n}\n"],"names":["path","AGENTS","claude","command","matches","matchArgv0","codex","copilot","matchArgv0Name","gemini_cli","matchAnyToken","opencode","pi","matchAnyBasename","name","lower","toLowerCase","psCommand","token","trim","split","basename","includes","names","lowers","Set","map","has"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAYxB;;;;CAIC,GACD,OAAO,MAAMC,SAAkD;IAC3DC,QAAY;QAAEC,SAAS;QAAYC,SAASC,WAAW;IAAU;IACjEC,OAAY;QAAEH,SAAS;QAAYC,SAASC,WAAW;IAAS;IAChEE,SAAY;QAAEJ,SAAS;QAAYC,SAASI,eAAe;IAAe;IAC1EC,YAAY;QAAEN,SAAS;QAAYC,SAASM,cAAc;IAAU;IACpEC,UAAY;QAAER,SAAS;QAAYC,SAASC,WAAW;IAAY;IACnEO,IAAY;QAAET,SAAS;QAAYC,SAASS,iBAAiB;YAAC;SAAK;IAAE;AACzE,EAAE;AAEF,SAASR,WAAWS,IAAY;IAC5B,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQlB,KAAKqB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,QAAQ;IAClE;AACJ;AAEA,SAASP,eAAeM,IAAY;IAChC,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQA,MAAMF,WAAW,GAAGM,QAAQ,CAACP,SAAS;IACzD;AACJ;AAEA,SAASL,cAAcI,IAAY;IAC/B,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YAC/C,IAAIpB,KAAKqB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,OAAO,OAAO;QAC7D;QACA,OAAO;IACX;AACJ;AAEA,SAASF,iBAAiBU,KAAe;IACrC,MAAMC,SAAS,IAAIC,IAAIF,MAAMG,GAAG,CAAC,CAACZ,OAASA,KAAKE,WAAW;IAC3D,OAAO,CAACC;QACJ,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YAC/C,IAAII,OAAOG,GAAG,CAAC3B,KAAKqB,QAAQ,CAACH,OAAOF,WAAW,KAAK,OAAO;QAC/D;QACA,OAAO;IACX;AACJ"}
+{"version":3,"sources":["../../src/utils/agents.ts"],"sourcesContent":["import path from 'path';\nimport type { AgentType } from '../adapters/AgentAdapter.js';\n\nexport type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'copilot' | 'gemini_cli' | 'grok_cli' | 'opencode' | 'pi'>;\n\nexport interface AgentConfig {\n    /** Shell command to launch the agent (sent to tmux via `send-keys`). */\n    command: string;\n    /** Returns true if the given `ps` command line belongs to this agent. */\n    matches: (psCommand: string) => boolean;\n}\n\n/**\n * Per-agent configuration: launch command plus a matcher that recognizes the\n * agent's process in `ps` output. Each matcher knows that agent's distribution\n * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).\n */\nexport const AGENTS: Record<StartableAgentType, AgentConfig> = {\n    claude:     { command: 'claude',   matches: matchArgv0('claude') },\n    codex:      { command: 'codex',    matches: matchArgv0('codex') },\n    copilot:    { command: 'copilot',  matches: matchArgv0Name('copilot-cli') },\n    gemini_cli: { command: 'gemini',   matches: matchAnyToken('gemini') },\n    grok_cli:   { command: 'grok',     matches: matchArgv0('grok') },\n    opencode:   { command: 'opencode', matches: matchArgv0('opencode') },\n    pi:         { command: 'pi',       matches: matchAnyBasename(['pi']) },\n};\n\nfunction matchArgv0(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        const token = psCommand.trim().split(/\\s+/)[0];\n        return token ? path.basename(token).toLowerCase() === lower : false;\n    };\n}\n\nfunction matchArgv0Name(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        const token = psCommand.trim().split(/\\s+/)[0];\n        return token ? token.toLowerCase().includes(lower) : false;\n    };\n}\n\nfunction matchAnyToken(name: string): (psCommand: string) => boolean {\n    const lower = name.toLowerCase();\n    return (psCommand) => {\n        for (const token of psCommand.trim().split(/\\s+/)) {\n            if (path.basename(token).toLowerCase() === lower) return true;\n        }\n        return false;\n    };\n}\n\nfunction matchAnyBasename(names: string[]): (psCommand: string) => boolean {\n    const lowers = new Set(names.map((name) => name.toLowerCase()));\n    return (psCommand) => {\n        for (const token of psCommand.trim().split(/\\s+/)) {\n            if (lowers.has(path.basename(token).toLowerCase())) return true;\n        }\n        return false;\n    };\n}\n"],"names":["path","AGENTS","claude","command","matches","matchArgv0","codex","copilot","matchArgv0Name","gemini_cli","matchAnyToken","grok_cli","opencode","pi","matchAnyBasename","name","lower","toLowerCase","psCommand","token","trim","split","basename","includes","names","lowers","Set","map","has"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAYxB;;;;CAIC,GACD,OAAO,MAAMC,SAAkD;IAC3DC,QAAY;QAAEC,SAAS;QAAYC,SAASC,WAAW;IAAU;IACjEC,OAAY;QAAEH,SAAS;QAAYC,SAASC,WAAW;IAAS;IAChEE,SAAY;QAAEJ,SAAS;QAAYC,SAASI,eAAe;IAAe;IAC1EC,YAAY;QAAEN,SAAS;QAAYC,SAASM,cAAc;IAAU;IACpEC,UAAY;QAAER,SAAS;QAAYC,SAASC,WAAW;IAAQ;IAC/DO,UAAY;QAAET,SAAS;QAAYC,SAASC,WAAW;IAAY;IACnEQ,IAAY;QAAEV,SAAS;QAAYC,SAASU,iBAAiB;YAAC;SAAK;IAAE;AACzE,EAAE;AAEF,SAAST,WAAWU,IAAY;IAC5B,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQnB,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,QAAQ;IAClE;AACJ;AAEA,SAASR,eAAeO,IAAY;IAChC,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQA,MAAMF,WAAW,GAAGM,QAAQ,CAACP,SAAS;IACzD;AACJ;AAEA,SAASN,cAAcK,IAAY;IAC/B,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACJ,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YAC/C,IAAIrB,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,OAAO,OAAO;QAC7D;QACA,OAAO;IACX;AACJ;AAEA,SAASF,iBAAiBU,KAAe;IACrC,MAAMC,SAAS,IAAIC,IAAIF,MAAMG,GAAG,CAAC,CAACZ,OAASA,KAAKE,WAAW;IAC3D,OAAO,CAACC;QACJ,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YAC/C,IAAII,OAAOG,GAAG,CAAC5B,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,KAAK,OAAO;QAC/D;QACA,OAAO;IACX;AACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-devkit/agent-manager",
-  "version": "0.22.1",
+  "version": "0.25.0",
   "type": "module",
   "description": "Standalone agent detection and management utilities for AI DevKit",
   "main": "dist/index.js",
@@ -35,7 +35,7 @@
     "directory": "packages/agent-manager"
   },
   "dependencies": {
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "12.11.1",
     "uuid": "14.0.0"
   },
   "devDependencies": {

package/src/__tests__/AgentManager.test.ts

@@ -86,9 +86,15 @@ function createMockAgent(overrides: Partial<AgentInfo> = {}): AgentInfo {
 
 describe('AgentManager', () => {
     let manager: AgentManager;
+    let tmpDir: string;
 
     beforeEach(() => {
-        manager = new AgentManager();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-manager-'));
+        manager = new AgentManager(new AgentRegistry(path.join(tmpDir, 'agents.json')));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
     });
 
     describe('registerAdapter', () => {

package/src/__tests__/adapters/GrokCliAdapter.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Tests for GrokCliAdapter
+ *
+ * The adapter resolves a live process to its cwd via ~/.grok/active_sessions.json
+ * and reads session details from chat_history.jsonl (not summary.json/updates.jsonl).
+ */
+
+import type { MockedFunction } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { GrokCliAdapter } from '../../adapters/GrokCliAdapter.js';
+import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { generateAgentName } from '../../utils/matching.js';
+
+vi.mock('../../utils/process.js', async (importOriginal) => {
+    const actual = (await importOriginal()) as typeof import('../../utils/process.js');
+    return {
+        ...actual,
+        listAgentProcesses: vi.fn(),
+        enrichProcesses: vi.fn(),
+    };
+});
+
+vi.mock('../../utils/matching.js', async (importOriginal) => {
+    const actual = (await importOriginal()) as typeof import('../../utils/matching.js');
+    return {
+        ...actual,
+        generateAgentName: vi.fn(),
+    };
+});
+
+const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
+
+const SESSION_ID = '019f16c3-5d5d-7dc3-85d1-bc629416ca2d';
+
+/** A user transcript record: the real prompt wrapped in <user_query> like Grok writes it. */
+const userRecord = (text: string) => ({
+    type: 'user',
+    content: [{ type: 'text', text: `<user_query>\n${text}\n</user_query>` }],
+});
+/** A user context-injection record (no <user_query>) — should be ignored as a prompt. */
+const contextRecord = (text: string) => ({ type: 'user', content: [{ type: 'text', text }] });
+const assistantRecord = (text: string) => ({ type: 'assistant', content: [{ type: 'text', text }] });
+const systemRecord = (text: string) => ({ type: 'system', content: text });
+
+describe('GrokCliAdapter', () => {
+    let adapter: GrokCliAdapter;
+    let tmpHome: string;
+    let cwd: string;
+
+    beforeEach(() => {
+        tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'grok-adapter-test-'));
+        process.env.HOME = tmpHome;
+        delete process.env.GROK_HOME;
+        cwd = '/Users/dev/my-project';
+
+        adapter = new GrokCliAdapter();
+
+        mockedListAgentProcesses.mockReset();
+        mockedEnrichProcesses.mockReset();
+        mockedGenerateAgentName.mockReset();
+
+        mockedEnrichProcesses.mockImplementation((procs) => procs);
+        mockedGenerateAgentName.mockImplementation((c: string, pid: number) => `${path.basename(c) || 'unknown'}-${pid}`);
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpHome, { recursive: true, force: true });
+    });
+
+    /** Write a session dir under ~/.grok/sessions/<enc(cwd)>/<id>/chat_history.jsonl. */
+    function writeSession(opts: {
+        sessionCwd?: string;
+        id?: string;
+        records?: object[];
+        chat?: boolean;
+        mtime?: Date;
+    }): string {
+        const sessionCwd = opts.sessionCwd ?? cwd;
+        const id = opts.id ?? SESSION_ID;
+        const sessionDir = path.join(tmpHome, '.grok', 'sessions', encodeURIComponent(sessionCwd), id);
+        fs.mkdirSync(sessionDir, { recursive: true });
+
+        if (opts.chat !== false) {
+            const records = opts.records ?? [userRecord('fix the bug')];
+            const chatPath = path.join(sessionDir, 'chat_history.jsonl');
+            fs.writeFileSync(chatPath, records.map((r) => JSON.stringify(r)).join('\n'));
+            if (opts.mtime) fs.utimesSync(chatPath, opts.mtime, opts.mtime);
+        }
+
+        return sessionDir;
+    }
+
+    /** Write ~/.grok/active_sessions.json (the live pid -> cwd registry). */
+    function writeActiveSessions(entries: Array<{ pid: number; cwd: string; opened_at?: number }>): void {
+        fs.mkdirSync(path.join(tmpHome, '.grok'), { recursive: true });
+        fs.writeFileSync(path.join(tmpHome, '.grok', 'active_sessions.json'), JSON.stringify(entries));
+    }
+
+    function proc(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+        return { pid: 4242, ppid: 1, command: 'grok', cwd, tty: 'ttys010', startTime: new Date(), ...overrides };
+    }
+
+    describe('initialization', () => {
+        it('exposes the grok_cli type', () => {
+            expect(adapter.type).toBe('grok_cli');
+        });
+    });
+
+    describe('canHandle', () => {
+        it('returns true for a plain grok command', () => {
+            expect(adapter.canHandle(proc({ command: 'grok' }))).toBe(true);
+        });
+
+        it('returns true for grok with a full path and args', () => {
+            expect(adapter.canHandle(proc({ command: '/Users/dev/.grok/bin/grok --always-approve' }))).toBe(true);
+        });
+
+        it('returns false for non-grok processes', () => {
+            expect(adapter.canHandle(proc({ command: 'node app.js' }))).toBe(false);
+        });
+
+        it('returns false when "grok" appears only in an argument path', () => {
+            expect(adapter.canHandle(proc({ command: 'node /path/to/grok-thing.js' }))).toBe(false);
+        });
+    });
+
+    describe('detectAgents', () => {
+        it('returns [] when there are no grok processes', async () => {
+            mockedListAgentProcesses.mockReturnValue([]);
+            expect(await adapter.detectAgents()).toEqual([]);
+        });
+
+        it('resolves the cwd via active_sessions.json (authoritative over the process cwd)', async () => {
+            const realCwd = '/Users/dev/real-project';
+            writeSession({ sessionCwd: realCwd });
+            // The process cwd is stale/wrong; active_sessions.json has the truth.
+            writeActiveSessions([{ pid: 4242, cwd: realCwd, opened_at: 1 }]);
+            mockedListAgentProcesses.mockReturnValue([proc({ cwd: '/wrong/path' })]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'grok_cli',
+                pid: 4242,
+                projectPath: realCwd,
+                sessionId: SESSION_ID,
+                summary: 'fix the bug',
+            });
+            expect(agents[0].sessionFilePath).toBe(
+                path.join(tmpHome, '.grok', 'sessions', encodeURIComponent(realCwd), SESSION_ID, 'chat_history.jsonl'),
+            );
+        });
+
+        it('falls back to the process cwd when the pid is not in active_sessions.json', async () => {
+            writeSession({});
+            writeActiveSessions([{ pid: 9999, cwd: '/somewhere/else' }]);
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents[0]).toMatchObject({ projectPath: cwd, sessionId: SESSION_ID });
+        });
+
+        it('picks the most recently active session dir when a cwd has several', async () => {
+            const older = new Date(Date.now() - 60 * 60 * 1000);
+            writeSession({ id: '019f0000-0000-7000-8000-00000000000a', records: [userRecord('old one')], mtime: older });
+            writeSession({ id: '019f0000-0000-7000-8000-00000000000b', records: [userRecord('newest one')] });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('019f0000-0000-7000-8000-00000000000b');
+            expect(agents[0].summary).toBe('newest one');
+        });
+
+        it('falls back to a process-only RUNNING agent when no session matches', async () => {
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].status).toBe(AgentStatus.RUNNING);
+            expect(agents[0].sessionId).toBe('pid-4242');
+            expect(agents[0].sessionFilePath).toBeUndefined();
+        });
+
+        it('treats a session dir without chat_history.jsonl as no match (process-only)', async () => {
+            writeSession({ chat: false });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].sessionId).toBe('pid-4242');
+        });
+    });
+
+    describe('getConversation', () => {
+        it('maps user (<user_query>) and assistant records to roles', () => {
+            const dir = writeSession({ records: [userRecord('hi'), assistantRecord('hello')] });
+            expect(adapter.getConversation(path.join(dir, 'chat_history.jsonl'))).toEqual([
+                { role: 'user', content: 'hi' },
+                { role: 'assistant', content: 'hello' },
+            ]);
+        });
+
+        it('accepts a session dir path and skips context-injection user records', () => {
+            const dir = writeSession({
+                records: [contextRecord('<user_info>OS: macos</user_info>'), userRecord('do the thing')],
+            });
+            expect(adapter.getConversation(dir)).toEqual([{ role: 'user', content: 'do the thing' }]);
+        });
+
+        it('skips malformed lines', () => {
+            const dir = writeSession({ records: [userRecord('hi')] });
+            fs.appendFileSync(path.join(dir, 'chat_history.jsonl'), '\n{bad json');
+            expect(adapter.getConversation(dir)).toEqual([{ role: 'user', content: 'hi' }]);
+        });
+
+        it('excludes system records unless verbose', () => {
+            const dir = writeSession({ records: [systemRecord('You are Grok'), userRecord('go')] });
+            expect(adapter.getConversation(dir)).toEqual([{ role: 'user', content: 'go' }]);
+            expect(adapter.getConversation(dir, { verbose: true }).map((m) => m.role)).toEqual(['system', 'user']);
+        });
+    });
+
+    describe('detectAgents status + summary mapping', () => {
+        const detectFirst = async () => (await adapter.detectAgents())[0];
+
+        it('marks WAITING when the last transcript turn is an assistant message', async () => {
+            writeSession({ records: [userRecord('go'), assistantRecord('done')] });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+            expect((await detectFirst()).status).toBe(AgentStatus.WAITING);
+        });
+
+        it('marks RUNNING when the last transcript turn is a user message', async () => {
+            writeSession({ records: [userRecord('still there?')] });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+            expect((await detectFirst()).status).toBe(AgentStatus.RUNNING);
+        });
+
+        it('marks IDLE when chat_history.jsonl is older than the threshold', async () => {
+            const old = new Date(Date.now() - 10 * 60 * 1000);
+            writeSession({ records: [userRecord('go')], mtime: old });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+            expect((await detectFirst()).status).toBe(AgentStatus.IDLE);
+        });
+
+        it('uses the last user prompt as the agent summary', async () => {
+            writeSession({ records: [userRecord('refactor the parser'), assistantRecord('on it')] });
+            mockedListAgentProcesses.mockReturnValue([proc()]);
+            expect((await detectFirst()).summary).toBe('refactor the parser');
+        });
+    });
+
+    describe('listSessions', () => {
+        it('returns [] when the sessions dir does not exist', async () => {
+            expect(await adapter.listSessions()).toEqual([]);
+        });
+
+        it('lists historical sessions with cwd decoded from the group dir', async () => {
+            writeSession({});
+            const summaries = await adapter.listSessions();
+            expect(summaries).toHaveLength(1);
+            expect(summaries[0]).toMatchObject({
+                type: 'grok_cli',
+                sessionId: SESSION_ID,
+                cwd,
+                firstUserMessage: 'fix the bug',
+            });
+            expect(summaries[0].sessionFilePath).toBe(
+                path.join(tmpHome, '.grok', 'sessions', encodeURIComponent(cwd), SESSION_ID, 'chat_history.jsonl'),
+            );
+        });
+
+        it('applies the cwd filter against the decoded cwd', async () => {
+            writeSession({ sessionCwd: '/Users/dev/project-a', id: '019f0000-0000-7000-8000-00000000000a' });
+            writeSession({ sessionCwd: '/Users/dev/project-b', id: '019f0000-0000-7000-8000-00000000000b' });
+
+            const all = await adapter.listSessions();
+            expect(all).toHaveLength(2);
+
+            const filtered = await adapter.listSessions({ cwd: '/Users/dev/project-a' });
+            expect(filtered).toHaveLength(1);
+            expect(filtered[0].cwd).toBe('/Users/dev/project-a');
+        });
+
+        it('skips non-session entries (e.g. prompt_history.jsonl) in a group dir', async () => {
+            writeSession({});
+            // Grok writes a group-level prompt_history.jsonl alongside session dirs.
+            fs.writeFileSync(
+                path.join(tmpHome, '.grok', 'sessions', encodeURIComponent(cwd), 'prompt_history.jsonl'),
+                '{"text":"noise"}',
+            );
+            const summaries = await adapter.listSessions();
+            expect(summaries).toHaveLength(1);
+        });
+    });
+});

package/src/__tests__/terminal/TerminalFocusManager.test.ts

@@ -2,6 +2,7 @@ import { execFile } from 'child_process';
 import type { MockedFunction } from 'vitest';
 
 import { TerminalFocusManager, TerminalType } from '../../terminal/TerminalFocusManager.js';
+import type { TerminalLocation } from '../../terminal/TerminalFocusManager.js';
 import { getProcessTty } from '../../utils/process.js';
 
 vi.mock('child_process', () => ({
@@ -62,6 +63,192 @@ describe('TerminalFocusManager', () => {
         );
     });
 
+    describe('WezTerm', () => {
+        const listArgs = ['cli', 'list', '--format', 'json'];
+
+        it('finds the WezTerm pane whose tty_name matches the agent tty', async () => {
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm' && args.join(' ') === listArgs.join(' ')) {
+                    return JSON.stringify([
+                        { pane_id: 3, tty_name: '/dev/ttys099', cwd: '/x' },
+                        { pane_id: 7, tty_name: '/dev/ttys000', cwd: '/y' },
+                    ]);
+                }
+                return '';
+            });
+
+            const location = await new TerminalFocusManager().findTerminal(123);
+
+            expect(location).toEqual({
+                type: TerminalType.WEZTERM,
+                identifier: '7',
+                tty: '/dev/ttys000',
+            });
+        });
+
+        it('skips the macOS AppleScript probes when WezTerm matches', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm') {
+                    return JSON.stringify([{ pane_id: 7, tty_name: '/dev/ttys000' }]);
+                }
+                return '';
+            });
+
+            await new TerminalFocusManager().findTerminal(123);
+
+            expect(mockedExecFile).not.toHaveBeenCalledWith(
+                'osascript',
+                expect.any(Array),
+                expect.any(Function),
+            );
+        });
+
+        it('returns UNKNOWN when WezTerm is installed but no pane matches the tty', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm') {
+                    return JSON.stringify([{ pane_id: 7, tty_name: '/dev/ttys099' }]);
+                }
+                return '';
+            });
+
+            const location = await new TerminalFocusManager().findTerminal(123);
+
+            expect(location?.type).toBe(TerminalType.UNKNOWN);
+        });
+
+        it('returns UNKNOWN (without throwing) on malformed JSON from wezterm', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm') return 'not-json{';
+                return '';
+            });
+
+            const location = await new TerminalFocusManager().findTerminal(123);
+
+            expect(location?.type).toBe(TerminalType.UNKNOWN);
+        });
+
+        it('returns UNKNOWN when the wezterm binary is missing', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm') return new Error('spawn wezterm ENOENT');
+                return '';
+            });
+
+            const location = await new TerminalFocusManager().findTerminal(123);
+
+            expect(location?.type).toBe(TerminalType.UNKNOWN);
+        });
+
+        it('prefers tmux over WezTerm (tmux-inside-WezTerm resolves to tmux)', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'tmux') {
+                    return `/dev/ttys000|my:0.1`;
+                }
+                if (cmd === 'wezterm') {
+                    return JSON.stringify([{ pane_id: 7, tty: '/dev/ttys000' }]);
+                }
+                return '';
+            });
+
+            const location = await new TerminalFocusManager().findTerminal(123);
+
+            expect(location).toEqual({
+                type: TerminalType.TMUX,
+                identifier: 'my:0.1',
+                tty: '/dev/ttys000',
+            });
+            // WezTerm must not even be queried when tmux already matched.
+            expect(mockedExecFile).not.toHaveBeenCalledWith(
+                'wezterm',
+                expect.any(Array),
+                expect.any(Function),
+            );
+        });
+    });
+
+    describe('focusTerminal for WezTerm', () => {
+        const location: TerminalLocation = {
+            type: TerminalType.WEZTERM,
+            identifier: '7',
+            tty: '/dev/ttys000',
+        };
+
+        it('focuses the pane via wezterm cli activate-pane --pane-id', async () => {
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'wezterm' && args.join(' ') === 'cli activate-pane --pane-id 7') {
+                    return '';
+                }
+                return '';
+            });
+
+            const ok = await new TerminalFocusManager().focusTerminal(location);
+
+            expect(ok).toBe(true);
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'wezterm',
+                ['cli', 'activate-pane', '--pane-id', '7'],
+                expect.any(Function),
+            );
+        });
+
+        it('returns false (without throwing) when focus fails', async () => {
+            setExecFileHandler((cmd) => {
+                if (cmd === 'wezterm') return new Error('boom');
+                return '';
+            });
+
+            const ok = await new TerminalFocusManager().focusTerminal(location);
+
+            expect(ok).toBe(false);
+        });
+    });
+
+    describe('debug tracing', () => {
+        it('emits the matching decision path via the debug logger', async () => {
+            const debug = vi.fn();
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return new Error('tmux not running');
+                if (cmd === 'wezterm' && args.join(' ').includes('cli list')) {
+                    return JSON.stringify([{ pane_id: 7, tty_name: '/dev/ttys000' }]);
+                }
+                return '';
+            });
+
+            const location = await new TerminalFocusManager(debug).findTerminal(123);
+
+            expect(location?.type).toBe(TerminalType.WEZTERM);
+            const messages = debug.mock.calls.map((call) => call[0] as string);
+            expect(messages.some((m) => /pid=123/.test(m))).toBe(true);
+            expect(messages.some((m) => /tmux.*no match|tmux: no/i.test(m))).toBe(true);
+            expect(messages.some((m) => /wezterm/i.test(m))).toBe(true);
+        });
+
+        it('emits the focus decision path via the debug logger', async () => {
+            const debug = vi.fn();
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'wezterm' && args.join(' ') === 'cli activate-pane --pane-id 7') {
+                    return '';
+                }
+                return '';
+            });
+
+            const ok = await new TerminalFocusManager(debug).focusTerminal({
+                type: TerminalType.WEZTERM,
+                identifier: '7',
+                tty: '/dev/ttys000',
+            });
+
+            expect(ok).toBe(true);
+            const messages = debug.mock.calls.map((call) => call[0] as string);
+            expect(messages.some((m) => /focusing wezterm/i.test(m))).toBe(true);
+            expect(messages.some((m) => /succeeded/i.test(m))).toBe(true);
+        });
+    });
+
     it('finds Terminal.app when the process is listed by app bundle path', async () => {
         setExecFileHandler((cmd, args) => {
             if (cmd === 'tmux') return new Error('tmux not running');