@ai-devkit/agent-manager 0.4.0 → 0.5.0

package/dist/adapters/AgentAdapter.d.ts

@@ -52,6 +52,8 @@ export interface ProcessInfo {
     cwd: string;
     /** Terminal TTY (e.g., "ttys030") */
     tty: string;
+    /** Process start time, populated by enrichProcesses */
+    startTime?: Date;
 }
 /**
  * Agent Adapter Interface

package/dist/adapters/AgentAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AgentAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/AgentAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,GAAG,OAAO,CAAC;AAEpE;;GAEG;AACH,oBAAY,WAAW;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,OAAO,YAAY;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IAEb,oBAAoB;IACpB,IAAI,EAAE,SAAS,CAAC;IAEhB,qBAAqB;IACrB,MAAM,EAAE,WAAW,CAAC;IAEpB,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAEhB,iBAAiB;IACjB,GAAG,EAAE,MAAM,CAAC;IAEZ,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IAEpB,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAElB,wGAAwG;IACxG,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,iCAAiC;IACjC,UAAU,EAAE,IAAI,CAAC;CAEpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,iBAAiB;IACjB,GAAG,EAAE,MAAM,CAAC;IAEZ,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAEhB,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAC;IAEZ,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IACzB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;OAGG;IACH,YAAY,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAErC;;;;OAIG;IACH,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC;CAChD"}
+{"version":3,"file":"AgentAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/AgentAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,GAAG,OAAO,CAAC;AAEpE;;GAEG;AACH,oBAAY,WAAW;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,OAAO,YAAY;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IAEb,oBAAoB;IACpB,IAAI,EAAE,SAAS,CAAC;IAEhB,qBAAqB;IACrB,MAAM,EAAE,WAAW,CAAC;IAEpB,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAEhB,iBAAiB;IACjB,GAAG,EAAE,MAAM,CAAC;IAEZ,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IAEpB,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAElB,wGAAwG;IACxG,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,iCAAiC;IACjC,UAAU,EAAE,IAAI,CAAC;CAEpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,iBAAiB;IACjB,GAAG,EAAE,MAAM,CAAC;IAEZ,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAEhB,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAC;IAEZ,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAC;IAEZ,uDAAuD;IACvD,SAAS,CAAC,EAAE,IAAI,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IACzB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;OAGG;IACH,YAAY,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAErC;;;;OAIG;IACH,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC;CAChD"}

package/dist/adapters/ClaudeCodeAdapter.d.ts

@@ -3,21 +3,16 @@ import type { AgentAdapter, AgentInfo, ProcessInfo } from './AgentAdapter';
  * Claude Code Adapter
  *
  * Detects Claude Code agents by:
- * 1. Finding running claude processes
- * 2. Getting process start times for accurate session matching
- * 3. Reading bounded session files from ~/.claude/projects/
- * 4. Matching sessions to processes via CWD then start time ranking
+ * 1. Finding running claude processes via shared listAgentProcesses()
+ * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json
+ * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file
  * 5. Extracting summary from last user message in session JSONL
  */
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     readonly type: "claude";
-    /** Limit session parsing per run to keep list latency bounded. */
-    private static readonly MIN_SESSION_SCAN;
-    private static readonly MAX_SESSION_SCAN;
-    private static readonly SESSION_SCAN_MULTIPLIER;
-    /** Matching tolerance between process start time and session start time. */
-    private static readonly PROCESS_SESSION_TIME_TOLERANCE_MS;
     private projectsDir;
+    private sessionsDir;
     constructor();
     /**
      * Check if this adapter can handle a given process
@@ -28,24 +23,34 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Detect running Claude Code agents
      */
     detectAgents(): Promise<AgentInfo[]>;
