@ai-devkit/agent-manager 0.29.0 → 0.31.0

package/dist/{adapters/ClaudeCodeAdapter.d.ts → providers/claude/ClaudeSessionLocator.d.ts}

@@ -1,24 +1,72 @@
-import type { AgentAdapter, AgentInfo, ProcessInfo, ConversationMessage, SessionSummary, ListSessionsOptions, AgentDetectionContext } from './AgentAdapter.js';
+import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { type MatchResult } from '../../utils/matching.js';
+import { type SessionFile } from '../../utils/session.js';
 /**
- * Claude Code Adapter
+ * A process directly matched to a session via PID file (authoritative path).
  *
- * Detects Claude Code agents by:
- * 1. Filtering Claude processes from a shared asynchronous process snapshot
- * 2. Using snapshot CWD and start-time enrichment
- * 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
+ * When the matching PID file also exposes live status/waitingFor metadata,
+ * those values are carried here so the agent mapper can prefer them over
+ * the JSONL-derived heuristic.
  */
-export declare class ClaudeCodeAdapter implements AgentAdapter {
-    readonly type: "claude";
-    readonly processNames: readonly ["claude"];
-    private projectsDir;
-    private sessionsDir;
-    private parser;
-    constructor();
-    canHandle(processInfo: ProcessInfo): boolean;
-    private isClaudeExecutable;
-    detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]>;
+export interface ClaudeDirectMatch {
+    process: ProcessInfo;
+    sessionFile: SessionFile;
+    pidStatus?: AgentStatus;
+    waitingFor?: string;
+}
+export interface ClaudeProcessSessionMatches {
+    direct: ClaudeDirectMatch[];
+    legacyMatches: MatchResult[];
+}
+export interface ClaudeSessionLocatorOptions {
+    projectsDir?: string;
+    sessionsDir?: string;
+}
+export declare class ClaudeSessionLocator {
+    private readonly projectsDir;
+    private readonly sessionsDir;
+    constructor(options?: ClaudeSessionLocatorOptions);
+    /**
+     * Pair live Claude processes with their session files.
+     *
+     * Runs three staged strategies, each handing its unmatched processes
+     * to the next:
+     * 1. `--resume <id>` on the command line — authoritative for resumed
+     *    sessions whose JSONL predates the process.
+     * 2. PID-file matching via ~/.claude/sessions/<pid>.json.
+     * 3. Legacy CWD+birthtime heuristic, for processes with no PID file.
+     */
+    matchRunningProcesses(processes: ProcessInfo[]): ClaudeProcessSessionMatches;
+    /**
+     * Discover candidate session files for listing historical sessions.
+     *
+     * Always walks every subdirectory of `projectsDir`. We can't use the
+     * encoded-dir shortcut for the cwd-scoped path because Claude Code
+     * indexes session files by where the *process was launched*, not by
+     * the recorded `cwd` field inside the session — these diverge in
+     * worktrees and similar setups. The cwd filter is applied later
+     * against `session.lastCwd` so callers see exactly the sessions whose
+     * recorded cwd matches.
+     */
+    discoverHistoricalSessionFiles(): Array<{
+        filePath: string;
+        defaultCwd: string;
+    }>;
+    /**
+     * Derive the Claude Code project directory for a given CWD.
+     *
+     * Claude Code encodes paths by replacing every non-alphanumeric
+     * character with '-', so '/', '_', '.', spaces, etc. all collapse:
+     *   /Users/foo/bar          → -Users-foo-bar
+     *   /Users/foo/my_project   → -Users-foo-my-project
+     *   /Users/foo/.worktrees/x → -Users-foo--worktrees-x
+     *
+     * The encoding is lossy — multiple real paths can collide on the
+     * same encoded dir. Callers that need to disambiguate must read the
+     * `cwd` field inside each session JSONL.
+     */
+    private getProjectDir;
     /**
      * Discover session files for the given processes.
      *
@@ -26,7 +74,7 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * ~/.claude/projects/<encoded>/ directory, then gets session file birthtimes
      * via a single batched stat call across all directories.
      */
-    private discoverSessions;
+    discoverLiveSessions(processes: ProcessInfo[]): SessionFile[];
     /**
      * Match processes via `claude --resume <uuid>` in their command line.
      * This works for resumed sessions, where the JSONL was created earlier
@@ -63,37 +111,5 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * stale startedAt (>60s from proc.startTime), or missing JSONL.
      */
     private tryPidFileMatching;
-    /**
-     * Derive the Claude Code project directory for a given CWD.
-     *
-     * Claude Code encodes paths by replacing every non-alphanumeric
-     * character with '-', so '/', '_', '.', spaces, etc. all collapse:
-     *   /Users/foo/bar          → -Users-foo-bar
-     *   /Users/foo/my_project   → -Users-foo-my-project
-     *   /Users/foo/.worktrees/x → -Users-foo--worktrees-x
-     *
-     * The encoding is lossy — multiple real paths can collide on the
-     * same encoded dir. Callers that need to disambiguate must read the
-     * `cwd` field inside each session JSONL.
-     */
-    private getProjectDir;
-    private mapSessionToAgent;
-    private mapProcessOnlyAgent;
-    getConversation(sessionFilePath: string, options?: {
-        verbose?: boolean;
-    }): ConversationMessage[];
-    listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
-    /**
-     * Discover candidate session files for {@link listSessions}.
-     *
-     * Always walks every subdirectory of `projectsDir`. We can't use the
-     * encoded-dir shortcut for the cwd-scoped path because Claude Code
-     * indexes session files by where the *process was launched*, not by
-     * the recorded `cwd` field inside the session — these diverge in
-     * worktrees and similar setups. The cwd filter is applied later
-     * against `session.lastCwd` so callers see exactly the sessions whose
-     * recorded cwd matches.
-     */
-    private discoverSessionFiles;
 }
-//# sourceMappingURL=ClaudeCodeAdapter.d.ts.map
+//# sourceMappingURL=ClaudeSessionLocator.d.ts.map

package/dist/providers/claude/ClaudeSessionLocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeSessionLocator.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/ClaudeSessionLocator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAMH,KAAK,WAAW,EACnB,MAAM,wBAAwB,CAAC;AAyBhC;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,aAAa,EAAE,WAAW,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,2BAA2B;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAKD,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,OAAO,GAAE,2BAAgC;IAMrD;;;;;;;;;OASG;IACH,qBAAqB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,2BAA2B;IAe5E;;;;;;;;;;OAUG;IACH,8BAA8B,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAsBjF;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,aAAa;IAKrB;;;;;;OAMG;IACH,oBAAoB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE;IA6B7D;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA8CzB,OAAO,CAAC,sBAAsB;IAK9B;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;CAsC7B"}

package/dist/{adapters/ClaudeCodeAdapter.js → providers/claude/ClaudeSessionLocator.js}

