@ai-devkit/agent-manager 0.3.0 → 0.4.0

package/src/adapters/ClaudeCodeAdapter.ts

@@ -1,16 +1,10 @@
-/**
- * Claude Code Adapter
- * 
- * Detects running Claude Code agents by reading session files
- * from ~/.claude/ directory and correlating with running processes.
- */
-
 import * as fs from 'fs';
 import * as path from 'path';
+import { execSync } from 'child_process';
 import type { AgentAdapter, AgentInfo, ProcessInfo } from './AgentAdapter';
 import { AgentStatus } from './AgentAdapter';
 import { listProcesses } from '../utils/process';
-import { readLastLines, readJsonLines, readJson } from '../utils/file';
+import { readJson } from '../utils/file';
 
 /**
  * Structure of ~/.claude/projects/{path}/sessions-index.json
@@ -19,43 +13,21 @@ interface SessionsIndex {
     originalPath: string;
 }
 
-enum SessionEntryType {
-    ASSISTANT = 'assistant',
-    USER = 'user',
-    PROGRESS = 'progress',
-    THINKING = 'thinking',
-    SYSTEM = 'system',
-    MESSAGE = 'message',
-    TEXT = 'text',
-}
-
 /**
  * Entry in session JSONL file
  */
 interface SessionEntry {
-    type?: SessionEntryType;
+    type?: string;
     timestamp?: string;
     slug?: string;
     cwd?: string;
-    sessionId?: string;
     message?: {
-        content?: Array<{
+        content?: string | Array<{
             type?: string;
             text?: string;
             content?: string;
         }>;
     };
-    [key: string]: unknown;
-}
-
-/**
- * Entry in ~/.claude/history.jsonl
- */
-interface HistoryEntry {
-    display: string;
-    timestamp: number;
-    project: string;
-    sessionId: string;
 }
 
 /**
@@ -66,135 +38,122 @@ interface ClaudeSession {
     projectPath: string;
     lastCwd?: string;
     slug?: string;
-    sessionLogPath: string;
-    lastEntry?: SessionEntry;
-    lastActive?: Date;
+    sessionStart: Date;
+    lastActive: Date;
+    lastEntryType?: string;
+    isInterrupted: boolean;
+    lastUserMessage?: string;
 }
 
-type SessionMatchMode = 'cwd' | 'project-parent';
+type SessionMatchMode = 'cwd' | 'missing-cwd' | 'parent-child';
 
 /**
  * Claude Code Adapter
- * 
+ *
  * Detects Claude Code agents by:
  * 1. Finding running claude processes
- * 2. Reading session files from ~/.claude/projects/
- * 3. Matching sessions to processes via CWD
- * 4. Extracting status from session JSONL
- * 5. Extracting summary from history.jsonl
+ * 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
+ * 5. Extracting summary from last user message in session JSONL
  */
 export class ClaudeCodeAdapter implements AgentAdapter {
     readonly type = 'claude' as const;
 
-    /** Threshold in minutes before considering a session idle */
-    private static readonly IDLE_THRESHOLD_MINUTES = 5;
+    /** Limit session parsing per run to keep list latency bounded. */
+    private static readonly MIN_SESSION_SCAN = 12;
+    private static readonly MAX_SESSION_SCAN = 40;
+    private static readonly SESSION_SCAN_MULTIPLIER = 4;
+    /** Matching tolerance between process start time and session start time. */
+    private static readonly PROCESS_SESSION_TIME_TOLERANCE_MS = 2 * 60 * 1000;
 
-    private claudeDir: string;
     private projectsDir: string;
-    private historyPath: string;
 
     constructor() {
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        this.claudeDir = path.join(homeDir, '.claude');
-        this.projectsDir = path.join(this.claudeDir, 'projects');
-        this.historyPath = path.join(this.claudeDir, 'history.jsonl');
+        this.projectsDir = path.join(homeDir, '.claude', 'projects');
     }
 
     /**
      * Check if this adapter can handle a given process
      */
     canHandle(processInfo: ProcessInfo): boolean {
-        return processInfo.command.toLowerCase().includes('claude');
+        return this.isClaudeExecutable(processInfo.command);
+    }
+
+    private isClaudeExecutable(command: string): boolean {
+        const executable = command.trim().split(/\s+/)[0] || '';
+        const base = path.basename(executable).toLowerCase();
+        return base === 'claude' || base === 'claude.exe';
     }
 
     /**
      * Detect running Claude Code agents
      */
     async detectAgents(): Promise<AgentInfo[]> {
-        const claudeProcesses = listProcesses({ namePattern: 'claude' }).filter((processInfo) =>
-            this.canHandle(processInfo),
-        );
-
+        const claudeProcesses = this.listClaudeProcesses();
         if (claudeProcesses.length === 0) {
             return [];
         }
 
-        const sessions = this.readSessions();
-        const history = this.readHistory();
-        const historyByProjectPath = this.indexHistoryByProjectPath(history);
-        const historyBySessionId = new Map<string, HistoryEntry>();
-        for (const entry of history) {
-            historyBySessionId.set(entry.sessionId, entry);
-        }
+        const processStartByPid = this.getProcessStartTimes(
+            claudeProcesses.map((p) => p.pid),
+        );
+        const sessionScanLimit = this.calculateSessionScanLimit(claudeProcesses.length);
+        const sessions = this.readSessions(sessionScanLimit);
 
-        const sortedSessions = [...sessions].sort((a, b) => {
-            const timeA = a.lastActive?.getTime() || 0;
-            const timeB = b.lastActive?.getTime() || 0;
-            return timeB - timeA;
-        });
+        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<string>();
         const assignedPids = new Set<number>();
         const agents: AgentInfo[] = [];
 
-        this.assignSessionsForMode(
-            'cwd',
-            claudeProcesses,
-            sortedSessions,
-            usedSessionIds,
-            assignedPids,
-            historyBySessionId,
-            agents,
-        );
-        this.assignHistoryEntriesForExactProcessCwd(
-            claudeProcesses,
-            assignedPids,
-            historyByProjectPath,
-            usedSessionIds,
-            agents,
-        );
-        this.assignSessionsForMode(
-            'project-parent',
-            claudeProcesses,
-            sortedSessions,
-            usedSessionIds,
-            assignedPids,
-            historyBySessionId,
-            agents,
-        );
+        const modes: SessionMatchMode[] = ['cwd', 'missing-cwd', 'parent-child'];
+        for (const mode of modes) {
+            this.assignSessionsForMode(
+                mode,
+                claudeProcesses,
+                sortedSessions,
+                usedSessionIds,
+                assignedPids,
+                processStartByPid,
+                agents,
+            );
+        }
+
         for (const processInfo of claudeProcesses) {
             if (assignedPids.has(processInfo.pid)) {
                 continue;
             }
 
             assignedPids.add(processInfo.pid);
-            agents.push(this.mapProcessOnlyAgent(processInfo, agents, historyByProjectPath, usedSessionIds));
+            agents.push(this.mapProcessOnlyAgent(processInfo, agents));
         }
 
         return agents;
     }
 
-    private assignHistoryEntriesForExactProcessCwd(
-        claudeProcesses: ProcessInfo[],
-        assignedPids: Set<number>,
-        historyByProjectPath: Map<string, HistoryEntry[]>,
-        usedSessionIds: Set<string>,
-        agents: AgentInfo[],
-    ): void {
-        for (const processInfo of claudeProcesses) {
-            if (assignedPids.has(processInfo.pid)) {
-                continue;
-            }
-
-            const historyEntry = this.selectHistoryForProcess(processInfo.cwd || '', historyByProjectPath, usedSessionIds);
-            if (!historyEntry) {
-                continue;
-            }
+    private listClaudeProcesses(): ProcessInfo[] {
+        return listProcesses({ namePattern: 'claude' }).filter((p) =>
+            this.canHandle(p),
+        );
+    }
 
-            assignedPids.add(processInfo.pid);
-            usedSessionIds.add(historyEntry.sessionId);
-            agents.push(this.mapHistoryToAgent(processInfo, historyEntry, agents));
-        }
+    private calculateSessionScanLimit(processCount: number): number {
+        return Math.min(
+            Math.max(
+                processCount * ClaudeCodeAdapter.SESSION_SCAN_MULTIPLIER,
+                ClaudeCodeAdapter.MIN_SESSION_SCAN,
+            ),
+            ClaudeCodeAdapter.MAX_SESSION_SCAN,
+        );
     }
 
     private assignSessionsForMode(
@@ -203,7 +162,7 @@ export class ClaudeCodeAdapter implements AgentAdapter {
         sessions: ClaudeSession[],
         usedSessionIds: Set<string>,
         assignedPids: Set<number>,
-        historyBySessionId: Map<string, HistoryEntry>,
+        processStartByPid: Map<number, Date>,
         agents: AgentInfo[],
     ): void {
         for (const processInfo of claudeProcesses) {
@@ -211,321 +170,457 @@ export class ClaudeCodeAdapter implements AgentAdapter {
                 continue;
             }
 
-            const session = this.selectBestSession(processInfo, sessions, usedSessionIds, mode);
+            const session = this.selectBestSession(
+                processInfo,
+                sessions,
+                usedSessionIds,
+                processStartByPid,
+                mode,
+            );
             if (!session) {
                 continue;
             }
 
             usedSessionIds.add(session.sessionId);
             assignedPids.add(processInfo.pid);
-            agents.push(this.mapSessionToAgent(session, processInfo, historyBySessionId, agents));
+            agents.push(this.mapSessionToAgent(session, processInfo, agents));
         }
     }
 
-    private selectBestSession(
-        processInfo: ProcessInfo,
-        sessions: ClaudeSession[],
-        usedSessionIds: Set<string>,
-        mode: SessionMatchMode,
-    ): ClaudeSession | null {
-        const candidates = sessions.filter((session) => {
-            if (usedSessionIds.has(session.sessionId)) {
-                return false;
-            }
-
-            if (mode === 'cwd') {
-                return this.pathEquals(processInfo.cwd, session.lastCwd)
-                    || this.pathEquals(processInfo.cwd, session.projectPath);
-            }
-
-            if (mode === 'project-parent') {
-                return this.isChildPath(processInfo.cwd, session.projectPath)
-                    || this.isChildPath(processInfo.cwd, session.lastCwd);
-            }
-
-            return false;
-        });
-
-        if (candidates.length === 0) {
-            return null;
-        }
-
-        if (mode !== 'project-parent') {
-            return candidates[0];
-        }
-
-        return candidates.sort((a, b) => {
-            const depthA = Math.max(this.pathDepth(a.projectPath), this.pathDepth(a.lastCwd));
-            const depthB = Math.max(this.pathDepth(b.projectPath), this.pathDepth(b.lastCwd));
-            if (depthA !== depthB) {
-                return depthB - depthA;
-            }
-
-            const lastActiveA = a.lastActive?.getTime() || 0;
-            const lastActiveB = b.lastActive?.getTime() || 0;
-            return lastActiveB - lastActiveA;
-        })[0];
-    }
-
     private mapSessionToAgent(
         session: ClaudeSession,
         processInfo: ProcessInfo,
-        historyBySessionId: Map<string, HistoryEntry>,
         existingAgents: AgentInfo[],
     ): AgentInfo {
-        const historyEntry = historyBySessionId.get(session.sessionId);
-
         return {
             name: this.generateAgentName(session, existingAgents),
             type: this.type,
             status: this.determineStatus(session),
-            summary: historyEntry?.display || 'Session started',
+            summary: session.lastUserMessage || 'Session started',
             pid: processInfo.pid,
             projectPath: session.projectPath || processInfo.cwd || '',
             sessionId: session.sessionId,
             slug: session.slug,
-            lastActive: session.lastActive || new Date(),
+            lastActive: session.lastActive,
         };
     }
 
     private mapProcessOnlyAgent(
         processInfo: ProcessInfo,
         existingAgents: AgentInfo[],
-        historyByProjectPath: Map<string, HistoryEntry[]>,
-        usedSessionIds: Set<string>,
     ): AgentInfo {
-        const projectPath = processInfo.cwd || '';
-        const historyEntry = this.selectHistoryForProcess(projectPath, historyByProjectPath, usedSessionIds);
-        const sessionId = historyEntry?.sessionId || `pid-${processInfo.pid}`;
-        const lastActive = historyEntry ? new Date(historyEntry.timestamp) : new Date();
-        if (historyEntry) {
-            usedSessionIds.add(historyEntry.sessionId);
-        }
-
-        const processSession: ClaudeSession = {
-            sessionId,
-            projectPath,
-            lastCwd: projectPath,
-            sessionLogPath: '',
-            lastActive,
-        };
+        const processCwd = processInfo.cwd || '';
+        const projectName = path.basename(processCwd) || 'claude';
+        const hasDuplicate = existingAgents.some((a) => a.projectPath === processCwd);
 
         return {
-            name: this.generateAgentName(processSession, existingAgents),
+            name: hasDuplicate ? `${projectName} (pid-${processInfo.pid})` : projectName,
             type: this.type,
-            status: AgentStatus.RUNNING,
-            summary: historyEntry?.display || 'Claude process running',
+            status: AgentStatus.IDLE,
+            summary: 'Unknown',
             pid: processInfo.pid,
-            projectPath,
-            sessionId: processSession.sessionId,
-            lastActive: processSession.lastActive || new Date(),
+            projectPath: processCwd,
+            sessionId: `pid-${processInfo.pid}`,
+            lastActive: new Date(),
         };
     }
 
-    private mapHistoryToAgent(
+    private selectBestSession(
         processInfo: ProcessInfo,
-        historyEntry: HistoryEntry,
-        existingAgents: AgentInfo[],
-    ): AgentInfo {
-        const projectPath = processInfo.cwd || historyEntry.project;
-        const historySession: ClaudeSession = {
-            sessionId: historyEntry.sessionId,
-            projectPath,
-            lastCwd: projectPath,
-            sessionLogPath: '',
-            lastActive: new Date(historyEntry.timestamp),
-        };
+        sessions: ClaudeSession[],
+        usedSessionIds: Set<string>,
+        processStartByPid: Map<number, Date>,
+        mode: SessionMatchMode,
+    ): ClaudeSession | undefined {
+        const candidates = this.filterCandidateSessions(
+            processInfo,
+            sessions,
+            usedSessionIds,
+            mode,
+        );
 
-        return {
-            name: this.generateAgentName(historySession, existingAgents),
-            type: this.type,
-            status: AgentStatus.RUNNING,
-            summary: historyEntry.display || 'Claude process running',
-            pid: processInfo.pid,
-            projectPath,
-            sessionId: historySession.sessionId,
-            lastActive: historySession.lastActive || new Date(),
-        };
-    }
+        if (candidates.length === 0) {
+            return undefined;
+        }
 
-    private indexHistoryByProjectPath(historyEntries: HistoryEntry[]): Map<string, HistoryEntry[]> {
-        const grouped = new Map<string, HistoryEntry[]>();
+        const processStart = processStartByPid.get(processInfo.pid);
+        if (!processStart) {
+            return candidates.sort(
+                (a, b) => b.lastActive.getTime() - a.lastActive.getTime(),
+            )[0];
+        }
 
-        for (const entry of historyEntries) {
-            const key = this.normalizePath(entry.project);
-            const list = grouped.get(key) || [];
-            list.push(entry);
-            grouped.set(key, list);
+        const best = this.rankCandidatesByStartTime(candidates, processStart)[0];
+        if (!best) {
+            return undefined;
         }
 
-        for (const [key, list] of grouped.entries()) {
-            grouped.set(
-                key,
-                [...list].sort((a, b) => b.timestamp - a.timestamp),
+        // 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 grouped;
+        return best;
     }
 
-    private selectHistoryForProcess(
-        processCwd: string,
-        historyByProjectPath: Map<string, HistoryEntry[]>,
+    private filterCandidateSessions(
+        processInfo: ProcessInfo,
+        sessions: ClaudeSession[],
         usedSessionIds: Set<string>,
-    ): HistoryEntry | undefined {
-        if (!processCwd) {
-            return undefined;
+        mode: SessionMatchMode,
+    ): ClaudeSession[] {
+        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)
+            );
+        });
+    }
+
+    private rankCandidatesByStartTime(
+        candidates: ClaudeSession[],
+        processStart: Date,
+    ): ClaudeSession[] {
+        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);
+    }
+
+    private getProcessStartTimes(pids: number[]): Map<number, Date> {
+        if (pids.length === 0 || process.env.JEST_WORKER_ID) {
+            return new Map();
         }
 
-        const candidates = historyByProjectPath.get(this.normalizePath(processCwd)) || [];
-        return candidates.find((entry) => !usedSessionIds.has(entry.sessionId));
+        try {
+            const output = execSync(
+                `ps -o pid=,etime= -p ${pids.join(',')}`,
+                { encoding: 'utf-8' },
+            );
+            const nowMs = Date.now();
+            const startTimes = new Map<number, Date>();
+
+            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();
+        }
+    }
+
+    private parseElapsedSeconds(etime: string): number | null {
+        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 all Claude Code sessions
+     * Read Claude Code sessions with bounded scanning
      */
-    private readSessions(): ClaudeSession[] {
+    private readSessions(limit: number): ClaudeSession[] {
+        const sessionFiles = this.findSessionFiles(limit);
+        const sessions: ClaudeSession[] = [];
+
+        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
+     */
+    private findSessionFiles(
+        limit: number,
+    ): Array<{ filePath: string; projectPath: string; mtimeMs: number }> {
         if (!fs.existsSync(this.projectsDir)) {
             return [];
         }
 
-        const sessions: ClaudeSession[] = [];
-        const projectDirs = fs.readdirSync(this.projectsDir);
+        const files: Array<{
+            filePath: string;
+            projectPath: string;
+            mtimeMs: number;
+        }> = [];
 
-        for (const dirName of projectDirs) {
+        for (const dirName of fs.readdirSync(this.projectsDir)) {
             if (dirName.startsWith('.')) {
                 continue;
             }
 
             const projectDir = path.join(this.projectsDir, dirName);
-            if (!fs.statSync(projectDir).isDirectory()) {
+            try {
+                if (!fs.statSync(projectDir).isDirectory()) continue;
+            } catch {
                 continue;
             }
 
-            // Read sessions-index.json to get original project path
             const indexPath = path.join(projectDir, 'sessions-index.json');
-            if (!fs.existsSync(indexPath)) {
-                continue;
-            }
-
-            const sessionsIndex = readJson<SessionsIndex>(indexPath);
-            if (!sessionsIndex) {
-                console.error(`Failed to parse ${indexPath}`);
-                continue;
-            }
+            const index = readJson<SessionsIndex>(indexPath);
+            const projectPath = index?.originalPath || '';
 
-            const sessionFiles = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
-
-            for (const sessionFile of sessionFiles) {
-                const sessionId = sessionFile.replace('.jsonl', '');
-                const sessionLogPath = path.join(projectDir, sessionFile);
+            for (const entry of fs.readdirSync(projectDir)) {
+                if (!entry.endsWith('.jsonl')) {
+                    continue;
+                }
 
+                const filePath = path.join(projectDir, entry);
                 try {
-                    const sessionData = this.readSessionLog(sessionLogPath);
-
-                    sessions.push({
-                        sessionId,
-                        projectPath: sessionsIndex.originalPath,
-                        lastCwd: sessionData.lastCwd,
-                        slug: sessionData.slug,
-                        sessionLogPath,
-                        lastEntry: sessionData.lastEntry,
-                        lastActive: sessionData.lastActive,
+                    files.push({
+                        filePath,
+                        projectPath,
+                        mtimeMs: fs.statSync(filePath).mtimeMs,
                     });
-                } catch (error) {
-                    console.error(`Failed to read session ${sessionId}:`, error);
+                } catch {
                     continue;
                 }
             }
         }
 
-        return sessions;
+        // 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: typeof files = [];
+        const seenProjects = new Set<string>();
+
+        // 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);
     }
 
     /**
-     * Read a session JSONL file
-     * Only reads last 100 lines for performance with large files
+     * Parse a single session file into ClaudeSession
      */
-    private readSessionLog(logPath: string): {
-        slug?: string;
-        lastEntry?: SessionEntry;
-        lastActive?: Date;
-        lastCwd?: string;
-    } {
-        const lines = readLastLines(logPath, 100);
+    private readSession(
+        filePath: string,
+        projectPath: string,
+    ): ClaudeSession | null {
+        const sessionId = path.basename(filePath, '.jsonl');
 
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            return null;
+        }
+
+        const allLines = content.trim().split('\n');
+        if (allLines.length === 0) {
+            return null;
+        }
+
+        // Parse first line for sessionStart.
+        // Claude Code may emit a "file-history-snapshot" as the first entry, which
+        // stores its timestamp inside "snapshot.timestamp" rather than at the root.
+        let sessionStart: Date | null = null;
+        try {
+            const firstEntry = JSON.parse(allLines[0]);
+            const rawTs: string | undefined =
+                firstEntry.timestamp || firstEntry.snapshot?.timestamp;
+            if (rawTs) {
+                const ts = new Date(rawTs);
+                if (!Number.isNaN(ts.getTime())) {
+                    sessionStart = ts;
+                }
+            }
+        } catch {
+            /* skip */
+        }
+
+        // Parse all lines for session state (file already in memory)
         let slug: string | undefined;
-        let lastEntry: SessionEntry | undefined;
+        let lastEntryType: string | undefined;
         let lastActive: Date | undefined;
         let lastCwd: string | undefined;
+        let isInterrupted = false;
+        let lastUserMessage: string | undefined;
 
-        for (const line of lines) {
+        for (const line of allLines) {
             try {
                 const entry: SessionEntry = JSON.parse(line);
 
-                if (entry.slug && !slug) {
-                    slug = entry.slug;
+                if (entry.timestamp) {
+                    const ts = new Date(entry.timestamp);
+                    if (!Number.isNaN(ts.getTime())) {
+                        lastActive = ts;
+                    }
                 }
 
-                lastEntry = entry;
-
-                if (entry.timestamp) {
-                    lastActive = new Date(entry.timestamp);
+                if (entry.slug && !slug) {
+                    slug = entry.slug;
                 }
 
                 if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {
                     lastCwd = entry.cwd;
                 }
-            } catch (error) {
+
+                if (entry.type && !this.isMetadataEntryType(entry.type)) {
+                    lastEntryType = entry.type;
+
+                    if (entry.type === 'user') {
+                        const msgContent = entry.message?.content;
+                        isInterrupted =
+                            Array.isArray(msgContent) &&
+                            msgContent.some(
+                                (c) =>
+                                    (c.type === 'text' &&
+                                        c.text?.includes('[Request interrupted')) ||
+                                    (c.type === 'tool_result' &&
+                                        c.content?.includes('[Request interrupted')),
+                            );
+
+                        // Extract user message text for summary fallback
+                        const text = this.extractUserMessageText(msgContent);
+                        if (text) {
+                            lastUserMessage = text;
+                        }
+                    } else {
+                        isInterrupted = false;
+                    }
+                }
+            } catch {
                 continue;
             }
         }
 
-        return { slug, lastEntry, lastActive, lastCwd };
-    }
-
-    /**
-     * Read history.jsonl for user prompts
-     * Only reads last 100 lines for performance
-     */
-    private readHistory(): HistoryEntry[] {
-        return readJsonLines<HistoryEntry>(this.historyPath, 100);
+        return {
+            sessionId,
+            projectPath: projectPath || lastCwd || '',
+            lastCwd,
+            slug,
+            sessionStart: sessionStart || lastActive || new Date(),
+            lastActive: lastActive || new Date(),
+            lastEntryType,
+            isInterrupted,
+            lastUserMessage,
+        };
     }
 
     /**
-     * Determine agent status from session entry
+     * Determine agent status from session state
      */
     private determineStatus(session: ClaudeSession): AgentStatus {
-        if (!session.lastEntry) {
+        if (!session.lastEntryType) {
             return AgentStatus.UNKNOWN;
         }
 
-        const entryType = session.lastEntry.type;
-        const lastActive = session.lastActive || new Date(0);
-        const ageMinutes = (Date.now() - lastActive.getTime()) / 1000 / 60;
+        // No age-based IDLE override: every agent in the list is backed by
+        // a running process (found via ps), so the entry type is the best
+        // indicator of actual state.
 
-        if (ageMinutes > ClaudeCodeAdapter.IDLE_THRESHOLD_MINUTES) {
-            return AgentStatus.IDLE;
+        if (session.lastEntryType === 'user') {
+            return session.isInterrupted
+                ? AgentStatus.WAITING
+                : AgentStatus.RUNNING;
         }
 
-        if (entryType === SessionEntryType.USER) {
-            // Check if user interrupted manually - this puts agent back in waiting state
-            const content = session.lastEntry.message?.content;
-            if (Array.isArray(content)) {
-                const isInterrupted = content.some(c =>
-                    (c.type === SessionEntryType.TEXT && c.text?.includes('[Request interrupted')) ||
-                    (c.type === 'tool_result' && c.content?.includes('[Request interrupted'))
-                );
-                if (isInterrupted) return AgentStatus.WAITING;
-            }
+        if (
+            session.lastEntryType === 'progress' ||
+            session.lastEntryType === 'thinking'
+        ) {
             return AgentStatus.RUNNING;
         }
 
-        if (entryType === SessionEntryType.PROGRESS || entryType === SessionEntryType.THINKING) {
-            return AgentStatus.RUNNING;
-        } else if (entryType === SessionEntryType.ASSISTANT) {
+        if (session.lastEntryType === 'assistant') {
             return AgentStatus.WAITING;
-        } else if (entryType === SessionEntryType.SYSTEM) {
+        }
+
+        if (session.lastEntryType === 'system') {
             return AgentStatus.IDLE;
         }
 
@@ -536,30 +631,35 @@ export class ClaudeCodeAdapter implements AgentAdapter {
      * Generate unique agent name
      * Uses project basename, appends slug if multiple sessions for same project
      */
-    private generateAgentName(session: ClaudeSession, existingAgents: AgentInfo[]): string {
+    private generateAgentName(
+        session: ClaudeSession,
+        existingAgents: AgentInfo[],
+    ): string {
         const projectName = path.basename(session.projectPath) || 'claude';
 
         const sameProjectAgents = existingAgents.filter(
-            a => a.projectPath === session.projectPath
+            (a) => a.projectPath === session.projectPath,
         );
 
         if (sameProjectAgents.length === 0) {
             return projectName;
         }
 
-        // Multiple sessions for same project, append slug
         if (session.slug) {
-            // Use first word of slug for brevity (with safety check for format)
             const slugPart = session.slug.includes('-')
                 ? session.slug.split('-')[0]
                 : session.slug.slice(0, 8);
             return `${projectName} (${slugPart})`;
         }
 
-        // No slug available, use session ID prefix
         return `${projectName} (${session.sessionId.slice(0, 8)})`;
     }
 
+    /** Check if two paths are equal, or one is a parent/child of the other. */
+    private pathRelated(a?: string, b?: string): boolean {
+        return this.pathEquals(a, b) || this.isChildPath(a, b) || this.isChildPath(b, a);
+    }
+
     private pathEquals(a?: string, b?: string): boolean {
         if (!a || !b) {
             return false;
@@ -575,23 +675,94 @@ export class ClaudeCodeAdapter implements AgentAdapter {
 
         const normalizedChild = this.normalizePath(child);
         const normalizedParent = this.normalizePath(parent);
-        return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
+        return normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
     }
 
-    private normalizePath(value: string): string {
-        const resolved = path.resolve(value);
-        if (resolved.length > 1 && resolved.endsWith(path.sep)) {
-            return resolved.slice(0, -1);
+    /**
+     * Extract meaningful text from a user message content.
+     * Handles string and array formats, skill command expansion, and noise filtering.
+     */
+    private extractUserMessageText(
+        content: string | Array<{ type?: string; text?: string }> | undefined,
+    ): string | undefined {
+        if (!content) {
+            return undefined;
         }
-        return resolved;
+
+        let raw: string | undefined;
+
+        if (typeof content === 'string') {
+            raw = content.trim();
+        } else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text' && block.text?.trim()) {
+                    raw = block.text.trim();
+                    break;
+                }
+            }
+        }
+
+        if (!raw) {
+            return undefined;
+        }
+
+        // Skill slash-command: extract /command-name and args
+        if (raw.startsWith('<command-message>')) {
+            return this.parseCommandMessage(raw);
+        }
+
+        // Expanded skill content: extract ARGUMENTS line if present, skip otherwise
+        if (raw.startsWith('Base directory for this skill:')) {
+            const argsMatch = raw.match(/\nARGUMENTS:\s*(.+)/);
+            return argsMatch?.[1]?.trim() || undefined;
+        }
+
+        // Filter noise
+        if (this.isNoiseMessage(raw)) {
+            return undefined;
+        }
+
+        return raw;
     }
 
-    private pathDepth(value?: string): number {
-        if (!value) {
-            return 0;
+    /**
+     * Parse a <command-message> string into "/command args" format.
+     */
+    private parseCommandMessage(raw: string): string | undefined {
+        const nameMatch = raw.match(/<command-name>([^<]+)<\/command-name>/);
+        const argsMatch = raw.match(/<command-args>([^<]+)<\/command-args>/);
+        const name = nameMatch?.[1]?.trim();
+        if (!name) {
+            return undefined;
         }
+        const args = argsMatch?.[1]?.trim();
+        return args ? `${name} ${args}` : name;
+    }
+
+    /**
+     * Check if a message is noise (not a meaningful user intent).
+     */
+    private isNoiseMessage(text: string): boolean {
+        return (
+            text.startsWith('[Request interrupted') ||
+            text === 'Tool loaded.' ||
+            text.startsWith('This session is being continued')
+        );
+    }
 
-        return this.normalizePath(value).split(path.sep).filter(Boolean).length;
+    /**
+     * Check if an entry type is metadata (not conversation state).
+     * These should not overwrite lastEntryType used for status determination.
+     */
+    private isMetadataEntryType(type: string): boolean {
+        return type === 'last-prompt' || type === 'file-history-snapshot';
     }
 
+    private normalizePath(value: string): string {
+        const resolved = path.resolve(value);
+        if (resolved.length > 1 && resolved.endsWith(path.sep)) {
+            return resolved.slice(0, -1);
+        }
+        return resolved;
+    }
 }