@ai-devkit/agent-manager 0.3.0 → 0.5.0

package/dist/adapters/ClaudeCodeAdapter.js

@@ -1,10 +1,4 @@
 "use strict";
-/**
- * Claude Code Adapter
- *
- * Detects running Claude Code agents by reading session files
- * from ~/.claude/ directory and correlating with running processes.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -44,389 +38,388 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const AgentAdapter_1 = require("./AgentAdapter");
 const process_1 = require("../utils/process");
-const file_1 = require("../utils/file");
-var SessionEntryType;
-(function (SessionEntryType) {
-    SessionEntryType["ASSISTANT"] = "assistant";
-    SessionEntryType["USER"] = "user";
-    SessionEntryType["PROGRESS"] = "progress";
-    SessionEntryType["THINKING"] = "thinking";
-    SessionEntryType["SYSTEM"] = "system";
-    SessionEntryType["MESSAGE"] = "message";
-    SessionEntryType["TEXT"] = "text";
-})(SessionEntryType || (SessionEntryType = {}));
+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. 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
+ * 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 {
     constructor() {
         this.type = 'claude';
         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');
+        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');
     }
     /**
      * Check if this adapter can handle a given process
      */
     canHandle(processInfo) {
-        return processInfo.command.toLowerCase().includes('claude');
+        return this.isClaudeExecutable(processInfo.command);
+    }
+    isClaudeExecutable(command) {
+        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() {
-        const claudeProcesses = (0, process_1.listProcesses)({ namePattern: 'claude' }).filter((processInfo) => this.canHandle(processInfo));
-        if (claudeProcesses.length === 0) {
+        const processes = (0, process_1.enrichProcesses)((0, process_1.listAgentProcesses)('claude'));
+        if (processes.length === 0) {
             return [];
         }
-        const sessions = this.readSessions();
-        const history = this.readHistory();
-        const historyByProjectPath = this.indexHistoryByProjectPath(history);
-        const historyBySessionId = new Map();
-        for (const entry of history) {
-            historyBySessionId.set(entry.sessionId, entry);
-        }
-        const sortedSessions = [...sessions].sort((a, b) => {
-            const timeA = a.lastActive?.getTime() || 0;
-            const timeB = b.lastActive?.getTime() || 0;
-            return timeB - timeA;
-        });
-        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 = [];
-        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);
-        for (const processInfo of claudeProcesses) {
-            if (assignedPids.has(processInfo.pid)) {
-                continue;
+        // 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);
             }
-            assignedPids.add(processInfo.pid);
-            agents.push(this.mapProcessOnlyAgent(processInfo, agents, historyByProjectPath, usedSessionIds));
         }
-        return agents;
-    }
-    assignHistoryEntriesForExactProcessCwd(claudeProcesses, assignedPids, historyByProjectPath, usedSessionIds, agents) {
-        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));
             }
-            const historyEntry = this.selectHistoryForProcess(processInfo.cwd || '', historyByProjectPath, usedSessionIds);
-            if (!historyEntry) {
-                continue;
+            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);
-            usedSessionIds.add(historyEntry.sessionId);
-            agents.push(this.mapHistoryToAgent(processInfo, historyEntry, agents));
         }
+        return agents;
     }