@@ -1,95 +1,84 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { AgentStatus } from './AgentAdapter.js';
-import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';
-import { batchGetSessionFileBirthtimes, isDirectory, listJsonl, safeReaddir, safeStat } from '../utils/session.js';
-import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
-import { ClaudeSessionParser } from '../utils/ClaudeSessionParser.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { matchProcessesToSessions } from '../../utils/matching.js';
+import { batchGetSessionFileBirthtimes, isDirectory, listJsonl, safeReaddir, safeStat } from '../../utils/session.js';
 /** Maximum allowed delta (ms) between process start time and PID file startedAt. */ const PID_FILE_STALENESS_MS = 60000;
-/**
- * Claude Code Adapter
- *
- * Detects Claude Code agents by:
- * 1. Filtering Claude processes from a shared asynchronous process snapshot
- * 2. Using snapshot CWD and start-time enrichment
- * 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 class ClaudeCodeAdapter {
-    type = 'claude';
-    processNames = [
-        'claude'
-    ];
+export class ClaudeSessionLocator {
     projectsDir;
     sessionsDir;
-    parser;
-    constructor(){
+    constructor(options = {}){
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        this.projectsDir = path.join(homeDir, '.claude', 'projects');
-        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');
-        this.parser = new ClaudeSessionParser();
+        this.projectsDir = options.projectsDir ?? path.join(homeDir, '.claude', 'projects');
+        this.sessionsDir = options.sessionsDir ?? path.join(homeDir, '.claude', 'sessions');
     }
-    canHandle(processInfo) {
-        return this.isClaudeExecutable(processInfo.command);
-    }
-    isClaudeExecutable(command) {
-        const base = executableBasename(command);
-        return base === 'claude' || base === 'claude.exe';
-    }
-    async detectAgents(context) {
-        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
-        const relevant = filterByProcessNames(snapshot, this.processNames);
-        const processes = relevant.filter((process1)=>this.canHandle(process1));
-        if (processes.length === 0) {
-            return [];
-        }
-        // Step 1: extract `--resume <id>` from command line — authoritative for
-        // resumed sessions where the JSONL predates the process and PID-file/
-        // birthtime heuristics can't match it.
+    /**
+     * Pair live Claude processes with their session files.
+     *
+     * Runs three staged strategies, each handing its unmatched processes
+     * to the next:
+     * 1. `--resume <id>` on the command line — authoritative for resumed
+     *    sessions whose JSONL predates the process.
+     * 2. PID-file matching via ~/.claude/sessions/<pid>.json.
+     * 3. Legacy CWD+birthtime heuristic, for processes with no PID file.
+     */ matchRunningProcesses(processes) {
         const { direct: resumeDirect, fallback: noResume } = this.tryResumeMatching(processes);
-        // Step 2: try authoritative PID-file matching for the rest
         const { direct: pidDirect, fallback } = this.tryPidFileMatching(noResume);
-        const direct = [
-            ...resumeDirect,
-            ...pidDirect
-        ];
-        // Step 3: run legacy CWD+birthtime matching only for processes without a PID file
-        const legacySessions = this.discoverSessions(fallback);
+        const legacySessions = this.discoverLiveSessions(fallback);
         const legacyMatches = fallback.length > 0 && legacySessions.length > 0 ? matchProcessesToSessions(fallback, legacySessions) : [];
-        const matchedPids = new Set([
-            ...direct.map((d)=>d.process.pid),
-            ...legacyMatches.map((m)=>m.process.pid)
-        ]);
-        const agents = [];
-        // Build agents from direct (resume + PID-file) matches
-        for (const match of direct){
-            const { process: proc, sessionFile } = match;
-            const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
-            if (sessionData) {
-                agents.push(this.mapSessionToAgent(sessionData, proc, sessionFile, {
-                    pidStatus: match.pidStatus,
-                    waitingFor: match.waitingFor
-                }));
-            } else {
-                matchedPids.delete(proc.pid);
-            }
-        }
-        // Build agents from legacy matches
-        for (const match of legacyMatches){
-            const sessionData = this.parser.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));
+        return {
+            direct: [
+                ...resumeDirect,
+                ...pidDirect
+            ],
+            legacyMatches
+        };
+    }
+    /**
+     * Discover candidate session files for listing historical sessions.
+     *
+     * Always walks every subdirectory of `projectsDir`. We can't use the
+     * encoded-dir shortcut for the cwd-scoped path because Claude Code
+     * indexes session files by where the *process was launched*, not by
+     * the recorded `cwd` field inside the session — these diverge in
+     * worktrees and similar setups. The cwd filter is applied later
+     * against `session.lastCwd` so callers see exactly the sessions whose
+     * recorded cwd matches.
+     */ discoverHistoricalSessionFiles() {
+        const out = [];
+        if (!isDirectory(this.projectsDir)) return out;
+        for (const dirName of safeReaddir(this.projectsDir)){
+            const projectDir = path.join(this.projectsDir, dirName);
+            if (!isDirectory(projectDir)) continue;
+            // Best-effort decode for the rare case session content has no
+            // recorded cwd: '-Users-foo-bar' → '/Users/foo/bar'. Lossy for
+            // paths containing '-'; session content's lastCwd overrides
+            // this when available.
+            const decoded = dirName.replace(/-/g, '/');
+            for (const name of listJsonl(projectDir)){
+                out.push({
+                    filePath: path.join(projectDir, name),
+                    defaultCwd: decoded
+                });
             }
         }
-        return agents;
+        return out;
+    }
+    /**
+     * Derive the Claude Code project directory for a given CWD.
+     *
+     * Claude Code encodes paths by replacing every non-alphanumeric
+     * character with '-', so '/', '_', '.', spaces, etc. all collapse:
+     *   /Users/foo/bar          → -Users-foo-bar
+     *   /Users/foo/my_project   → -Users-foo-my-project
+     *   /Users/foo/.worktrees/x → -Users-foo--worktrees-x
+     *
+     * The encoding is lossy — multiple real paths can collide on the
+     * same encoded dir. Callers that need to disambiguate must read the
+     * `cwd` field inside each session JSONL.
+     */ getProjectDir(cwd) {
+        const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
+        return path.join(this.projectsDir, encoded);
     }
     /**
      * Discover session files for the given processes.
@@ -97,7 +86,7 @@ import { ClaudeSessionParser } from '../utils/ClaudeSessionParser.js';
      * 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) {
+     */ discoverLiveSessions(processes) {
         const dirToCwd = new Map();
         for (const proc of processes){
             if (!proc.cwd) continue;
@@ -249,113 +238,6 @@ import { ClaudeSessionParser } from '../utils/ClaudeSessionParser.js';
             fallback
         };
     }
