@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/__tests__/utils/agent-requests.test.ts

@@ -1,74 +1,94 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { getAgentRequestPath, readLatestAgentRequest, writeAgentRequest, type AgentRequest } from '../../utils/agent-requests.js';
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  getAgentRequestPath,
+  readLatestAgentRequest,
+  writeAgentRequest,
+  type AgentRequest,
+} from "../../utils/agent-requests.js";
 
-describe('agent-requests', () => {
-    let homeDir: string;
+describe("agent-requests", () => {
+  let homeDir: string;
 
-    beforeEach(() => {
-        homeDir = mkdtempSync(join(tmpdir(), 'agent-requests-test-'));
-    });
+  beforeEach(() => {
+    homeDir = mkdtempSync(join(tmpdir(), "agent-requests-test-"));
+  });
 
-    afterEach(() => {
-        rmSync(homeDir, { recursive: true, force: true });
-    });
+  afterEach(() => {
+    rmSync(homeDir, { recursive: true, force: true });
+  });
 
-    describe('getAgentRequestPath', () => {
-        it('returns ~/.ai-devkit/agent-requests/<sessionId>.json', () => {
-            expect(getAgentRequestPath(homeDir, 'abc-123')).toBe(
-                join(homeDir, '.ai-devkit', 'agent-requests', 'abc-123.json'),
-            );
-        });
+  describe("getAgentRequestPath", () => {
+    it("returns ~/.ai-devkit/agent-requests/<sessionId>.json", () => {
+      expect(getAgentRequestPath(homeDir, "abc-123")).toBe(
+        join(homeDir, ".ai-devkit", "agent-requests", "abc-123.json"),
+      );
     });
+  });
 
-    describe('writeAgentRequest', () => {
-        it('creates the directory and file on first write', () => {
-            const entry: AgentRequest = {
-                sessionId: 'sess-1',
-                toolName: 'Bash',
-                toolInput: { command: 'ls /tmp' },
-                timestamp: '2026-06-29T00:00:00.000Z',
-            };
-            writeAgentRequest(homeDir, entry);
+  describe("writeAgentRequest", () => {
+    it("creates the directory and file on first write", () => {
+      const entry: AgentRequest = {
+        sessionId: "sess-1",
+        toolName: "Bash",
+        toolInput: { command: "ls /tmp" },
+        timestamp: "2026-06-29T00:00:00.000Z",
+      };
+      writeAgentRequest(homeDir, entry);
 
-            expect(readLatestAgentRequest(homeDir, 'sess-1')).toEqual(entry);
-        });
+      expect(readLatestAgentRequest(homeDir, "sess-1")).toEqual(entry);
+    });
 
-        it('overwrites an existing entry on subsequent writes', () => {
-            const first: AgentRequest = { sessionId: 'sess-2', toolName: 'Bash', toolInput: { command: 'echo first' }, timestamp: '2026-06-29T00:00:01.000Z' };
-            const second: AgentRequest = { sessionId: 'sess-2', toolName: 'Bash', toolInput: { command: 'echo second' }, timestamp: '2026-06-29T00:00:02.000Z' };
+    it("overwrites an existing entry on subsequent writes", () => {
+      const first: AgentRequest = {
+        sessionId: "sess-2",
+        toolName: "Bash",
+        toolInput: { command: "echo first" },
+        timestamp: "2026-06-29T00:00:01.000Z",
+      };
+      const second: AgentRequest = {
+        sessionId: "sess-2",
+        toolName: "Bash",
+        toolInput: { command: "echo second" },
+        timestamp: "2026-06-29T00:00:02.000Z",
+      };
 
-            writeAgentRequest(homeDir, first);
-            writeAgentRequest(homeDir, second);
+      writeAgentRequest(homeDir, first);
+      writeAgentRequest(homeDir, second);
 
-            expect(readLatestAgentRequest(homeDir, 'sess-2')).toEqual(second);
-        });
+      expect(readLatestAgentRequest(homeDir, "sess-2")).toEqual(second);
     });
+  });
 
-    describe('readLatestAgentRequest', () => {
-        it('returns null when no file exists for the session', () => {
-            expect(readLatestAgentRequest(homeDir, 'no-such-session')).toBeNull();
-        });
+  describe("readLatestAgentRequest", () => {
+    it("returns null when no file exists for the session", () => {
+      expect(readLatestAgentRequest(homeDir, "no-such-session")).toBeNull();
+    });
 
-        it('returns null when the file contains malformed JSON', () => {
-            const entry: AgentRequest = { sessionId: 'bad', toolName: 'Bash', toolInput: {}, timestamp: '2026-06-29T00:00:00.000Z' };
-            writeAgentRequest(homeDir, entry);
-            writeFileSync(getAgentRequestPath(homeDir, 'bad'), 'NOT JSON{{{', 'utf-8');
+    it("returns null when the file contains malformed JSON", () => {
+      const entry: AgentRequest = {
+        sessionId: "bad",
+        toolName: "Bash",
+        toolInput: {},
+        timestamp: "2026-06-29T00:00:00.000Z",
+      };
+      writeAgentRequest(homeDir, entry);
+      writeFileSync(getAgentRequestPath(homeDir, "bad"), "NOT JSON{{{", "utf-8");
 
-            expect(readLatestAgentRequest(homeDir, 'bad')).toBeNull();
-        });
+      expect(readLatestAgentRequest(homeDir, "bad")).toBeNull();
+    });
 
-        it('returns the stored entry when the file is valid', () => {
-            const entry: AgentRequest = {
-                sessionId: 'good',
-                toolName: 'AskUserQuestion',
-                toolInput: { question: 'Which option?', options: ['A', 'B'] },
-                timestamp: '2026-06-29T12:00:00.000Z',
-            };
-            writeAgentRequest(homeDir, entry);
+    it("returns the stored entry when the file is valid", () => {
+      const entry: AgentRequest = {
+        sessionId: "good",
+        toolName: "AskUserQuestion",
+        toolInput: { question: "Which option?", options: ["A", "B"] },
+        timestamp: "2026-06-29T12:00:00.000Z",
+      };
+      writeAgentRequest(homeDir, entry);
 
-            expect(readLatestAgentRequest(homeDir, 'good')).toEqual(entry);
-        });
+      expect(readLatestAgentRequest(homeDir, "good")).toEqual(entry);
     });
+  });
 });

package/src/__tests__/utils/agents.test.ts

@@ -1,24 +1,24 @@
-import { describe, expect, it } from 'vitest';
-import { AGENTS } from '../../../src/utils/agents.js';
+import { describe, expect, it } from "vitest";
+import { AGENTS } from "../../../src/utils/agents.js";
 
-describe('AGENTS', () => {
-    it('includes Copilot as a startable agent', () => {
-        expect(AGENTS.copilot.command).toBe('copilot');
-        expect(AGENTS.copilot.matches('/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot')).toBe(true);
-        expect(AGENTS.copilot.matches('node /repo/feature-cli-copilot-cli/script.js')).toBe(false);
-    });
+describe("AGENTS", () => {
+  it("includes Copilot as a startable agent", () => {
+    expect(AGENTS.copilot.command).toBe("copilot");
+    expect(AGENTS.copilot.matches("/opt/homebrew/Caskroom/copilot-cli/1.0.60/copilot")).toBe(true);
+    expect(AGENTS.copilot.matches("node /repo/feature-cli-copilot-cli/script.js")).toBe(false);
+  });
 
-    it('includes Pi as a startable agent', () => {
-        expect(AGENTS.pi.command).toBe('pi');
-        expect(AGENTS.pi.matches('pi')).toBe(true);
-        expect(AGENTS.pi.matches('/usr/local/bin/pi --model x')).toBe(true);
-        expect(AGENTS.pi.matches('node /repo/feature-pi-adapter/script.js')).toBe(false);
-    });
+  it("includes Pi as a startable agent", () => {
+    expect(AGENTS.pi.command).toBe("pi");
+    expect(AGENTS.pi.matches("pi")).toBe(true);
+    expect(AGENTS.pi.matches("/usr/local/bin/pi --model x")).toBe(true);
+    expect(AGENTS.pi.matches("node /repo/feature-pi-adapter/script.js")).toBe(false);
+  });
 
-    it('includes Grok as a startable agent', () => {
-        expect(AGENTS.grok_cli.command).toBe('grok');
-        expect(AGENTS.grok_cli.matches('grok')).toBe(true);
-        expect(AGENTS.grok_cli.matches('/Users/dev/.grok/bin/grok --always-approve')).toBe(true);
-        expect(AGENTS.grok_cli.matches('node /repo/feature-grok-cli/script.js')).toBe(false);
-    });
+  it("includes Grok as a startable agent", () => {
+    expect(AGENTS.grok_cli.command).toBe("grok");
+    expect(AGENTS.grok_cli.matches("grok")).toBe(true);
+    expect(AGENTS.grok_cli.matches("/Users/dev/.grok/bin/grok --always-approve")).toBe(true);
+    expect(AGENTS.grok_cli.matches("node /repo/feature-grok-cli/script.js")).toBe(false);
+  });
 });

package/src/__tests__/utils/matching.test.ts

@@ -2,198 +2,233 @@
  * Tests for utils/matching.ts
  */
 
-
-import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
-import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
-import type { SessionFile } from '../../utils/session.js';
+import { matchProcessesToSessions, generateAgentName } from "../../utils/matching.js";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import type { SessionFile } from "../../utils/session.js";
 
 function makeProcess(overrides: Partial<ProcessInfo> & { pid: number }): ProcessInfo {
-    return {
-        command: 'claude',
-        cwd: '/projects/my-app',
-        tty: 'ttys001',
-        startTime: new Date('2026-03-18T23:18:01.000Z'),
-        ...overrides,
-    };
+  return {
+    command: "claude",
+    cwd: "/projects/my-app",
+    tty: "ttys001",
+    startTime: new Date("2026-03-18T23:18:01.000Z"),
+    ...overrides,
+  };
 }
 
 function makeSession(overrides: Partial<SessionFile> & { sessionId: string }): SessionFile {
-    return {
-        filePath: `/home/.claude/projects/my-app/${overrides.sessionId}.jsonl`,
-        projectDir: '/home/.claude/projects/my-app',
-        birthtimeMs: new Date('2026-03-18T23:18:44.000Z').getTime(),
-        resolvedCwd: '/projects/my-app',
-        ...overrides,
-    };
+  return {
+    filePath: `/home/.claude/projects/my-app/${overrides.sessionId}.jsonl`,
+    projectDir: "/home/.claude/projects/my-app",
+    birthtimeMs: new Date("2026-03-18T23:18:44.000Z").getTime(),
+    resolvedCwd: "/projects/my-app",
+    ...overrides,
+  };
 }
 
-describe('matchProcessesToSessions', () => {
-    it('should return empty array when no processes', () => {
-        const sessions = [makeSession({ sessionId: 's1' })];
-        expect(matchProcessesToSessions([], sessions)).toEqual([]);
-    });
-
-    it('should return empty array when no sessions', () => {
-        const processes = [makeProcess({ pid: 100 })];
-        expect(matchProcessesToSessions(processes, [])).toEqual([]);
-    });
-
-    it('should match a single process to closest session', () => {
-        const proc = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:44.000Z').getTime() });
-        const s2 = makeSession({ sessionId: 's2', birthtimeMs: new Date('2026-03-18T23:20:00.000Z').getTime() });
-
-        const results = matchProcessesToSessions([proc], [s1, s2]);
-        expect(results).toHaveLength(1);
-        expect(results[0].session.sessionId).toBe('s1');
-        expect(results[0].deltaMs).toBe(43000);
-    });
-
-    it('should enforce 1:1 constraint — each process matches only one session', () => {
-        const p1 = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const p2 = makeProcess({ pid: 200, startTime: new Date('2026-03-18T23:18:30.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:10.000Z').getTime() });
-        const s2 = makeSession({ sessionId: 's2', birthtimeMs: new Date('2026-03-18T23:18:35.000Z').getTime() });
-
-        const results = matchProcessesToSessions([p1, p2], [s1, s2]);
-        expect(results).toHaveLength(2);
-
-        const pids = results.map(r => r.process.pid).sort();
-        const sids = results.map(r => r.session.sessionId).sort();
-        expect(pids).toEqual([100, 200]);
-        expect(sids).toEqual(['s1', 's2']);
-    });
-
-    it('should disambiguate multiple processes with same CWD by birthtime', () => {
-        const p1 = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const p2 = makeProcess({ pid: 200, startTime: new Date('2026-03-19T08:53:11.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:44.000Z').getTime() });
-        const s2 = makeSession({ sessionId: 's2', birthtimeMs: new Date('2026-03-19T08:55:35.000Z').getTime() });
-
-        const results = matchProcessesToSessions([p1, p2], [s1, s2]);
-        expect(results).toHaveLength(2);
-
-        const match1 = results.find(r => r.process.pid === 100);
-        const match2 = results.find(r => r.process.pid === 200);
-        expect(match1?.session.sessionId).toBe('s1');
-        expect(match2?.session.sessionId).toBe('s2');
-    });
-
-    it('should exclude processes without startTime', () => {
-        const proc = makeProcess({ pid: 100, startTime: undefined });
-        const session = makeSession({ sessionId: 's1' });
-
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toEqual([]);
-    });
-
-    it('should exclude processes without cwd', () => {
-        const proc = makeProcess({ pid: 100, cwd: '' });
-        const session = makeSession({ sessionId: 's1' });
-
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toEqual([]);
-    });
-
-    it('should not match when CWD does not match resolvedCwd', () => {
-        const proc = makeProcess({ pid: 100, cwd: '/projects/app-a' });
-        const session = makeSession({ sessionId: 's1', resolvedCwd: '/projects/app-b' });
-
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toEqual([]);
-    });
-
-    it('should not match when delta exceeds 3-minute tolerance', () => {
-        const proc = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const session = makeSession({
-            sessionId: 's1',
-            birthtimeMs: new Date('2026-03-18T23:22:00.000Z').getTime(), // ~4 min later
-        });
+describe("matchProcessesToSessions", () => {
+  it("should return empty array when no processes", () => {
+    const sessions = [makeSession({ sessionId: "s1" })];
+    expect(matchProcessesToSessions([], sessions)).toEqual([]);
+  });
 
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toEqual([]);
+  it("should return empty array when no sessions", () => {
+    const processes = [makeProcess({ pid: 100 })];
+    expect(matchProcessesToSessions(processes, [])).toEqual([]);
+  });
+
+  it("should match a single process to closest session", () => {
+    const proc = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:44.000Z").getTime(),
     });
+    const s2 = makeSession({
+      sessionId: "s2",
+      birthtimeMs: new Date("2026-03-18T23:20:00.000Z").getTime(),
+    });
+
+    const results = matchProcessesToSessions([proc], [s1, s2]);
+    expect(results).toHaveLength(1);
+    expect(results[0].session.sessionId).toBe("s1");
+    expect(results[0].deltaMs).toBe(43000);
+  });
+
+  it("should enforce 1:1 constraint — each process matches only one session", () => {
+    const p1 = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const p2 = makeProcess({ pid: 200, startTime: new Date("2026-03-18T23:18:30.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:10.000Z").getTime(),
+    });
+    const s2 = makeSession({
+      sessionId: "s2",
+      birthtimeMs: new Date("2026-03-18T23:18:35.000Z").getTime(),
+    });
+
+    const results = matchProcessesToSessions([p1, p2], [s1, s2]);
+    expect(results).toHaveLength(2);
+
+    const pids = results.map((r) => r.process.pid).sort();
+    const sids = results.map((r) => r.session.sessionId).sort();
+    expect(pids).toEqual([100, 200]);
+    expect(sids).toEqual(["s1", "s2"]);
+  });
+
+  it("should disambiguate multiple processes with same CWD by birthtime", () => {
+    const p1 = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const p2 = makeProcess({ pid: 200, startTime: new Date("2026-03-19T08:53:11.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:44.000Z").getTime(),
+    });
+    const s2 = makeSession({
+      sessionId: "s2",
+      birthtimeMs: new Date("2026-03-19T08:55:35.000Z").getTime(),
+    });
+
+    const results = matchProcessesToSessions([p1, p2], [s1, s2]);
+    expect(results).toHaveLength(2);
+
+    const match1 = results.find((r) => r.process.pid === 100);
+    const match2 = results.find((r) => r.process.pid === 200);
+    expect(match1?.session.sessionId).toBe("s1");
+    expect(match2?.session.sessionId).toBe("s2");
+  });
+
+  it("should exclude processes without startTime", () => {
+    const proc = makeProcess({ pid: 100, startTime: undefined });
+    const session = makeSession({ sessionId: "s1" });
 
-    it('should match at exactly 3-minute boundary', () => {
-        const startTime = new Date('2026-03-18T23:18:00.000Z');
-        const proc = makeProcess({ pid: 100, startTime });
-        const session = makeSession({
-            sessionId: 's1',
-            birthtimeMs: startTime.getTime() + 180_000, // exactly 3 min
-        });
-
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toHaveLength(1);
-    });
-
-    it('should handle more sessions than processes', () => {
-        const proc = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:44.000Z').getTime() });
-        const s2 = makeSession({ sessionId: 's2', birthtimeMs: new Date('2026-03-18T23:19:00.000Z').getTime() });
-        const s3 = makeSession({ sessionId: 's3', birthtimeMs: new Date('2026-03-18T23:19:30.000Z').getTime() });
-
-        const results = matchProcessesToSessions([proc], [s1, s2, s3]);
-        expect(results).toHaveLength(1);
-        expect(results[0].session.sessionId).toBe('s1'); // closest
-    });
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toEqual([]);
+  });
+
+  it("should exclude processes without cwd", () => {
+    const proc = makeProcess({ pid: 100, cwd: "" });
+    const session = makeSession({ sessionId: "s1" });
+
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toEqual([]);
+  });
+
+  it("should not match when CWD does not match resolvedCwd", () => {
+    const proc = makeProcess({ pid: 100, cwd: "/projects/app-a" });
+    const session = makeSession({ sessionId: "s1", resolvedCwd: "/projects/app-b" });
+
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toEqual([]);
+  });
+
+  it("should not match when delta exceeds 3-minute tolerance", () => {
+    const proc = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const session = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:22:00.000Z").getTime(), // ~4 min later
+    });
+
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toEqual([]);
+  });
+
+  it("should match at exactly 3-minute boundary", () => {
+    const startTime = new Date("2026-03-18T23:18:00.000Z");
+    const proc = makeProcess({ pid: 100, startTime });
+    const session = makeSession({
+      sessionId: "s1",
+      birthtimeMs: startTime.getTime() + 180_000, // exactly 3 min
+    });
+
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toHaveLength(1);
+  });
 
-    it('should handle more processes than sessions', () => {
-        const p1 = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:01.000Z') });
-        const p2 = makeProcess({ pid: 200, startTime: new Date('2026-03-18T23:20:01.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:44.000Z').getTime() });
+  it("should handle more sessions than processes", () => {
+    const proc = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:44.000Z").getTime(),
+    });
+    const s2 = makeSession({
+      sessionId: "s2",
+      birthtimeMs: new Date("2026-03-18T23:19:00.000Z").getTime(),
+    });
+    const s3 = makeSession({
+      sessionId: "s3",
+      birthtimeMs: new Date("2026-03-18T23:19:30.000Z").getTime(),
+    });
+
+    const results = matchProcessesToSessions([proc], [s1, s2, s3]);
+    expect(results).toHaveLength(1);
+    expect(results[0].session.sessionId).toBe("s1"); // closest
+  });
 
-        const results = matchProcessesToSessions([p1, p2], [s1]);
-        expect(results).toHaveLength(1);
-        expect(results[0].process.pid).toBe(100); // closest
-    });
+  it("should handle more processes than sessions", () => {
+    const p1 = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:01.000Z") });
+    const p2 = makeProcess({ pid: 200, startTime: new Date("2026-03-18T23:20:01.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:44.000Z").getTime(),
+    });
+
+    const results = matchProcessesToSessions([p1, p2], [s1]);
+    expect(results).toHaveLength(1);
+    expect(results[0].process.pid).toBe(100); // closest
+  });
+
+  it("should skip sessions with empty resolvedCwd", () => {
+    const proc = makeProcess({ pid: 100 });
+    const session = makeSession({ sessionId: "s1", resolvedCwd: "" });
 
-    it('should skip sessions with empty resolvedCwd', () => {
-        const proc = makeProcess({ pid: 100 });
-        const session = makeSession({ sessionId: 's1', resolvedCwd: '' });
+    const results = matchProcessesToSessions([proc], [session]);
+    expect(results).toEqual([]);
+  });
 
-        const results = matchProcessesToSessions([proc], [session]);
-        expect(results).toEqual([]);
+  it("should prefer best match when greedy ordering matters", () => {
+    // p1 is 10s from s2, p2 is 5s from s2 — p2 should win s2, p1 gets s1
+    const p1 = makeProcess({ pid: 100, startTime: new Date("2026-03-18T23:18:00.000Z") });
+    const p2 = makeProcess({ pid: 200, startTime: new Date("2026-03-18T23:18:25.000Z") });
+    const s1 = makeSession({
+      sessionId: "s1",
+      birthtimeMs: new Date("2026-03-18T23:18:08.000Z").getTime(),
+    });
+    const s2 = makeSession({
+      sessionId: "s2",
+      birthtimeMs: new Date("2026-03-18T23:18:30.000Z").getTime(),
     });
 
-    it('should prefer best match when greedy ordering matters', () => {
-        // p1 is 10s from s2, p2 is 5s from s2 — p2 should win s2, p1 gets s1
-        const p1 = makeProcess({ pid: 100, startTime: new Date('2026-03-18T23:18:00.000Z') });
-        const p2 = makeProcess({ pid: 200, startTime: new Date('2026-03-18T23:18:25.000Z') });
-        const s1 = makeSession({ sessionId: 's1', birthtimeMs: new Date('2026-03-18T23:18:08.000Z').getTime() });
-        const s2 = makeSession({ sessionId: 's2', birthtimeMs: new Date('2026-03-18T23:18:30.000Z').getTime() });
-
-        const results = matchProcessesToSessions([p1, p2], [s1, s2]);
-        expect(results).toHaveLength(2);
-
-        const match1 = results.find(r => r.process.pid === 200);
-        const match2 = results.find(r => r.process.pid === 100);
-        expect(match1?.session.sessionId).toBe('s2'); // 5s delta
-        expect(match2?.session.sessionId).toBe('s1'); // 8s delta
-    });
+    const results = matchProcessesToSessions([p1, p2], [s1, s2]);
+    expect(results).toHaveLength(2);
+
+    const match1 = results.find((r) => r.process.pid === 200);
+    const match2 = results.find((r) => r.process.pid === 100);
+    expect(match1?.session.sessionId).toBe("s2"); // 5s delta
+    expect(match2?.session.sessionId).toBe("s1"); // 8s delta
+  });
 });
 
-describe('generateAgentName', () => {
-    it('should return lowercase kebab-case name with pid', () => {
-        expect(generateAgentName('/projects/my-app', 12345)).toBe('my-app-12345');
-    });
+describe("generateAgentName", () => {
+  it("should return lowercase kebab-case name with pid", () => {
+    expect(generateAgentName("/projects/my-app", 12345)).toBe("my-app-12345");
+  });
 
-    it('should handle root path', () => {
-        expect(generateAgentName('/', 100)).toBe('unknown-100');
-    });
+  it("should handle root path", () => {
+    expect(generateAgentName("/", 100)).toBe("unknown-100");
+  });
 
-    it('should handle empty cwd', () => {
-        expect(generateAgentName('', 100)).toBe('unknown-100');
-    });
+  it("should handle empty cwd", () => {
+    expect(generateAgentName("", 100)).toBe("unknown-100");
+  });
 
-    it('should handle nested paths', () => {
-        expect(generateAgentName('/home/user/projects/ai-devkit', 78070)).toBe('ai-devkit-78070');
-    });
+  it("should handle nested paths", () => {
+    expect(generateAgentName("/home/user/projects/ai-devkit", 78070)).toBe("ai-devkit-78070");
+  });
 
-    it('should convert spaces and special chars to kebab-case', () => {
-        expect(generateAgentName('/projects/AI DevKit', 123)).toBe('ai-devkit-123');
-    });
+  it("should convert spaces and special chars to kebab-case", () => {
+    expect(generateAgentName("/projects/AI DevKit", 123)).toBe("ai-devkit-123");
+  });
 
-    it('should convert uppercase to lowercase', () => {
-        expect(generateAgentName('/projects/MyProject', 456)).toBe('myproject-456');
-    });
+  it("should convert uppercase to lowercase", () => {
+    expect(generateAgentName("/projects/MyProject", 456)).toBe("myproject-456");
+  });
 });