-    assignSessionsForMode(mode, claudeProcesses, sessions, usedSessionIds, assignedPids, historyBySessionId, 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, mode);
-            if (!session) {
+            catch {
                 continue;
             }
-            usedSessionIds.add(session.sessionId);
-            assignedPids.add(processInfo.pid);
-            agents.push(this.mapSessionToAgent(session, processInfo, historyBySessionId, 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;
     }
-    selectBestSession(processInfo, sessions, usedSessionIds, mode) {
-        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);
+    /**
+     * 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,
+                    },
+                });
             }
-            if (mode === 'project-parent') {
-                return this.isChildPath(processInfo.cwd, session.projectPath)
-                    || this.isChildPath(processInfo.cwd, session.lastCwd);
+            catch {
+                // PID file absent, unreadable, or malformed — fall back per-process
+                fallback.push(proc);
             }
-            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];
+        return { direct, fallback };
     }
-    mapSessionToAgent(session, processInfo, historyBySessionId, existingAgents) {
-        const historyEntry = historyBySessionId.get(session.sessionId);
+    /**
+     * 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: historyEntry?.display || 'Session started',
+            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 || new Date(),
-        };
-    }
-    mapProcessOnlyAgent(processInfo, existingAgents, historyByProjectPath, usedSessionIds) {
-        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 = {
-            sessionId,
-            projectPath,
-            lastCwd: projectPath,
-            sessionLogPath: '',
-            lastActive,
-        };
-        return {
-            name: this.generateAgentName(processSession, existingAgents),
-            type: this.type,
-            status: AgentAdapter_1.AgentStatus.RUNNING,
-            summary: historyEntry?.display || 'Claude process running',
-            pid: processInfo.pid,
-            projectPath,
-            sessionId: processSession.sessionId,
-            lastActive: processSession.lastActive || new Date(),
+            lastActive: session.lastActive,
         };
     }
-    mapHistoryToAgent(processInfo, historyEntry, existingAgents) {
-        const projectPath = processInfo.cwd || historyEntry.project;
-        const historySession = {
-            sessionId: historyEntry.sessionId,
-            projectPath,
-            lastCwd: projectPath,
-            sessionLogPath: '',
-            lastActive: new Date(historyEntry.timestamp),
-        };
+    mapProcessOnlyAgent(processInfo) {
         return {
-            name: this.generateAgentName(historySession, existingAgents),
+            name: (0, matching_1.generateAgentName)(processInfo.cwd || '', processInfo.pid),
             type: this.type,
-            status: AgentAdapter_1.AgentStatus.RUNNING,
-            summary: historyEntry.display || 'Claude process running',
+            status: AgentAdapter_1.AgentStatus.IDLE,
+            summary: 'Unknown',
             pid: processInfo.pid,
-            projectPath,
-            sessionId: historySession.sessionId,
-            lastActive: historySession.lastActive || new Date(),
+            projectPath: processInfo.cwd || '',
+            sessionId: `pid-${processInfo.pid}`,
+            lastActive: new Date(),
         };
     }
-    indexHistoryByProjectPath(historyEntries) {
-        const grouped = new Map();
-        for (const entry of historyEntries) {
-            const key = this.normalizePath(entry.project);
-            const list = grouped.get(key) || [];
-            list.push(entry);
-            grouped.set(key, list);
-        }
-        for (const [key, list] of grouped.entries()) {
-            grouped.set(key, [...list].sort((a, b) => b.timestamp - a.timestamp));
-        }
-        return grouped;
-    }
-    selectHistoryForProcess(processCwd, historyByProjectPath, usedSessionIds) {
-        if (!processCwd) {
-            return undefined;
-        }
-        const candidates = historyByProjectPath.get(this.normalizePath(processCwd)) || [];
-        return candidates.find((entry) => !usedSessionIds.has(entry.sessionId));
-    }
     /**
-     * Read all Claude Code sessions
+     * Parse a single session file into ClaudeSession
      */
-    readSessions() {
-        if (!fs.existsSync(this.projectsDir)) {
-            return [];
+    readSession(filePath, projectPath) {
+        const sessionId = path.basename(filePath, '.jsonl');
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
         }
-        const sessions = [];
-        const projectDirs = fs.readdirSync(this.projectsDir);
-        for (const dirName of projectDirs) {
-            if (dirName.startsWith('.')) {
-                continue;
-            }
-            const projectDir = path.join(this.projectsDir, dirName);
-            if (!fs.statSync(projectDir).isDirectory()) {
-                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 = (0, file_1.readJson)(indexPath);
-            if (!sessionsIndex) {
-                console.error(`Failed to parse ${indexPath}`);
-                continue;
-            }
-            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);
-                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,
-                    });
-                }
-                catch (error) {
-                    console.error(`Failed to read session ${sessionId}:`, error);
-                    continue;
+        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 = null;
+        try {
+            const firstEntry = JSON.parse(allLines[0]);
+            const rawTs = firstEntry.timestamp || firstEntry.snapshot?.timestamp;
+            if (rawTs) {
+                const ts = new Date(rawTs);
+                if (!Number.isNaN(ts.getTime())) {
+                    sessionStart = ts;
                 }
             }
         }
-        return sessions;
-    }
-    /**
-     * Read a session JSONL file
-     * Only reads last 100 lines for performance with large files
-     */
-    readSessionLog(logPath) {
-        const lines = (0, file_1.readLastLines)(logPath, 100);
+        catch {
+            /* skip */
+        }
+        // Parse all lines for session state (file already in memory)
         let slug;
-        let lastEntry;
+        let lastEntryType;
         let lastActive;
         let lastCwd;
-        for (const line of lines) {
+        let isInterrupted = false;
+        let lastUserMessage;
+        for (const line of allLines) {
             try {
                 const entry = JSON.parse(line);
+                if (entry.timestamp) {
+                    const ts = new Date(entry.timestamp);
+                    if (!Number.isNaN(ts.getTime())) {
+                        lastActive = ts;
+                    }
+                }
                 if (entry.slug && !slug) {
                     slug = entry.slug;
                 }
-                lastEntry = entry;
-                if (entry.timestamp) {
-                    lastActive = new Date(entry.timestamp);
-                }
                 if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {
                     lastCwd = entry.cwd;
                 }
+                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 (error) {
+            catch {
                 continue;
             }
         }
-        return { slug, lastEntry, lastActive, lastCwd };
-    }
-    /**
-     * Read history.jsonl for user prompts
-     * Only reads last 100 lines for performance
-     */
-    readHistory() {
-        return (0, file_1.readJsonLines)(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
      */
     determineStatus(session) {
-        if (!session.lastEntry) {
+        if (!session.lastEntryType) {
             return AgentAdapter_1.AgentStatus.UNKNOWN;
         }
-        const entryType = session.lastEntry.type;
-        const lastActive = session.lastActive || new Date(0);
-        const ageMinutes = (Date.now() - lastActive.getTime()) / 1000 / 60;
-        if (ageMinutes > ClaudeCodeAdapter.IDLE_THRESHOLD_MINUTES) {
-            return AgentAdapter_1.AgentStatus.IDLE;
+        // 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 (session.lastEntryType === 'user') {
+            return session.isInterrupted
+                ? AgentAdapter_1.AgentStatus.WAITING
+                : AgentAdapter_1.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 AgentAdapter_1.AgentStatus.WAITING;
-            }
+        if (session.lastEntryType === 'progress' ||
+            session.lastEntryType === 'thinking') {
             return AgentAdapter_1.AgentStatus.RUNNING;
         }
-        if (entryType === SessionEntryType.PROGRESS || entryType === SessionEntryType.THINKING) {
-            return AgentAdapter_1.AgentStatus.RUNNING;
-        }
-        else if (entryType === SessionEntryType.ASSISTANT) {
+        if (session.lastEntryType === 'assistant') {
             return AgentAdapter_1.AgentStatus.WAITING;
         }
-        else if (entryType === SessionEntryType.SYSTEM) {
+        if (session.lastEntryType === 'system') {
             return AgentAdapter_1.AgentStatus.IDLE;
         }
         return AgentAdapter_1.AgentStatus.UNKNOWN;
     }
     /**
-     * Generate unique agent name
-     * Uses project basename, appends slug if multiple sessions for same project
+     * Extract meaningful text from a user message content.
+     * Handles string and array formats, skill command expansion, and noise filtering.
      */
-    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;
+    extractUserMessageText(content) {
+        if (!content) {
+            return undefined;
         }
-        // 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})`;
+        let raw;
+        if (typeof content === 'string') {
+            raw = content.trim();
         }
-        // No slug available, use session ID prefix
-        return `${projectName} (${session.sessionId.slice(0, 8)})`;
-    }
-    pathEquals(a, b) {
-        if (!a || !b) {
-            return false;
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text' && block.text?.trim()) {
+                    raw = block.text.trim();
+                    break;
+                }
+            }
         }
-        return this.normalizePath(a) === this.normalizePath(b);
-    }
-    isChildPath(child, parent) {
-        if (!child || !parent) {
-            return false;
+        if (!raw) {
+            return undefined;
         }
-        const normalizedChild = this.normalizePath(child);
-        const normalizedParent = this.normalizePath(parent);
-        return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
-    }
-    normalizePath(value) {
-        const resolved = path.resolve(value);
-        if (resolved.length > 1 && resolved.endsWith(path.sep)) {
-            return resolved.slice(0, -1);
+        // Skill slash-command: extract /command-name and args
+        if (raw.startsWith('<command-message>')) {
+            return this.parseCommandMessage(raw);
         }
-        return resolved;
+        // 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;
     }
-    pathDepth(value) {
-        if (!value) {
-            return 0;
+    /**
+     * Parse a <command-message> string into "/command args" format.
+     */
+    parseCommandMessage(raw) {
+        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;
         }
-        return this.normalizePath(value).split(path.sep).filter(Boolean).length;
+        const args = argsMatch?.[1]?.trim();
+        return args ? `${name} ${args}` : name;
+    }
+    /**
+     * Check if a message is noise (not a meaningful user intent).
+     */
+    isNoiseMessage(text) {
+        return (text.startsWith('[Request interrupted') ||
+            text === 'Tool loaded.' ||
+            text.startsWith('This session is being continued'));
+    }
+    /**
+     * Check if an entry type is metadata (not conversation state).
+     * These should not overwrite lastEntryType used for status determination.
+     */
+    isMetadataEntryType(type) {
+        return type === 'last-prompt' || type === 'file-history-snapshot';
     }
 }
 exports.ClaudeCodeAdapter = ClaudeCodeAdapter;
-/** Threshold in minutes before considering a session idle */
-ClaudeCodeAdapter.IDLE_THRESHOLD_MINUTES = 5;
 //# sourceMappingURL=ClaudeCodeAdapter.js.map