-    /**
-     * Derive the Claude Code project directory for a given CWD.
-     *
-     * Claude Code encodes paths by replacing every non-alphanumeric
-     * character with '-', so '/', '_', '.', spaces, etc. all collapse:
-     *   /Users/foo/bar          → -Users-foo-bar
-     *   /Users/foo/my_project   → -Users-foo-my-project
-     *   /Users/foo/.worktrees/x → -Users-foo--worktrees-x
-     *
-     * The encoding is lossy — multiple real paths can collide on the
-     * same encoded dir. Callers that need to disambiguate must read the
-     * `cwd` field inside each session JSONL.
-     */ getProjectDir(cwd) {
-        const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
-        return path.join(this.projectsDir, encoded);
-    }
-    mapSessionToAgent(session, processInfo, sessionFile, liveInfo) {
-        // Live PID-file status is authoritative when present — JSONL-derived
-        // status mis-classifies sessions whose latest entry is a UI-state
-        // event like `permission-mode` or `ai-title`.
-        const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);
-        const baseSummary = session.lastUserMessage || 'Session started';
-        const summary = status === AgentStatus.WAITING && liveInfo?.waitingFor ? `${baseSummary} — waiting for ${liveInfo.waitingFor}` : baseSummary;
-        return {
-            name: generateAgentName(processInfo.cwd, processInfo.pid),
-            type: this.type,
-            status,
-            summary,
-            pid: processInfo.pid,
-            projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',
-            sessionId: sessionFile.sessionId,
-            lastActive: session.lastActive,
-            sessionFilePath: sessionFile.filePath
-        };
-    }
-    mapProcessOnlyAgent(processInfo) {
-        return {
-            name: generateAgentName(processInfo.cwd || '', processInfo.pid),
-            type: this.type,
-            status: AgentStatus.IDLE,
-            summary: 'Unknown',
-            pid: processInfo.pid,
-            projectPath: processInfo.cwd || '',
-            sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date()
-        };
-    }
-    getConversation(sessionFilePath, options) {
-        return this.parser.getConversation(sessionFilePath, options);
-    }
-    async listSessions(opts) {
-        const filterCwd = opts?.cwd;
-        const candidates = this.discoverSessionFiles();
-        const summaries = [];
-        for (const { filePath, defaultCwd } of candidates){
-            const session = this.parser.readSession(filePath, defaultCwd);
-            if (!session) continue;
-            // Drop sessions whose JSONL had no parseable conversation entries.
-            // readSession is permissive (returns a shell record even when every
-            // line fails to parse); listSessions needs at least one real entry
-            // so we don't surface garbage files.
-            if (!session.lastEntryType) continue;
-            const recordedCwd = session.lastCwd || defaultCwd;
-            if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;
-            const stat = safeStat(filePath);
-            summaries.push({
-                type: 'claude',
-                sessionId: session.sessionId,
-                cwd: recordedCwd,
-                firstUserMessage: session.firstUserMessage || '',
-                lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
-                startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
-                sessionFilePath: filePath
-            });
-        }
-        return summaries;
-    }
-    /**
-     * Discover candidate session files for {@link listSessions}.
-     *
-     * Always walks every subdirectory of `projectsDir`. We can't use the
-     * encoded-dir shortcut for the cwd-scoped path because Claude Code
-     * indexes session files by where the *process was launched*, not by
-     * the recorded `cwd` field inside the session — these diverge in
-     * worktrees and similar setups. The cwd filter is applied later
-     * against `session.lastCwd` so callers see exactly the sessions whose
-     * recorded cwd matches.
-     */ discoverSessionFiles() {
-        const out = [];
-        if (!isDirectory(this.projectsDir)) return out;
-        for (const dirName of safeReaddir(this.projectsDir)){
-            const projectDir = path.join(this.projectsDir, dirName);
-            if (!isDirectory(projectDir)) continue;
-            // Best-effort decode for the rare case session content has no
-            // recorded cwd: '-Users-foo-bar' → '/Users/foo/bar'. Lossy for
-            // paths containing '-'; session content's lastCwd overrides
-            // this when available.
-            const decoded = dirName.replace(/-/g, '/');
-            for (const name of listJsonl(projectDir)){
-                out.push({
-                    filePath: path.join(projectDir, name),
-                    defaultCwd: decoded
-                });
-            }
-        }
-        return out;
-    }
 }
 
-//# sourceMappingURL=ClaudeCodeAdapter.js.map
+//# sourceMappingURL=ClaudeSessionLocator.js.map