-    private listClaudeProcesses;
-    private calculateSessionScanLimit;
-    private assignSessionsForMode;
-    private mapSessionToAgent;
-    private mapProcessOnlyAgent;
-    private selectBestSession;
-    private filterCandidateSessions;
-    private rankCandidatesByStartTime;
-    private getProcessStartTimes;
-    private parseElapsedSeconds;
     /**
-     * Read Claude Code sessions with bounded scanning
+     * Discover session files for the given processes.
+     *
+     * For each unique process CWD, encodes it to derive the expected
+     * ~/.claude/projects/<encoded>/ directory, then gets session file birthtimes
+     * via a single batched stat call across all directories.
+     */
+    private discoverSessions;
+    /**
+     * Attempt to match each process to its session via ~/.claude/sessions/<pid>.json.
+     *
+     * Returns:
+     *   direct  — processes matched authoritatively via PID file
+     *   fallback — processes with no valid PID file (sent to legacy matching)
+     *
+     * Per-process fallback triggers on: file absent, malformed JSON,
+     * stale startedAt (>60 s from proc.startTime), or missing JSONL.
      */
-    private readSessions;
+    private tryPidFileMatching;
     /**
-     * Find session files bounded by mtime, sorted most-recent first
+     * Derive the Claude Code project directory for a given CWD.
+     *
+     * Claude Code encodes paths by replacing '/' with '-':
+     * /Users/foo/bar → ~/.claude/projects/-Users-foo-bar/
      */
-    private findSessionFiles;
+    private getProjectDir;
+    private mapSessionToAgent;
+    private mapProcessOnlyAgent;
     /**
      * Parse a single session file into ClaudeSession
      */
@@ -54,15 +59,6 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Determine agent status from session state
      */
     private determineStatus;
-    /**
-     * Generate unique agent name
-     * Uses project basename, appends slug if multiple sessions for same project
-     */
-    private generateAgentName;
-    /** Check if two paths are equal, or one is a parent/child of the other. */
-    private pathRelated;
-    private pathEquals;
-    private isChildPath;
     /**
      * Extract meaningful text from a user message content.
      * Handles string and array formats, skill command expansion, and noise filtering.
@@ -81,6 +77,5 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * These should not overwrite lastEntryType used for status determination.
      */
     private isMetadataEntryType;
-    private normalizePath;
 }
 //# sourceMappingURL=ClaudeCodeAdapter.d.ts.map

package/dist/adapters/ClaudeCodeAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClaudeCodeAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/ClaudeCodeAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AA8C3E;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAK;IACpD,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iCAAiC,CAAiB;IAE1E,OAAO,CAAC,WAAW,CAAS;;IAO5B;;OAEG;IACH,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAI5C,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAkD1C,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,yBAAyB;IAUjC,OAAO,CAAC,qBAAqB;IA+B7B,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,mBAAmB;IAoB3B,OAAO,CAAC,iBAAiB;IA6CzB,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,yBAAyB;IAgCjC,OAAO,CAAC,oBAAoB;IAiC5B,OAAO,CAAC,mBAAmB;IAgB3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAkBpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4ExB;;OAEG;IACH,OAAO,CAAC,WAAW;IAyGnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAwBzB,2EAA2E;IAC3E,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,WAAW;IAUnB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,aAAa;CAOxB"}
+{"version":3,"file":"ClaudeCodeAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/ClaudeCodeAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AA0D3E;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;;IAQ5B;;OAEG;IACH,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAI5C,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAwD1C;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAkD1B;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,mBAAmB;IAa3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAyGnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAI9B"}

package/dist/adapters/ClaudeCodeAdapter.js

@@ -36,18 +36,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeCodeAdapter = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
 const AgentAdapter_1 = require("./AgentAdapter");
 const process_1 = require("../utils/process");