package/dist/providers/claude/ClaudeSessionLocator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/providers/claude/ClaudeSessionLocator.ts"],"sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type { ProcessInfo } from '../../adapters/AgentAdapter.js';\nimport { AgentStatus } from '../../adapters/AgentAdapter.js';\nimport { matchProcessesToSessions, type MatchResult } from '../../utils/matching.js';\nimport {\n    batchGetSessionFileBirthtimes,\n    isDirectory,\n    listJsonl,\n    safeReaddir,\n    safeStat,\n    type SessionFile,\n} from '../../utils/session.js';\n\n/**\n * Entry in ~/.claude/sessions/<pid>.json written by Claude Code.\n * Maps a running process to its session file via PID.\n */\ninterface PidFileEntry {\n    pid: number;\n    sessionId: string;\n    cwd: string;\n    /** Epoch milliseconds when the Claude Code process started */\n    startedAt: number;\n    kind: string;\n    entrypoint: string;\n    /**\n     * Authoritative live status published by the Claude Code process\n     * (e.g., 'running', 'waiting', 'idle'). Preferred over JSONL-derived\n     * status because trailing entries like 'permission-mode' / 'ai-title'\n     * can mask the real conversational state.\n     */\n    status?: string;\n    /** Short description of what the agent is waiting on (e.g., \"approve Read\"). */\n    waitingFor?: string;\n}\n\n/**\n * A process directly matched to a session via PID file (authoritative path).\n *\n * When the matching PID file also exposes live status/waitingFor metadata,\n * those values are carried here so the agent mapper can prefer them over\n * the JSONL-derived heuristic.\n */\nexport interface ClaudeDirectMatch {\n    process: ProcessInfo;\n    sessionFile: SessionFile;\n    pidStatus?: AgentStatus;\n    waitingFor?: string;\n}\n\nexport interface ClaudeProcessSessionMatches {\n    direct: ClaudeDirectMatch[];\n    legacyMatches: MatchResult[];\n}\n\nexport interface ClaudeSessionLocatorOptions {\n    projectsDir?: string;\n    sessionsDir?: string;\n}\n\n/** Maximum allowed delta (ms) between process start time and PID file startedAt. */\nconst PID_FILE_STALENESS_MS = 60000;\n\nexport class ClaudeSessionLocator {\n    private readonly projectsDir: string;\n    private readonly sessionsDir: string;\n\n    constructor(options: ClaudeSessionLocatorOptions = {}) {\n        const homeDir = process.env.HOME || process.env.USERPROFILE || '';\n        this.projectsDir = options.projectsDir ?? path.join(homeDir, '.claude', 'projects');\n        this.sessionsDir = options.sessionsDir ?? path.join(homeDir, '.claude', 'sessions');\n    }\n\n    /**\n     * Pair live Claude processes with their session files.\n     *\n     * Runs three staged strategies, each handing its unmatched processes\n     * to the next:\n     * 1. `--resume <id>` on the command line — authoritative for resumed\n     *    sessions whose JSONL predates the process.\n     * 2. PID-file matching via ~/.claude/sessions/<pid>.json.\n     * 3. Legacy CWD+birthtime heuristic, for processes with no PID file.\n     */\n    matchRunningProcesses(processes: ProcessInfo[]): ClaudeProcessSessionMatches {\n        const { direct: resumeDirect, fallback: noResume } = this.tryResumeMatching(processes);\n        const { direct: pidDirect, fallback } = this.tryPidFileMatching(noResume);\n        const legacySessions = this.discoverLiveSessions(fallback);\n        const legacyMatches =\n            fallback.length > 0 && legacySessions.length > 0\n                ? matchProcessesToSessions(fallback, legacySessions)\n                : [];\n\n        return {\n            direct: [...resumeDirect, ...pidDirect],\n            legacyMatches,\n        };\n    }\n\n    /**\n     * Discover candidate session files for listing historical sessions.\n     *\n     * Always walks every subdirectory of `projectsDir`. We can't use the\n     * encoded-dir shortcut for the cwd-scoped path because Claude Code\n     * indexes session files by where the *process was launched*, not by\n     * the recorded `cwd` field inside the session — these diverge in\n     * worktrees and similar setups. The cwd filter is applied later\n     * against `session.lastCwd` so callers see exactly the sessions whose\n     * recorded cwd matches.\n     */\n    discoverHistoricalSessionFiles(): Array<{ filePath: string; defaultCwd: string }> {\n        const out: Array<{ filePath: string; defaultCwd: string }> = [];\n\n        if (!isDirectory(this.projectsDir)) return out;\n\n        for (const dirName of safeReaddir(this.projectsDir)) {\n            const projectDir = path.join(this.projectsDir, dirName);\n            if (!isDirectory(projectDir)) continue;\n\n            // Best-effort decode for the rare case session content has no\n            // recorded cwd: '-Users-foo-bar' → '/Users/foo/bar'. Lossy for\n            // paths containing '-'; session content's lastCwd overrides\n            // this when available.\n            const decoded = dirName.replace(/-/g, '/');\n            for (const name of listJsonl(projectDir)) {\n                out.push({ filePath: path.join(projectDir, name), defaultCwd: decoded });\n            }\n        }\n\n        return out;\n    }\n\n    /**\n     * Derive the Claude Code project directory for a given CWD.\n     *\n     * Claude Code encodes paths by replacing every non-alphanumeric\n     * character with '-', so '/', '_', '.', spaces, etc. all collapse:\n     *   /Users/foo/bar          → -Users-foo-bar\n     *   /Users/foo/my_project   → -Users-foo-my-project\n     *   /Users/foo/.worktrees/x → -Users-foo--worktrees-x\n     *\n     * The encoding is lossy — multiple real paths can collide on the\n     * same encoded dir. Callers that need to disambiguate must read the\n     * `cwd` field inside each session JSONL.\n     */\n    private getProjectDir(cwd: string): string {\n        const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');\n        return path.join(this.projectsDir, encoded);\n    }\n\n    /**\n     * Discover session files for the given processes.\n     *\n     * For each unique process CWD, encodes it to derive the expected\n     * ~/.claude/projects/<encoded>/ directory, then gets session file birthtimes\n     * via a single batched stat call across all directories.\n     */\n    discoverLiveSessions(processes: ProcessInfo[]): SessionFile[] {\n        const dirToCwd = new Map<string, string>();\n\n        for (const proc of processes) {\n            if (!proc.cwd) continue;\n\n            const projectDir = this.getProjectDir(proc.cwd);\n            if (dirToCwd.has(projectDir)) continue;\n\n            try {\n                if (!fs.statSync(projectDir).isDirectory()) continue;\n            } catch {\n                continue;\n            }\n\n            dirToCwd.set(projectDir, proc.cwd);\n        }\n\n        if (dirToCwd.size === 0) return [];\n\n        const files = batchGetSessionFileBirthtimes([...dirToCwd.keys()]);\n\n        for (const file of files) {\n            file.resolvedCwd = dirToCwd.get(file.projectDir) || '';\n        }\n\n        return files;\n    }\n\n    /**\n     * Match processes via `claude --resume <uuid>` in their command line.\n     * This works for resumed sessions, where the JSONL was created earlier\n     * (so its birthtime is far from the process startTime and the legacy\n     * matcher can't pair them) and the PID file may also be misaligned.\n     */\n    private tryResumeMatching(processes: ProcessInfo[]): {\n        direct: ClaudeDirectMatch[];\n        fallback: ProcessInfo[];\n    } {\n        const direct: ClaudeDirectMatch[] = [];\n        const fallback: ProcessInfo[] = [];\n\n        for (const proc of processes) {\n            const sessionId = this.extractResumeSessionId(proc.command);\n            if (!sessionId || !proc.cwd) {\n                fallback.push(proc);\n                continue;\n            }\n\n            const projectDir = this.getProjectDir(proc.cwd);\n            const jsonlPath = path.join(projectDir, `${sessionId}.jsonl`);\n\n            const stat = safeStat(jsonlPath);\n            if (!stat) {\n                fallback.push(proc);\n                continue;\n            }\n\n            // Best-effort: the PID file (if present for this proc) is the\n            // authoritative source of live status. We still match the session\n            // via --resume, but we read the PID file alongside to capture\n            // status/waitingFor.\n            const pidEntry = this.readMatchingPidFile(proc.pid, proc.startTime);\n\n            direct.push({\n                process: proc,\n                sessionFile: {\n                    sessionId,\n                    filePath: jsonlPath,\n                    projectDir,\n                    birthtimeMs: stat.birthtimeMs,\n                    resolvedCwd: proc.cwd,\n                },\n                pidStatus: this.mapPidStatus(pidEntry?.status),\n                waitingFor: pidEntry?.waitingFor,\n            });\n        }\n\n        return { direct, fallback };\n    }\n\n    private extractResumeSessionId(command: string): string | null {\n        const match = command.match(/--resume\\s+([0-9a-f-]{36})/i);\n        return match?.[1] ?? null;\n    }\n\n    /**\n     * Read and parse ~/.claude/sessions/<pid>.json, returning null on any\n     * I/O / parse failure or when the file is stale relative to the live\n     * process.\n     *\n     * \"Stale\" means the PID file's startedAt diverges from the process's\n     * start time by more than {@link PID_FILE_STALENESS_MS} — typically\n     * a previous Claude Code process recycled the same PID without cleanup.\n     */\n    private readMatchingPidFile(pid: number, procStartTime?: Date): PidFileEntry | null {\n        const pidFilePath = path.join(this.sessionsDir, `${pid}.json`);\n        try {\n            const entry = JSON.parse(\n                fs.readFileSync(pidFilePath, 'utf-8'),\n            ) as PidFileEntry;\n\n            if (procStartTime) {\n                const deltaMs = Math.abs(procStartTime.getTime() - entry.startedAt);\n                if (deltaMs > PID_FILE_STALENESS_MS) {\n                    return null;\n                }\n            }\n\n            return entry;\n        } catch {\n            return null;\n        }\n    }\n\n    /**\n     * Map the PID file's live status string to {@link AgentStatus}.\n     *\n     * Returns undefined for missing / unrecognized values so the caller\n     * can fall back to JSONL-derived heuristics.\n     */\n    private mapPidStatus(status: string | undefined): AgentStatus | undefined {\n        switch (status) {\n            case 'running':\n                return AgentStatus.RUNNING;\n            case 'waiting':\n                return AgentStatus.WAITING;\n            case 'idle':\n                return AgentStatus.IDLE;\n            default:\n                return undefined;\n        }\n    }\n\n    /**\n     * Attempt to match each process to its session via ~/.claude/sessions/<pid>.json.\n     *\n     * Returns:\n     *   direct  — processes matched authoritatively via PID file\n     *   fallback — processes with no valid PID file (sent to legacy matching)\n     *\n     * Per-process fallback triggers on: file absent, malformed JSON,\n     * stale startedAt (>60s from proc.startTime), or missing JSONL.\n     */\n    private tryPidFileMatching(processes: ProcessInfo[]): {\n        direct: ClaudeDirectMatch[];\n        fallback: ProcessInfo[];\n    } {\n        const direct: ClaudeDirectMatch[] = [];\n        const fallback: ProcessInfo[] = [];\n\n        for (const proc of processes) {\n            const entry = this.readMatchingPidFile(proc.pid, proc.startTime);\n            if (!entry) {\n                fallback.push(proc);\n                continue;\n            }\n\n            const projectDir = this.getProjectDir(entry.cwd);\n            const jsonlPath = path.join(projectDir, `${entry.sessionId}.jsonl`);\n\n            if (!fs.existsSync(jsonlPath)) {\n                fallback.push(proc);\n                continue;\n            }\n\n            direct.push({\n                process: proc,\n                sessionFile: {\n                    sessionId: entry.sessionId,\n                    filePath: jsonlPath,\n                    projectDir,\n                    birthtimeMs: entry.startedAt,\n                    resolvedCwd: entry.cwd,\n                },\n                pidStatus: this.mapPidStatus(entry.status),\n                waitingFor: entry.waitingFor,\n            });\n        }\n\n        return { direct, fallback };\n    }\n}\n"],"names":["fs","path","AgentStatus","matchProcessesToSessions","batchGetSessionFileBirthtimes","isDirectory","listJsonl","safeReaddir","safeStat","PID_FILE_STALENESS_MS","ClaudeSessionLocator","projectsDir","sessionsDir","options","homeDir","process","env","HOME","USERPROFILE","join","matchRunningProcesses","processes","direct","resumeDirect","fallback","noResume","tryResumeMatching","pidDirect","tryPidFileMatching","legacySessions","discoverLiveSessions","legacyMatches","length","discoverHistoricalSessionFiles","out","dirName","projectDir","decoded","replace","name","push","filePath","defaultCwd","getProjectDir","cwd","encoded","dirToCwd","Map","proc","has","statSync","set","size","files","keys","file","resolvedCwd","get","sessionId","extractResumeSessionId","command","jsonlPath","stat","pidEntry","readMatchingPidFile","pid","startTime","sessionFile","birthtimeMs","pidStatus","mapPidStatus","status","waitingFor","match","procStartTime","pidFilePath","entry","JSON","parse","readFileSync","deltaMs","Math","abs","getTime","startedAt","RUNNING","WAITING","IDLE","undefined","existsSync"],"mappings":"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"}

package/dist/{utils → providers/claude}/ClaudeSessionParser.d.ts

@@ -1,5 +1,5 @@
-import type { ConversationMessage } from '../adapters/AgentAdapter.js';
-import { AgentStatus } from '../adapters/AgentAdapter.js';
+import type { ConversationMessage } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
 /**
  * Content block within a Claude Code JSONL message entry.
  * Handles text, tool_use, and tool_result block types.

package/dist/providers/claude/ClaudeSessionParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeSessionParser.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/ClaudeSessionParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE,CAAC;KACrC,CAAC;CACL;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,IAAI,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAoBD;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC5B;;;;;;;;OAQG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAmFxE;;;;;;;;;OASG;IACH,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,WAAW;IA6BpD;;;;;OAKG;IACH,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,mBAAmB,EAAE;IA6ChG;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;;;;;;;;OASG;IACH,OAAO,CAAC,sBAAsB;IAwC9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,OAAO,CAAC,0BAA0B;CAmCrC"}

package/dist/{utils → providers/claude}/ClaudeSessionParser.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { AgentStatus } from '../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
 /**
  * Top-level JSONL entry types that represent conversation/agent state.
  *

package/dist/providers/claude/ClaudeSessionParser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/providers/claude/ClaudeSessionParser.ts"],"sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type { ConversationMessage } from '../../adapters/AgentAdapter.js';\nimport { AgentStatus } from '../../adapters/AgentAdapter.js';\n\n/**\n * Content block within a Claude Code JSONL message entry.\n * Handles text, tool_use, and tool_result block types.\n */\nexport interface ContentBlock {\n    type?: string;\n    text?: string;\n    content?: string;\n    name?: string;\n    input?: Record<string, unknown>;\n    tool_use_id?: string;\n    is_error?: boolean;\n}\n\n/**\n * A single line entry in a Claude Code session JSONL file.\n *\n * Each line is an independent JSON object with a type discriminator:\n * - \"user\" / \"assistant\" / \"system\" — conversation turns\n * - \"progress\" / \"thinking\" — intermediate agent state\n * - \"last-prompt\" / \"file-history-snapshot\" — metadata (not conversation state)\n */\nexport interface SessionEntry {\n    type?: string;\n    timestamp?: string;\n    cwd?: string;\n    message?: {\n        content?: string | ContentBlock[];\n    };\n}\n\n/**\n * Parsed session state extracted from a JSONL file.\n * Aggregates data from all entries into a single summary.\n */\nexport interface ClaudeSession {\n    sessionId: string;\n    projectPath: string;\n    lastCwd?: string;\n    sessionStart: Date;\n    lastActive: Date;\n    lastEntryType?: string;\n    isInterrupted: boolean;\n    lastUserMessage?: string;\n    /** First meaningful user prompt in the session (post noise filter) */\n    firstUserMessage?: string;\n}\n\n/**\n * Top-level JSONL entry types that represent conversation/agent state.\n *\n * Only these types update `lastEntryType` for status determination. All\n * other types Claude Code emits (`attachment`, `permission-mode`,\n * `ai-title`, `queued_command`, `tools_changed`, `model_changed`,\n * `hook_progress`, …) are UI-state events that must not overwrite the\n * last conversation turn — otherwise polling between writes lands on a\n * UI-state entry and `determineStatus` falls through to UNKNOWN.\n */\nconst CONVERSATION_ENTRY_TYPES = new Set([\n    'user',\n    'assistant',\n    'system',\n    'progress',\n    'thinking',\n]);\n\n/**\n * Parses Claude Code session JSONL files into structured data.\n *\n * Session files live at ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl\n * and contain one JSON object per line, each representing a conversation\n * event (user turn, assistant response, tool call, etc.).\n */\nexport class ClaudeSessionParser {\n    /**\n     * Parse a session JSONL file into a ClaudeSession summary.\n     *\n     * Iterates all lines to extract: session start time (from first entry),\n     * last activity timestamp, last entry type (for status), whether the\n     * session was interrupted, and the last meaningful user message.\n     *\n     * Returns null if the file is unreadable or empty.\n     */\n    readSession(filePath: string, projectPath: string): ClaudeSession | null {\n        const sessionId = path.basename(filePath, '.jsonl');\n\n        let content: string;\n        try {\n            content = fs.readFileSync(filePath, 'utf-8');\n        } catch {\n            return null;\n        }\n\n        const allLines = content.trim().split('\\n');\n        if (allLines.length === 0) {\n            return null;\n        }\n\n        const sessionStart = this.parseSessionStart(allLines[0]);\n\n        let lastEntryType: string | undefined;\n        let lastActive: Date | undefined;\n        let lastCwd: string | undefined;\n        let isInterrupted = false;\n        let lastUserMessage: string | undefined;\n        let firstUserMessage: string | undefined;\n\n        for (const line of allLines) {\n            try {\n                const entry: SessionEntry = JSON.parse(line);\n\n                if (entry.timestamp) {\n                    const ts = new Date(entry.timestamp);\n                    if (!Number.isNaN(ts.getTime())) {\n                        lastActive = ts;\n                    }\n                }\n\n                if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {\n                    lastCwd = entry.cwd;\n                }\n\n                if (entry.type && CONVERSATION_ENTRY_TYPES.has(entry.type)) {\n                    lastEntryType = entry.type;\n\n                    if (entry.type === 'user') {\n                        const msgContent = entry.message?.content;\n                        isInterrupted =\n                            Array.isArray(msgContent) &&\n                            msgContent.some(\n                                (c) =>\n                                    (c.type === 'text' &&\n                                        c.text?.includes('[Request interrupted')) ||\n                                    (c.type === 'tool_result' &&\n                                        c.content?.includes('[Request interrupted')),\n                            );\n\n                        const text = this.extractUserMessageText(msgContent);\n                        if (text) {\n                            lastUserMessage = text;\n                            if (!firstUserMessage) {\n                                firstUserMessage = text;\n                            }\n                        }\n                    } else {\n                        isInterrupted = false;\n                    }\n                }\n            } catch {\n                continue;\n            }\n        }\n\n        return {\n            sessionId,\n            projectPath: projectPath || lastCwd || '',\n            lastCwd,\n            sessionStart: sessionStart || lastActive || new Date(),\n            lastActive: lastActive || new Date(),\n            lastEntryType,\n            isInterrupted,\n            lastUserMessage,\n            firstUserMessage,\n        };\n    }\n\n    /**\n     * Determine agent status from parsed session state.\n     *\n     * Status mapping:\n     * - \"user\" + interrupted → WAITING (agent finished, awaiting new input)\n     * - \"user\" + not interrupted → RUNNING (agent is processing)\n     * - \"progress\" / \"thinking\" → RUNNING\n     * - \"assistant\" → WAITING (agent responded, awaiting user)\n     * - \"system\" → IDLE\n     */\n    determineStatus(session: ClaudeSession): AgentStatus {\n        if (!session.lastEntryType) {\n            return AgentStatus.UNKNOWN;\n        }\n\n        if (session.lastEntryType === 'user') {\n            return session.isInterrupted\n                ? AgentStatus.WAITING\n                : AgentStatus.RUNNING;\n        }\n\n        if (\n            session.lastEntryType === 'progress' ||\n            session.lastEntryType === 'thinking'\n        ) {\n            return AgentStatus.RUNNING;\n        }\n\n        if (session.lastEntryType === 'assistant') {\n            return AgentStatus.WAITING;\n        }\n\n        if (session.lastEntryType === 'system') {\n            return AgentStatus.IDLE;\n        }\n\n        return AgentStatus.UNKNOWN;\n    }\n\n    /**\n     * Read the full conversation from a session JSONL file.\n     *\n     * Default mode returns only text content from user/assistant/system messages.\n     * Verbose mode also includes tool_use and tool_result blocks.\n     */\n    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {\n        const verbose = options?.verbose ?? false;\n\n        let content: string;\n        try {\n            content = fs.readFileSync(sessionFilePath, 'utf-8');\n        } catch {\n            return [];\n        }\n\n        const lines = content.trim().split('\\n');\n        const messages: ConversationMessage[] = [];\n\n        for (const line of lines) {\n            let entry: SessionEntry;\n            try {\n                entry = JSON.parse(line);\n            } catch {\n                continue;\n            }\n\n            let role: ConversationMessage['role'];\n            if (entry.type === 'user') {\n                role = 'user';\n            } else if (entry.type === 'assistant') {\n                role = 'assistant';\n            } else if (entry.type === 'system') {\n                role = 'system';\n            } else {\n                continue;\n            }\n\n            const text = this.extractConversationContent(entry.message?.content, role, verbose);\n            if (!text) continue;\n\n            messages.push({\n                role,\n                content: text,\n                timestamp: entry.timestamp,\n            });\n        }\n\n        return messages;\n    }\n\n    /**\n     * Parse session start time from the first JSONL line.\n     *\n     * Claude Code may emit a \"file-history-snapshot\" as the first entry,\n     * which stores its timestamp inside \"snapshot.timestamp\" rather than\n     * at the root level.\n     */\n    private parseSessionStart(firstLine: string): Date | null {\n        try {\n            const firstEntry = JSON.parse(firstLine);\n            const rawTs: string | undefined =\n                firstEntry.timestamp || firstEntry.snapshot?.timestamp;\n            if (rawTs) {\n                const ts = new Date(rawTs);\n                if (!Number.isNaN(ts.getTime())) {\n                    return ts;\n                }\n            }\n        } catch {\n            /* malformed first line */\n        }\n        return null;\n    }\n\n    /**\n     * Extract meaningful text from a user message content field.\n     *\n     * Handles multiple formats:\n     * - Plain string content\n     * - Array of content blocks (extracts first text block)\n     * - Skill slash-commands (<command-message> tags)\n     * - Expanded skill content (extracts ARGUMENTS line)\n     * - Filters noise messages (interruptions, tool loaded, session continued)\n     */\n    private extractUserMessageText(\n        content: string | Array<{ type?: string; text?: string }> | undefined,\n    ): string | undefined {\n        if (!content) {\n            return undefined;\n        }\n\n        let raw: string | undefined;\n\n        if (typeof content === 'string') {\n            raw = content.trim();\n        } else if (Array.isArray(content)) {\n            for (const block of content) {\n                if (block.type === 'text' && block.text?.trim()) {\n                    raw = block.text.trim();\n                    break;\n                }\n            }\n        }\n\n        if (!raw) {\n            return undefined;\n        }\n\n        if (raw.startsWith('<command-message>')) {\n            return this.parseCommandMessage(raw);\n        }\n\n        if (raw.startsWith('Base directory for this skill:')) {\n            const argsMatch = raw.match(/\\nARGUMENTS:\\s*(.+)/);\n            return argsMatch?.[1]?.trim() || undefined;\n        }\n\n        if (isNoiseMessage(raw)) {\n            return undefined;\n        }\n\n        return raw;\n    }\n\n    /**\n     * Parse a <command-message> string into \"/command args\" format.\n     */\n    private parseCommandMessage(raw: string): string | undefined {\n        const nameMatch = raw.match(/<command-name>([^<]+)<\\/command-name>/);\n        const argsMatch = raw.match(/<command-args>([^<]+)<\\/command-args>/);\n        const name = nameMatch?.[1]?.trim();\n        if (!name) {\n            return undefined;\n        }\n        const args = argsMatch?.[1]?.trim();\n        return args ? `${name} ${args}` : name;\n    }\n\n    /**\n     * Extract displayable content from a message content field for conversation output.\n     */\n    private extractConversationContent(\n        content: string | ContentBlock[] | undefined,\n        role: ConversationMessage['role'],\n        verbose: boolean,\n    ): string | undefined {\n        if (!content) return undefined;\n\n        if (typeof content === 'string') {\n            const cleaned = stripHarnessTags(content);\n            if (role === 'user' && isNoiseMessage(cleaned)) return undefined;\n            return cleaned || undefined;\n        }\n\n        if (!Array.isArray(content)) return undefined;\n\n        const parts: string[] = [];\n\n        for (const block of content) {\n            if (block.type === 'text' && block.text?.trim()) {\n                const cleaned = stripHarnessTags(block.text);\n                if (!cleaned) continue;\n                if (role === 'user' && isNoiseMessage(cleaned)) continue;\n                parts.push(cleaned);\n            } else if (block.type === 'tool_use' && verbose) {\n                const inputSummary = block.input?.file_path || block.input?.pattern || block.input?.command || '';\n                parts.push(`[Tool: ${block.name}]${inputSummary ? ' ' + inputSummary : ''}`);\n            } else if (block.type === 'tool_result' && verbose) {\n                const truncated = truncateToolResult(block.content || '');\n                const prefix = block.is_error ? '[Tool Error]' : '[Tool Result]';\n                parts.push(`${prefix} ${truncated}`);\n            }\n        }\n\n        return parts.length > 0 ? parts.join('\\n') : undefined;\n    }\n}\n\n/**\n * Tags whose entire block (including content) should be dropped — they are\n * harness-injected prompt context (system reminders, hook output, command\n * stdout), not meaningful conversation content.\n */\nconst HARNESS_DROP_TAGS = [\n    'system-reminder',\n    'local-command-stdout',\n    'local-command-stderr',\n    'user-prompt-submit-hook',\n    'command-stdout',\n    'command-stderr',\n    'bash-input',\n    'bash-stdout',\n    'bash-stderr',\n    'command-message',\n] as const;\n\nconst HARNESS_DROP_RE = new RegExp(\n    `<(${HARNESS_DROP_TAGS.join('|')})>[\\\\s\\\\S]*?</\\\\1>`,\n    'g',\n);\n\nconst COMMAND_INVOCATION_RE =\n    /<command-name>([^<]+)<\\/command-name>(?:\\s*<command-args>([\\s\\S]*?)<\\/command-args>)?/g;\n\n/**\n * Remove harness-injected XML blocks from message text and collapse\n * <command-name>/<command-args> pairs into a \"/name args\" shorthand.\n *\n * Returns the cleaned, trimmed text. Returns an empty string if nothing\n * survives stripping.\n */\nfunction stripHarnessTags(text: string): string {\n    let out = text.replace(HARNESS_DROP_RE, '');\n\n    out = out.replace(COMMAND_INVOCATION_RE, (_match, rawName: string, rawArgs?: string) => {\n        const name = rawName.trim();\n        const args = rawArgs?.trim();\n        return args ? `${name} ${args}` : name;\n    });\n\n    return out.replace(/\\n{3,}/g, '\\n\\n').trim();\n}\n\n/** Check if a message is noise (not a meaningful user intent). */\nfunction isNoiseMessage(text: string): boolean {\n    return (\n        text.startsWith('[Request interrupted') ||\n        text === 'Tool loaded.' ||\n        text.startsWith('This session is being continued')\n    );\n}\n\nfunction truncateToolResult(content: string, maxLength = 200): string {\n    const firstLine = content.split('\\n')[0] || '';\n    if (firstLine.length <= maxLength) return firstLine;\n    return firstLine.slice(0, maxLength - 3) + '...';\n}\n"],"names":["fs","path","AgentStatus","CONVERSATION_ENTRY_TYPES","Set","ClaudeSessionParser","readSession","filePath","projectPath","sessionId","basename","content","readFileSync","allLines","trim","split","length","sessionStart","parseSessionStart","lastEntryType","lastActive","lastCwd","isInterrupted","lastUserMessage","firstUserMessage","line","entry","JSON","parse","timestamp","ts","Date","Number","isNaN","getTime","cwd","type","has","msgContent","message","Array","isArray","some","c","text","includes","extractUserMessageText","determineStatus","session","UNKNOWN","WAITING","RUNNING","IDLE","getConversation","sessionFilePath","options","verbose","lines","messages","role","extractConversationContent","push","firstLine","firstEntry","rawTs","snapshot","undefined","raw","block","startsWith","parseCommandMessage","argsMatch","match","isNoiseMessage","nameMatch","name","args","cleaned","stripHarnessTags","parts","inputSummary","input","file_path","pattern","command","truncated","truncateToolResult","prefix","is_error","join","HARNESS_DROP_TAGS","HARNESS_DROP_RE","RegExp","COMMAND_INVOCATION_RE","out","replace","_match","rawName","rawArgs","maxLength","slice"],"mappings":"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"}

package/dist/providers/claude/durable/ClaudeCliProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeCliProbe.d.ts","sourceRoot":"","sources":["../../../../src/providers/claude/durable/ClaudeCliProbe.ts"],"names":[],"mappings":"AAKA,KAAK,UAAU,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACrD,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAKlE,MAAM,WAAW,qBAAqB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,IAAI,CAAC;CACf;AAED,qBAAa,cAAc;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAO;gBAEhB,OAAO,GAAE,qBAA0B;IAQzC,QAAQ,IAAI,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAuBrE"}

package/dist/{durable → providers/claude/durable}/ClaudeCliProbe.js

@@ -1,6 +1,7 @@
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { ClaudePrintError } from './DurableAgent.js';
+import { ClaudePrintError } from '../../../durable/DurableAgent.js';
+import { sanitizeText } from '../../../durable/utils.js';
 const execFileAsync = promisify(execFile);
 const REQUIRED = [
     '--print',
@@ -39,19 +40,13 @@ export class ClaudeCliProbe {
             }
             return {
                 executable: this.executable,
-                version: sanitize(versionResult.stdout, 256) || 'unknown'
+                version: sanitizeText(versionResult.stdout, 256) || 'unknown'
             };
         } catch (error) {
             if (error instanceof ClaudePrintError) throw error;
-            throw new ClaudePrintError(`Claude CLI validation failed: ${sanitize(error.message, 512)}`, 'CLAUDE_CLI_UNAVAILABLE');
+            throw new ClaudePrintError(`Claude CLI validation failed: ${sanitizeText(error.message, 512)}`, 'CLAUDE_CLI_UNAVAILABLE');
         }
     }
 }
-function sanitize(value, max) {
-    return Array.from(value, (character)=>{
-        const code = character.charCodeAt(0);
-        return code <= 31 || code === 127 ? ' ' : character;
-    }).join('').trim().slice(0, max);
-}
 
 //# sourceMappingURL=ClaudeCliProbe.js.map

package/dist/providers/claude/durable/ClaudeCliProbe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/providers/claude/durable/ClaudeCliProbe.ts"],"sourcesContent":["import { execFile } from 'child_process';\nimport { promisify } from 'util';\nimport { ClaudePrintError } from '../../../durable/DurableAgent.js';\nimport { sanitizeText } from '../../../durable/utils.js';\n\ntype ExecResult = { stdout: string; stderr: string };\ntype Exec = (file: string, args: string[]) => Promise<ExecResult>;\n\nconst execFileAsync = promisify(execFile);\nconst REQUIRED = ['--print', '--session-id', '--resume', '--output-format', 'stream-json'];\n\nexport interface ClaudeCliProbeOptions {\n    executable?: string;\n    exec?: Exec;\n}\n\nexport class ClaudeCliProbe {\n    private readonly executable: string;\n    private readonly exec: Exec;\n\n    constructor(options: ClaudeCliProbeOptions = {}) {\n        this.executable = options.executable ?? 'claude';\n        this.exec = options.exec ?? (async (file, args) => {\n            const result = await execFileAsync(file, args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });\n            return { stdout: result.stdout, stderr: result.stderr };\n        });\n    }\n\n    async validate(): Promise<{ executable: string; version: string }> {\n        try {\n            const versionResult = await this.exec(this.executable, ['--version']);\n            const helpResult = await this.exec(this.executable, ['--help']);\n            const missing = REQUIRED.filter((capability) => !helpResult.stdout.includes(capability));\n            if (missing.length > 0) {\n                throw new ClaudePrintError(\n                    `Claude CLI does not support required print-mode capabilities: ${missing.join(', ')}.`,\n                    'CLAUDE_CLI_UNSUPPORTED',\n                );\n            }\n            return {\n                executable: this.executable,\n                version: sanitizeText(versionResult.stdout, 256) || 'unknown',\n            };\n        } catch (error) {\n            if (error instanceof ClaudePrintError) throw error;\n            throw new ClaudePrintError(\n                `Claude CLI validation failed: ${sanitizeText((error as Error).message, 512)}`,\n                'CLAUDE_CLI_UNAVAILABLE',\n            );\n        }\n    }\n}\n"],"names":["execFile","promisify","ClaudePrintError","sanitizeText","execFileAsync","REQUIRED","ClaudeCliProbe","executable","exec","options","file","args","result","encoding","maxBuffer","stdout","stderr","validate","versionResult","helpResult","missing","filter","capability","includes","length","join","version","error","message"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,gBAAgB;AACzC,SAASC,SAAS,QAAQ,OAAO;AACjC,SAASC,gBAAgB,QAAQ,mCAAmC;AACpE,SAASC,YAAY,QAAQ,4BAA4B;AAKzD,MAAMC,gBAAgBH,UAAUD;AAChC,MAAMK,WAAW;IAAC;IAAW;IAAgB;IAAY;IAAmB;CAAc;AAO1F,OAAO,MAAMC;IACQC,WAAmB;IACnBC,KAAW;IAE5B,YAAYC,UAAiC,CAAC,CAAC,CAAE;QAC7C,IAAI,CAACF,UAAU,GAAGE,QAAQF,UAAU,IAAI;QACxC,IAAI,CAACC,IAAI,GAAGC,QAAQD,IAAI,IAAK,CAAA,OAAOE,MAAMC;YACtC,MAAMC,SAAS,MAAMR,cAAcM,MAAMC,MAAM;gBAAEE,UAAU;gBAAQC,WAAW,OAAO;YAAK;YAC1F,OAAO;gBAAEC,QAAQH,OAAOG,MAAM;gBAAEC,QAAQJ,OAAOI,MAAM;YAAC;QAC1D,CAAA;IACJ;IAEA,MAAMC,WAA6D;QAC/D,IAAI;YACA,MAAMC,gBAAgB,MAAM,IAAI,CAACV,IAAI,CAAC,IAAI,CAACD,UAAU,EAAE;gBAAC;aAAY;YACpE,MAAMY,aAAa,MAAM,IAAI,CAACX,IAAI,CAAC,IAAI,CAACD,UAAU,EAAE;gBAAC;aAAS;YAC9D,MAAMa,UAAUf,SAASgB,MAAM,CAAC,CAACC,aAAe,CAACH,WAAWJ,MAAM,CAACQ,QAAQ,CAACD;YAC5E,IAAIF,QAAQI,MAAM,GAAG,GAAG;gBACpB,MAAM,IAAItB,iBACN,CAAC,8DAA8D,EAAEkB,QAAQK,IAAI,CAAC,MAAM,CAAC,CAAC,EACtF;YAER;YACA,OAAO;gBACHlB,YAAY,IAAI,CAACA,UAAU;gBAC3BmB,SAASvB,aAAae,cAAcH,MAAM,EAAE,QAAQ;YACxD;QACJ,EAAE,OAAOY,OAAO;YACZ,IAAIA,iBAAiBzB,kBAAkB,MAAMyB;YAC7C,MAAM,IAAIzB,iBACN,CAAC,8BAA8B,EAAEC,aAAa,AAACwB,MAAgBC,OAAO,EAAE,MAAM,EAC9E;QAER;IACJ;AACJ"}