-const file_1 = require("../utils/file");
+const session_1 = require("../utils/session");
+const matching_1 = require("../utils/matching");
 /**
  * Claude Code Adapter
  *
  * Detects Claude Code agents by:
- * 1. Finding running claude processes
- * 2. Getting process start times for accurate session matching
- * 3. Reading bounded session files from ~/.claude/projects/
- * 4. Matching sessions to processes via CWD then start time ranking
+ * 1. Finding running claude processes via shared listAgentProcesses()
+ * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json
+ * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file
  * 5. Extracting summary from last user message in session JSONL
  */
 class ClaudeCodeAdapter {
@@ -55,6 +55,7 @@ class ClaudeCodeAdapter {
         this.type = 'claude';
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.projectsDir = path.join(homeDir, '.claude', 'projects');
+        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');
     }
     /**
      * Check if this adapter can handle a given process
@@ -71,277 +72,169 @@ class ClaudeCodeAdapter {
      * Detect running Claude Code agents
      */
     async detectAgents() {
-        const claudeProcesses = this.listClaudeProcesses();
-        if (claudeProcesses.length === 0) {
+        const processes = (0, process_1.enrichProcesses)((0, process_1.listAgentProcesses)('claude'));
+        if (processes.length === 0) {
             return [];
         }
-        const processStartByPid = this.getProcessStartTimes(claudeProcesses.map((p) => p.pid));
-        const sessionScanLimit = this.calculateSessionScanLimit(claudeProcesses.length);
-        const sessions = this.readSessions(sessionScanLimit);
-        if (sessions.length === 0) {
-            return claudeProcesses.map((p) => this.mapProcessOnlyAgent(p, []));
-        }
-        const sortedSessions = [...sessions].sort((a, b) => b.lastActive.getTime() - a.lastActive.getTime());
-        const usedSessionIds = new Set();
-        const assignedPids = new Set();
+        // Step 1: try authoritative PID-file matching for every process
+        const { direct, fallback } = this.tryPidFileMatching(processes);
+        // Step 2: run legacy CWD+birthtime matching only for processes without a PID file
+        const legacySessions = this.discoverSessions(fallback);
+        const legacyMatches = fallback.length > 0 && legacySessions.length > 0
+            ? (0, matching_1.matchProcessesToSessions)(fallback, legacySessions)
+            : [];
+        const matchedPids = new Set([
+            ...direct.map((d) => d.process.pid),
+            ...legacyMatches.map((m) => m.process.pid),
+        ]);
         const agents = [];
-        const modes = ['cwd', 'missing-cwd', 'parent-child'];
-        for (const mode of modes) {
-            this.assignSessionsForMode(mode, claudeProcesses, sortedSessions, usedSessionIds, assignedPids, processStartByPid, agents);
+        // Build agents from direct (PID-file) matches
+        for (const { process: proc, sessionFile } of direct) {
+            const sessionData = this.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
+            if (sessionData) {
+                agents.push(this.mapSessionToAgent(sessionData, proc, sessionFile));
+            }
+            else {
+                matchedPids.delete(proc.pid);
+            }
         }
-        for (const processInfo of claudeProcesses) {
-            if (assignedPids.has(processInfo.pid)) {
-                continue;
+        // Build agents from legacy matches
+        for (const match of legacyMatches) {
+            const sessionData = this.readSession(match.session.filePath, match.session.resolvedCwd);
+            if (sessionData) {
+                agents.push(this.mapSessionToAgent(sessionData, match.process, match.session));
+            }
+            else {
+                matchedPids.delete(match.process.pid);
+            }
+        }
+        // Any process with no match (direct or legacy) appears as IDLE
+        for (const proc of processes) {
+            if (!matchedPids.has(proc.pid)) {
+                agents.push(this.mapProcessOnlyAgent(proc));
             }
-            assignedPids.add(processInfo.pid);
-            agents.push(this.mapProcessOnlyAgent(processInfo, agents));
         }
         return agents;
     }
-    listClaudeProcesses() {
-        return (0, process_1.listProcesses)({ namePattern: 'claude' }).filter((p) => this.canHandle(p));
-    }
-    calculateSessionScanLimit(processCount) {
-        return Math.min(Math.max(processCount * ClaudeCodeAdapter.SESSION_SCAN_MULTIPLIER, ClaudeCodeAdapter.MIN_SESSION_SCAN), ClaudeCodeAdapter.MAX_SESSION_SCAN);
-    }
-    assignSessionsForMode(mode, claudeProcesses, sessions, usedSessionIds, assignedPids, processStartByPid, agents) {
-        for (const processInfo of claudeProcesses) {
-            if (assignedPids.has(processInfo.pid)) {
+    /**
+     * Discover session files for the given processes.
+     *
+     * For each unique process CWD, encodes it to derive the expected
+     * ~/.claude/projects/<encoded>/ directory, then gets session file birthtimes
+     * via a single batched stat call across all directories.
+     */
+    discoverSessions(processes) {
+        // Collect valid project dirs and map them back to their CWD
+        const dirToCwd = new Map();
+        for (const proc of processes) {
+            if (!proc.cwd)
                 continue;
+            const projectDir = this.getProjectDir(proc.cwd);
+            if (dirToCwd.has(projectDir))
+                continue;
+            try {
+                if (!fs.statSync(projectDir).isDirectory())
+                    continue;
             }
-            const session = this.selectBestSession(processInfo, sessions, usedSessionIds, processStartByPid, mode);
-            if (!session) {
+            catch {
                 continue;
             }
-            usedSessionIds.add(session.sessionId);
-            assignedPids.add(processInfo.pid);
-            agents.push(this.mapSessionToAgent(session, processInfo, agents));
+            dirToCwd.set(projectDir, proc.cwd);
+        }
+        if (dirToCwd.size === 0)
+            return [];
+        // Single batched stat call across all directories
+        const files = (0, session_1.batchGetSessionFileBirthtimes)([...dirToCwd.keys()]);
+        // Set resolvedCwd based on which project dir the file belongs to
+        for (const file of files) {
+            file.resolvedCwd = dirToCwd.get(file.projectDir) || '';
         }
+        return files;
     }
-    mapSessionToAgent(session, processInfo, existingAgents) {
+    /**
+     * Attempt to match each process to its session via ~/.claude/sessions/<pid>.json.
+     *
+     * Returns:
+     *   direct  — processes matched authoritatively via PID file
+     *   fallback — processes with no valid PID file (sent to legacy matching)
+     *
+     * Per-process fallback triggers on: file absent, malformed JSON,
+     * stale startedAt (>60 s from proc.startTime), or missing JSONL.
+     */
+    tryPidFileMatching(processes) {
+        const direct = [];
+        const fallback = [];
+        for (const proc of processes) {
+            const pidFilePath = path.join(this.sessionsDir, `${proc.pid}.json`);
+            try {
+                const entry = JSON.parse(fs.readFileSync(pidFilePath, 'utf-8'));
+                // Stale-file guard: reject PID files from a previous process with the same PID
+                if (proc.startTime) {
+                    const deltaMs = Math.abs(proc.startTime.getTime() - entry.startedAt);
+                    if (deltaMs > 60000) {
+                        fallback.push(proc);
+                        continue;
+                    }
+                }
+                const projectDir = this.getProjectDir(entry.cwd);
+                const jsonlPath = path.join(projectDir, `${entry.sessionId}.jsonl`);
+                if (!fs.existsSync(jsonlPath)) {
+                    fallback.push(proc);
+                    continue;
+                }
+                direct.push({
+                    process: proc,
+                    sessionFile: {
+                        sessionId: entry.sessionId,
+                        filePath: jsonlPath,
+                        projectDir,
+                        birthtimeMs: entry.startedAt,
+                        resolvedCwd: entry.cwd,
+                    },
+                });
+            }
+            catch {
+                // PID file absent, unreadable, or malformed — fall back per-process
+                fallback.push(proc);
+            }
+        }
+        return { direct, fallback };
+    }
+    /**
+     * Derive the Claude Code project directory for a given CWD.
+     *
+     * Claude Code encodes paths by replacing '/' with '-':
+     * /Users/foo/bar → ~/.claude/projects/-Users-foo-bar/
+     */
+    getProjectDir(cwd) {
+        const encoded = cwd.replace(/\//g, '-');
+        return path.join(this.projectsDir, encoded);
+    }
+    mapSessionToAgent(session, processInfo, sessionFile) {
         return {
-            name: this.generateAgentName(session, existingAgents),
+            name: (0, matching_1.generateAgentName)(processInfo.cwd, processInfo.pid),
             type: this.type,
             status: this.determineStatus(session),
             summary: session.lastUserMessage || 'Session started',
             pid: processInfo.pid,
-            projectPath: session.projectPath || processInfo.cwd || '',
-            sessionId: session.sessionId,
+            projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',
+            sessionId: sessionFile.sessionId,
             slug: session.slug,
             lastActive: session.lastActive,
         };
     }
-    mapProcessOnlyAgent(processInfo, existingAgents) {
-        const processCwd = processInfo.cwd || '';
-        const projectName = path.basename(processCwd) || 'claude';
-        const hasDuplicate = existingAgents.some((a) => a.projectPath === processCwd);
+    mapProcessOnlyAgent(processInfo) {
         return {
-            name: hasDuplicate ? `${projectName} (pid-${processInfo.pid})` : projectName,
+            name: (0, matching_1.generateAgentName)(processInfo.cwd || '', processInfo.pid),
             type: this.type,
             status: AgentAdapter_1.AgentStatus.IDLE,
             summary: 'Unknown',
             pid: processInfo.pid,
-            projectPath: processCwd,
+            projectPath: processInfo.cwd || '',
             sessionId: `pid-${processInfo.pid}`,
             lastActive: new Date(),
         };
     }
-    selectBestSession(processInfo, sessions, usedSessionIds, processStartByPid, mode) {
-        const candidates = this.filterCandidateSessions(processInfo, sessions, usedSessionIds, mode);
-        if (candidates.length === 0) {
-            return undefined;
-        }
-        const processStart = processStartByPid.get(processInfo.pid);
-        if (!processStart) {
-            return candidates.sort((a, b) => b.lastActive.getTime() - a.lastActive.getTime())[0];
-        }
-        const best = this.rankCandidatesByStartTime(candidates, processStart)[0];
-        if (!best) {
-            return undefined;
-        }
-        // In early modes (cwd/missing-cwd), defer assignment when the best
-        // candidate is outside start-time tolerance — a closer match may
-        // exist in parent-child mode (e.g., worktree sessions).
-        if (mode !== 'parent-child') {
-            const diffMs = Math.abs(best.sessionStart.getTime() - processStart.getTime());
-            if (diffMs > ClaudeCodeAdapter.PROCESS_SESSION_TIME_TOLERANCE_MS) {
-                return undefined;
-            }
-        }
-        return best;
-    }
-    filterCandidateSessions(processInfo, sessions, usedSessionIds, mode) {
-        return sessions.filter((session) => {
-            if (usedSessionIds.has(session.sessionId)) {
-                return false;
-            }
-            if (mode === 'cwd') {
-                return (this.pathEquals(processInfo.cwd, session.projectPath) ||
-                    this.pathEquals(processInfo.cwd, session.lastCwd));
-            }
-            if (mode === 'missing-cwd') {
-                return !session.projectPath;
-            }
-            // parent-child mode: match if process CWD equals, is under, or is
-            // a parent of session project/lastCwd.  This also catches exact CWD
-            // matches that were deferred from `cwd` mode due to start-time tolerance.
-            return (this.pathRelated(processInfo.cwd, session.projectPath) ||
-                this.pathRelated(processInfo.cwd, session.lastCwd));
-        });
-    }
-    rankCandidatesByStartTime(candidates, processStart) {
-        const toleranceMs = ClaudeCodeAdapter.PROCESS_SESSION_TIME_TOLERANCE_MS;
-        return candidates
-            .map((session) => {
-            const diffMs = Math.abs(session.sessionStart.getTime() - processStart.getTime());
-            const outsideTolerance = diffMs > toleranceMs ? 1 : 0;
-            return {
-                session,
-                rank: outsideTolerance,
-                diffMs,
-                recency: session.lastActive.getTime(),
-            };
-        })
-            .sort((a, b) => {
-            if (a.rank !== b.rank)
-                return a.rank - b.rank;
-            // Within tolerance (rank 0): prefer most recently active session.
-            // The exact diff is noise — a 6s vs 45s difference is meaningless,
-            // but the session with recent activity is more likely the real one.
-            if (a.rank === 0)
-                return b.recency - a.recency;
-            // Outside tolerance: prefer smallest time difference, then recency.
-            if (a.diffMs !== b.diffMs)
-                return a.diffMs - b.diffMs;
-            return b.recency - a.recency;
-        })
-            .map((ranked) => ranked.session);
-    }
-    getProcessStartTimes(pids) {
-        if (pids.length === 0 || process.env.JEST_WORKER_ID) {
-            return new Map();
-        }
-        try {
-            const output = (0, child_process_1.execSync)(`ps -o pid=,etime= -p ${pids.join(',')}`, { encoding: 'utf-8' });
-            const nowMs = Date.now();
-            const startTimes = new Map();
-            for (const rawLine of output.split('\n')) {
-                const line = rawLine.trim();
-                if (!line)
-                    continue;
-                const parts = line.split(/\s+/);
-                if (parts.length < 2)
-                    continue;
-                const pid = Number.parseInt(parts[0], 10);
-                const elapsedSeconds = this.parseElapsedSeconds(parts[1]);
-                if (!Number.isFinite(pid) || elapsedSeconds === null)
-                    continue;
-                startTimes.set(pid, new Date(nowMs - elapsedSeconds * 1000));
-            }
-            return startTimes;
-        }
-        catch {
-            return new Map();
-        }
-    }
-    parseElapsedSeconds(etime) {
-        const match = etime
-            .trim()
-            .match(/^(?:(\d+)-)?(?:(\d{1,2}):)?(\d{1,2}):(\d{2})$/);
-        if (!match) {
-            return null;
-        }
-        const days = Number.parseInt(match[1] || '0', 10);
-        const hours = Number.parseInt(match[2] || '0', 10);
-        const minutes = Number.parseInt(match[3] || '0', 10);
-        const seconds = Number.parseInt(match[4] || '0', 10);
-        return ((days * 24 + hours) * 60 + minutes) * 60 + seconds;
-    }
-    /**
-     * Read Claude Code sessions with bounded scanning
-     */
-    readSessions(limit) {
-        const sessionFiles = this.findSessionFiles(limit);
-        const sessions = [];
-        for (const file of sessionFiles) {
-            try {
-                const session = this.readSession(file.filePath, file.projectPath);
-                if (session) {
-                    sessions.push(session);
-                }
-            }
-            catch (error) {
-                console.error(`Failed to parse Claude session ${file.filePath}:`, error);
-            }
-        }
-        return sessions;
-    }
-    /**
-     * Find session files bounded by mtime, sorted most-recent first
-     */
-    findSessionFiles(limit) {
-        if (!fs.existsSync(this.projectsDir)) {
-            return [];
-        }
-        const files = [];
-        for (const dirName of fs.readdirSync(this.projectsDir)) {
-            if (dirName.startsWith('.')) {
-                continue;
-            }
-            const projectDir = path.join(this.projectsDir, dirName);
-            try {
-                if (!fs.statSync(projectDir).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            const indexPath = path.join(projectDir, 'sessions-index.json');
-            const index = (0, file_1.readJson)(indexPath);
-            const projectPath = index?.originalPath || '';
-            for (const entry of fs.readdirSync(projectDir)) {
-                if (!entry.endsWith('.jsonl')) {
-                    continue;
-                }
-                const filePath = path.join(projectDir, entry);
-                try {
-                    files.push({
-                        filePath,
-                        projectPath,
-                        mtimeMs: fs.statSync(filePath).mtimeMs,
-                    });
-                }
-                catch {
-                    continue;
-                }
-            }
-        }
-        // Ensure breadth: include at least the most recent session per project,
-        // then fill remaining slots with globally most-recent sessions.
-        const sorted = files.sort((a, b) => b.mtimeMs - a.mtimeMs);
-        const result = [];
-        const seenProjects = new Set();
-        // First pass: one most-recent session per project directory
-        for (const file of sorted) {
-            const projDir = path.dirname(file.filePath);
-            if (!seenProjects.has(projDir)) {
-                seenProjects.add(projDir);
-                result.push(file);
-            }
-        }
-        // Second pass: fill remaining slots with globally most-recent
-        if (result.length < limit) {
-            const resultSet = new Set(result.map((f) => f.filePath));
-            for (const file of sorted) {
-                if (result.length >= limit)
-                    break;
-                if (!resultSet.has(file.filePath)) {
-                    result.push(file);
-                }
-            }
-        }
-        return result.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit);
-    }
     /**
      * Parse a single session file into ClaudeSession
      */
@@ -461,42 +354,6 @@ class ClaudeCodeAdapter {
         }
         return AgentAdapter_1.AgentStatus.UNKNOWN;
     }
-    /**
-     * Generate unique agent name
-     * Uses project basename, appends slug if multiple sessions for same project
-     */
-    generateAgentName(session, existingAgents) {
-        const projectName = path.basename(session.projectPath) || 'claude';
-        const sameProjectAgents = existingAgents.filter((a) => a.projectPath === session.projectPath);
-        if (sameProjectAgents.length === 0) {
-            return projectName;
-        }
-        if (session.slug) {
-            const slugPart = session.slug.includes('-')
-                ? session.slug.split('-')[0]
-                : session.slug.slice(0, 8);
-            return `${projectName} (${slugPart})`;
-        }
-        return `${projectName} (${session.sessionId.slice(0, 8)})`;
-    }
-    /** Check if two paths are equal, or one is a parent/child of the other. */
-    pathRelated(a, b) {
-        return this.pathEquals(a, b) || this.isChildPath(a, b) || this.isChildPath(b, a);
-    }
-    pathEquals(a, b) {
-        if (!a || !b) {
-            return false;
-        }
-        return this.normalizePath(a) === this.normalizePath(b);
-    }
-    isChildPath(child, parent) {
-        if (!child || !parent) {
-            return false;
-        }
-        const normalizedChild = this.normalizePath(child);
-        const normalizedParent = this.normalizePath(parent);
-        return normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
-    }
     /**
      * Extract meaningful text from a user message content.
      * Handles string and array formats, skill command expansion, and noise filtering.
@@ -563,19 +420,6 @@ class ClaudeCodeAdapter {
     isMetadataEntryType(type) {
         return type === 'last-prompt' || type === 'file-history-snapshot';
     }
-    normalizePath(value) {
-        const resolved = path.resolve(value);
-        if (resolved.length > 1 && resolved.endsWith(path.sep)) {
-            return resolved.slice(0, -1);
-        }
-        return resolved;
-    }
 }
 exports.ClaudeCodeAdapter = ClaudeCodeAdapter;
-/** Limit session parsing per run to keep list latency bounded. */
-ClaudeCodeAdapter.MIN_SESSION_SCAN = 12;
-ClaudeCodeAdapter.MAX_SESSION_SCAN = 40;
-ClaudeCodeAdapter.SESSION_SCAN_MULTIPLIER = 4;
-/** Matching tolerance between process start time and session start time. */
-ClaudeCodeAdapter.PROCESS_SESSION_TIME_TOLERANCE_MS = 2 * 60 * 1000;
 //# sourceMappingURL=ClaudeCodeAdapter.js.map