package/dist/{durable → providers/claude/durable}/ClaudePrintAgentService.d.ts

@@ -1,16 +1,11 @@
-import type { DurableAgent, ProcessIdentity } from './DurableAgent.js';
+import type { DurableAgent, ProcessIdentity } from '../../../durable/DurableAgent.js';
 import { ClaudePrintRunner, type ClaudePrintRunResult } from './ClaudePrintRunner.js';
-import { type CreateDurableAgentInput, type DurableRunCompletion } from './DurableAgentRepository.js';
-interface RepositoryLike {
+import { type CreateDurableAgentInput } from '../../../durable/DurableAgentRepository.js';
+import { type DurableRunRepository } from '../../../durable/run.js';
+interface RepositoryLike extends DurableRunRepository {
     create(input: CreateDurableAgentInput): Promise<DurableAgent>;
     list(): Promise<DurableAgent[]>;
-    resolve(reference: string): Promise<DurableAgent | DurableAgent[] | null>;
-    acquireRun(id: string): Promise<{
-        agent: DurableAgent;
-        token: string;
-    }>;
     recordProviderProcess(id: string, token: string, identity: ProcessIdentity): Promise<void>;
-    completeRun(id: string, token: string, result: DurableRunCompletion): Promise<DurableAgent>;
 }
 interface ProbeLike {
     validate(): Promise<{