@ai-devkit/agent-manager 0.28.1 → 0.30.0

package/src/providers/pi/durable/PiPrintRunner.ts

@@ -0,0 +1,88 @@
+import { spawn as nodeSpawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'child_process';
+import type { PiDurableAgent, ProcessIdentity } from '../../../durable/DurableAgent.js';
+import { PiPrintError } from '../../../durable/DurableAgent.js';
+import { LocalProcessInspector, type ProcessInspector } from '../../../durable/process.js';
+import { waitForChildClose } from '../../../durable/utils.js';
+import { buildPiPrintArgs } from './PiPrintProtocol.js';
+import { PiStreamParser } from './PiStreamParser.js';
+
+type Spawn = (
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithoutStdio & { stdio: ['pipe', 'pipe', 'pipe'] },
+) => ChildProcessWithoutNullStreams;
+
+export interface PiPrintRunRequest {
+    agent: PiDurableAgent;
+    prompt: string;
+    executable?: string;
+    onSpawn(identity: ProcessIdentity): Promise<void>;
+}
+
+export interface PiPrintRunResult {
+    sessionId: string;
+    result: string;
+    messages: string[];
+    exitCode: number;
+}
+
+export interface PiPrintRunnerOptions {
+    spawn?: Spawn;
+    processInspector?: ProcessInspector;
+    maxLineBytes?: number;
+}
+
+export class PiPrintRunner {
+    private readonly spawn: Spawn;
+    private readonly processInspector: ProcessInspector;
+    private readonly maxLineBytes: number;
+
+    constructor(options: PiPrintRunnerOptions = {}) {
+        this.spawn = options.spawn ?? (nodeSpawn as Spawn);
+        this.processInspector = options.processInspector ?? new LocalProcessInspector();
+        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
+    }
+
+    async run(request: PiPrintRunRequest): Promise<PiPrintRunResult> {
+        const args = buildPiPrintArgs(request.agent.providerSessionId, request.agent.sessionHealth === 'uninitialized');
+        const child = this.spawn(request.executable ?? 'pi', args, {
+            cwd: request.agent.cwd,
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (!child.pid) {
+            child.kill();
+            throw new PiPrintError('Pi process did not provide a PID.', 'PI_PROCESS');
+        }
+        const identity = this.processInspector.getIdentity(child.pid);
+        if (!identity) {
+            child.kill();
+            throw new PiPrintError('Cannot verify Pi process identity.', 'PI_PROCESS');
+        }
+
+        const parser = new PiStreamParser(request.agent.providerSessionId, this.maxLineBytes);
+        child.stdout.on('data', (chunk: Buffer | string) => {
+            if (parser.hasFailed()) return;
+            try {
+                parser.accept(chunk);
+            } catch (error) {
+                parser.fail(error);
+            }
+        });
+        child.stderr.resume();
+
+        const closed = waitForChildClose(child);
+        try {
+            await request.onSpawn(identity);
+        } catch (error) {
+            child.kill();
+            throw error;
+        }
+
+        child.stdin.end(request.prompt);
+        const close = await closed.catch(() => {
+            throw new PiPrintError('Pi process failed to start or communicate.', 'PI_PROCESS');
+        });
+        return parser.result(close);
+    }
+}

package/src/providers/pi/durable/PiStreamParser.ts

@@ -0,0 +1,84 @@
+import { PiPrintError } from '../../../durable/DurableAgent.js';
+import { LineBuffer, type ChildCloseResult } from '../../../durable/utils.js';
+import { readPiAssistantText, readPiSessionId } from './PiPrintProtocol.js';
+
+export class PiStreamParser {
+    private readonly lines: LineBuffer;
+    private sessionId: string | null = null;
+    private ended = false;
+    private readonly messages: string[] = [];
+    private failure: PiPrintError | null = null;
+
+    constructor(
+        private readonly expectedSessionId: string,
+        maxLineBytes: number,
+    ) {
+        this.lines = new LineBuffer(
+            maxLineBytes,
+            () => new PiPrintError('Pi stream line exceeded the safety limit.', 'PI_PROTOCOL'),
+        );
+    }
+
+    hasFailed(): boolean {
+        return this.failure !== null;
+    }
+
+    accept(chunk: Buffer | string): void {
+        for (const line of this.lines.accept(chunk)) {
+            if (line.length === 0) continue;
+            this.acceptLine(line);
+        }
+    }
+
+    fail(error: unknown): void {
+        this.failure = error instanceof PiPrintError
+            ? error
+            : new PiPrintError('Pi stream processing failed.', 'PI_PROTOCOL');
+    }
+
+    result(close: ChildCloseResult): { sessionId: string; result: string; messages: string[]; exitCode: number } {
+        if (this.failure) throw this.failure;
+        this.lines.assertComplete(
+            () => new PiPrintError('Pi stream ended with incomplete JSON.', 'PI_PROTOCOL'),
+        );
+        if (close.code !== 0) {
+            throw new PiPrintError(`Pi print run failed${close.signal ? ` (${close.signal})` : '.'}`, 'PI_PROCESS');
+        }
+        if (this.sessionId === null) {
+            throw new PiPrintError('Pi stream ended without a session identity.', 'PI_PROTOCOL');
+        }
+        if (!this.ended) throw new PiPrintError('Pi stream ended before agent completion.', 'PI_PROTOCOL');
+        if (this.messages.length === 0) {
+            throw new PiPrintError('Pi stream ended without an assistant result.', 'PI_RESULT_MISSING');
+        }
+        return {
+            sessionId: this.sessionId,
+            result: this.messages.at(-1)!,
+            messages: this.messages,
+            exitCode: close.code,
+        };
+    }
+
+    private acceptLine(line: Buffer): void {
+        let value: unknown;
+        try {
+            value = JSON.parse(line.toString('utf8'));
+        } catch {
+            throw new PiPrintError('Pi emitted malformed stream JSON.', 'PI_PROTOCOL');
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new PiPrintError('Pi emitted a non-object stream message.', 'PI_PROTOCOL');
+        }
+        const event = value as Record<string, unknown>;
+        if (event.type === 'session') {
+            this.sessionId = readPiSessionId(event, this.sessionId, this.expectedSessionId);
+            return;
+        }
+        if (event.type === 'agent_end') {
+            this.ended = true;
+            return;
+        }
+        const text = readPiAssistantText(event);
+        if (text !== null) this.messages.push(text);
+    }
+}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ClaudeCodeAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/ClaudeCodeAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,YAAY,EACZ,SAAS,EACT,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACxB,MAAM,mBAAmB,CAAC;AAiD3B;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAClC,QAAQ,CAAC,YAAY,sBAAuB;IAE5C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAsB;;IASpC,SAAS,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAI5C,OAAO,CAAC,kBAAkB;IAKpB,YAAY,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAqEzE;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;;;;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;IAuC1B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,mBAAmB;IAa3B,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,mBAAmB,EAAE;IAI1F,YAAY,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAkCzE;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;CAqB/B"}

package/dist/adapters/ClaudeCodeAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/adapters/ClaudeCodeAdapter.ts"],"sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type {\n    AgentAdapter,\n    AgentInfo,\n    ProcessInfo,\n    ConversationMessage,\n    SessionSummary,\n    ListSessionsOptions,\n    AgentDetectionContext,\n} from './AgentAdapter.js';\nimport { AgentStatus } from './AgentAdapter.js';\nimport { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';\nimport { batchGetSessionFileBirthtimes, isDirectory, listJsonl, safeReaddir, safeStat } from '../utils/session.js';\nimport type { SessionFile } from '../utils/session.js';\nimport { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';\nimport { ClaudeSessionParser } from '../utils/ClaudeSessionParser.js';\nimport type { ClaudeSession } from '../utils/ClaudeSessionParser.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 `mapSessionToAgent` can prefer them\n * over the JSONL-derived heuristic.\n */\ninterface DirectMatch {\n    process: ProcessInfo;\n    sessionFile: SessionFile;\n    pidStatus?: AgentStatus;\n    waitingFor?: string;\n}\n\n/** Maximum allowed delta (ms) between process start time and PID file startedAt. */\nconst PID_FILE_STALENESS_MS = 60000;\n\n/**\n * Claude Code Adapter\n *\n * Detects Claude Code agents by:\n * 1. Filtering Claude processes from a shared asynchronous process snapshot\n * 2. Using snapshot CWD and start-time enrichment\n * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json\n * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file\n * 5. Extracting summary from last user message in session JSONL\n */\nexport class ClaudeCodeAdapter implements AgentAdapter {\n    readonly type = 'claude' as const;\n    readonly processNames = ['claude'] as const;\n\n    private projectsDir: string;\n    private sessionsDir: string;\n    private parser: ClaudeSessionParser;\n\n    constructor() {\n        const homeDir = process.env.HOME || process.env.USERPROFILE || '';\n        this.projectsDir = path.join(homeDir, '.claude', 'projects');\n        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');\n        this.parser = new ClaudeSessionParser();\n    }\n\n    canHandle(processInfo: ProcessInfo): boolean {\n        return this.isClaudeExecutable(processInfo.command);\n    }\n\n    private isClaudeExecutable(command: string): boolean {\n        const base = executableBasename(command);\n        return base === 'claude' || base === 'claude.exe';\n    }\n\n    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {\n        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);\n        const relevant = filterByProcessNames(snapshot, this.processNames);\n        const processes = relevant.filter((process) => this.canHandle(process));\n        if (processes.length === 0) {\n            return [];\n        }\n\n        // Step 1: extract `--resume <id>` from command line — authoritative for\n        // resumed sessions where the JSONL predates the process and PID-file/\n        // birthtime heuristics can't match it.\n        const { direct: resumeDirect, fallback: noResume } = this.tryResumeMatching(processes);\n\n        // Step 2: try authoritative PID-file matching for the rest\n        const { direct: pidDirect, fallback } = this.tryPidFileMatching(noResume);\n\n        const direct = [...resumeDirect, ...pidDirect];\n\n        // Step 3: run legacy CWD+birthtime matching only for processes without a PID file\n        const legacySessions = this.discoverSessions(fallback);\n        const legacyMatches =\n            fallback.length > 0 && legacySessions.length > 0\n                ? matchProcessesToSessions(fallback, legacySessions)\n                : [];\n\n        const matchedPids = new Set([\n            ...direct.map((d) => d.process.pid),\n            ...legacyMatches.map((m) => m.process.pid),\n        ]);\n\n        const agents: AgentInfo[] = [];\n\n        // Build agents from direct (resume + PID-file) matches\n        for (const match of direct) {\n            const { process: proc, sessionFile } = match;\n            const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);\n            if (sessionData) {\n                agents.push(this.mapSessionToAgent(sessionData, proc, sessionFile, {\n                    pidStatus: match.pidStatus,\n                    waitingFor: match.waitingFor,\n                }));\n            } else {\n                matchedPids.delete(proc.pid);\n            }\n        }\n\n        // Build agents from legacy matches\n        for (const match of legacyMatches) {\n            const sessionData = this.parser.readSession(\n                match.session.filePath,\n                match.session.resolvedCwd,\n            );\n            if (sessionData) {\n                agents.push(this.mapSessionToAgent(sessionData, match.process, match.session));\n            } else {\n                matchedPids.delete(match.process.pid);\n            }\n        }\n\n        // Any process with no match (direct or legacy) appears as IDLE\n        for (const proc of processes) {\n            if (!matchedPids.has(proc.pid)) {\n                agents.push(this.mapProcessOnlyAgent(proc));\n            }\n        }\n\n        return agents;\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    private discoverSessions(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: DirectMatch[];\n        fallback: ProcessInfo[];\n    } {\n        const direct: DirectMatch[] = [];\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: DirectMatch[];\n        fallback: ProcessInfo[];\n    } {\n        const direct: DirectMatch[] = [];\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    /**\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    private mapSessionToAgent(\n        session: ClaudeSession,\n        processInfo: ProcessInfo,\n        sessionFile: SessionFile,\n        liveInfo?: { pidStatus?: AgentStatus; waitingFor?: string },\n    ): AgentInfo {\n        // Live PID-file status is authoritative when present — JSONL-derived\n        // status mis-classifies sessions whose latest entry is a UI-state\n        // event like `permission-mode` or `ai-title`.\n        const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);\n        const baseSummary = session.lastUserMessage || 'Session started';\n        const summary = status === AgentStatus.WAITING && liveInfo?.waitingFor\n            ? `${baseSummary} — waiting for ${liveInfo.waitingFor}`\n            : baseSummary;\n\n        return {\n            name: generateAgentName(processInfo.cwd, processInfo.pid),\n            type: this.type,\n            status,\n            summary,\n            pid: processInfo.pid,\n            projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',\n            sessionId: sessionFile.sessionId,\n            lastActive: session.lastActive,\n            sessionFilePath: sessionFile.filePath,\n        };\n    }\n\n    private mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {\n        return {\n            name: generateAgentName(processInfo.cwd || '', processInfo.pid),\n            type: this.type,\n            status: AgentStatus.IDLE,\n            summary: 'Unknown',\n            pid: processInfo.pid,\n            projectPath: processInfo.cwd || '',\n            sessionId: `pid-${processInfo.pid}`,\n            lastActive: new Date(),\n        };\n    }\n\n    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {\n        return this.parser.getConversation(sessionFilePath, options);\n    }\n\n    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {\n        const filterCwd = opts?.cwd;\n        const candidates = this.discoverSessionFiles();\n        const summaries: SessionSummary[] = [];\n\n        for (const { filePath, defaultCwd } of candidates) {\n            const session = this.parser.readSession(filePath, defaultCwd);\n            if (!session) continue;\n\n            // Drop sessions whose JSONL had no parseable conversation entries.\n            // readSession is permissive (returns a shell record even when every\n            // line fails to parse); listSessions needs at least one real entry\n            // so we don't surface garbage files.\n            if (!session.lastEntryType) continue;\n\n            const recordedCwd = session.lastCwd || defaultCwd;\n            if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;\n\n            const stat = safeStat(filePath);\n\n            summaries.push({\n                type: 'claude',\n                sessionId: session.sessionId,\n                cwd: recordedCwd,\n                firstUserMessage: session.firstUserMessage || '',\n                lastActive: session.lastActive ?? stat?.mtime ?? new Date(),\n                startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),\n                sessionFilePath: filePath,\n            });\n        }\n\n        return summaries;\n    }\n\n    /**\n     * Discover candidate session files for {@link listSessions}.\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    private discoverSessionFiles(): 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"],"names":["fs","path","AgentStatus","captureProcessSnapshot","executableBasename","filterByProcessNames","batchGetSessionFileBirthtimes","isDirectory","listJsonl","safeReaddir","safeStat","matchProcessesToSessions","generateAgentName","ClaudeSessionParser","PID_FILE_STALENESS_MS","ClaudeCodeAdapter","type","processNames","projectsDir","sessionsDir","parser","homeDir","process","env","HOME","USERPROFILE","join","canHandle","processInfo","isClaudeExecutable","command","base","detectAgents","context","snapshot","processes","relevant","filter","length","direct","resumeDirect","fallback","noResume","tryResumeMatching","pidDirect","tryPidFileMatching","legacySessions","discoverSessions","legacyMatches","matchedPids","Set","map","d","pid","m","agents","match","proc","sessionFile","sessionData","readSession","filePath","resolvedCwd","push","mapSessionToAgent","pidStatus","waitingFor","delete","session","has","mapProcessOnlyAgent","dirToCwd","Map","cwd","projectDir","getProjectDir","statSync","set","size","files","keys","file","get","sessionId","extractResumeSessionId","jsonlPath","stat","pidEntry","readMatchingPidFile","startTime","birthtimeMs","mapPidStatus","status","procStartTime","pidFilePath","entry","JSON","parse","readFileSync","deltaMs","Math","abs","getTime","startedAt","RUNNING","WAITING","IDLE","undefined","existsSync","encoded","replace","liveInfo","determineStatus","baseSummary","lastUserMessage","summary","name","projectPath","lastActive","sessionFilePath","Date","getConversation","options","listSessions","opts","filterCwd","candidates","discoverSessionFiles","summaries","defaultCwd","lastEntryType","recordedCwd","lastCwd","firstUserMessage","mtime","sessionStart","birthtime","out","dirName","decoded"],"mappings":"AAAA,YAAYA,QAAQ,KAAK;AACzB,YAAYC,UAAU,OAAO;AAU7B,SAASC,WAAW,QAAQ,oBAAoB;AAChD,SAASC,sBAAsB,EAAEC,kBAAkB,EAAEC,oBAAoB,QAAQ,sBAAsB;AACvG,SAASC,6BAA6B,EAAEC,WAAW,EAAEC,SAAS,EAAEC,WAAW,EAAEC,QAAQ,QAAQ,sBAAsB;AAEnH,SAASC,wBAAwB,EAAEC,iBAAiB,QAAQ,uBAAuB;AACnF,SAASC,mBAAmB,QAAQ,kCAAkC;AAwCtE,kFAAkF,GAClF,MAAMC,wBAAwB;AAE9B;;;;;;;;;CASC,GACD,OAAO,MAAMC;IACAC,OAAO,SAAkB;IACzBC,eAAe;QAAC;KAAS,CAAU;IAEpCC,YAAoB;IACpBC,YAAoB;IACpBC,OAA4B;IAEpC,aAAc;QACV,MAAMC,UAAUC,QAAQC,GAAG,CAACC,IAAI,IAAIF,QAAQC,GAAG,CAACE,WAAW,IAAI;QAC/D,IAAI,CAACP,WAAW,GAAGjB,KAAKyB,IAAI,CAACL,SAAS,WAAW;QACjD,IAAI,CAACF,WAAW,GAAGlB,KAAKyB,IAAI,CAACL,SAAS,WAAW;QACjD,IAAI,CAACD,MAAM,GAAG,IAAIP;IACtB;IAEAc,UAAUC,WAAwB,EAAW;QACzC,OAAO,IAAI,CAACC,kBAAkB,CAACD,YAAYE,OAAO;IACtD;IAEQD,mBAAmBC,OAAe,EAAW;QACjD,MAAMC,OAAO3B,mBAAmB0B;QAChC,OAAOC,SAAS,YAAYA,SAAS;IACzC;IAEA,MAAMC,aAAaC,OAA+B,EAAwB;QACtE,MAAMC,WAAWD,SAASE,aAAa,MAAMhC,uBAAuB,IAAI,CAACc,YAAY;QACrF,MAAMmB,WAAW/B,qBAAqB6B,UAAU,IAAI,CAACjB,YAAY;QACjE,MAAMkB,YAAYC,SAASC,MAAM,CAAC,CAACf,WAAY,IAAI,CAACK,SAAS,CAACL;QAC9D,IAAIa,UAAUG,MAAM,KAAK,GAAG;YACxB,OAAO,EAAE;QACb;QAEA,wEAAwE;QACxE,sEAAsE;QACtE,uCAAuC;QACvC,MAAM,EAAEC,QAAQC,YAAY,EAAEC,UAAUC,QAAQ,EAAE,GAAG,IAAI,CAACC,iBAAiB,CAACR;QAE5E,2DAA2D;QAC3D,MAAM,EAAEI,QAAQK,SAAS,EAAEH,QAAQ,EAAE,GAAG,IAAI,CAACI,kBAAkB,CAACH;QAEhE,MAAMH,SAAS;eAAIC;eAAiBI;SAAU;QAE9C,kFAAkF;QAClF,MAAME,iBAAiB,IAAI,CAACC,gBAAgB,CAACN;QAC7C,MAAMO,gBACFP,SAASH,MAAM,GAAG,KAAKQ,eAAeR,MAAM,GAAG,IACzC3B,yBAAyB8B,UAAUK,kBACnC,EAAE;QAEZ,MAAMG,cAAc,IAAIC,IAAI;eACrBX,OAAOY,GAAG,CAAC,CAACC,IAAMA,EAAE9B,OAAO,CAAC+B,GAAG;eAC/BL,cAAcG,GAAG,CAAC,CAACG,IAAMA,EAAEhC,OAAO,CAAC+B,GAAG;SAC5C;QAED,MAAME,SAAsB,EAAE;QAE9B,uDAAuD;QACvD,KAAK,MAAMC,SAASjB,OAAQ;YACxB,MAAM,EAAEjB,SAASmC,IAAI,EAAEC,WAAW,EAAE,GAAGF;YACvC,MAAMG,cAAc,IAAI,CAACvC,MAAM,CAACwC,WAAW,CAACF,YAAYG,QAAQ,EAAEH,YAAYI,WAAW;YACzF,IAAIH,aAAa;gBACbJ,OAAOQ,IAAI,CAAC,IAAI,CAACC,iBAAiB,CAACL,aAAaF,MAAMC,aAAa;oBAC/DO,WAAWT,MAAMS,SAAS;oBAC1BC,YAAYV,MAAMU,UAAU;gBAChC;YACJ,OAAO;gBACHjB,YAAYkB,MAAM,CAACV,KAAKJ,GAAG;YAC/B;QACJ;QAEA,mCAAmC;QACnC,KAAK,MAAMG,SAASR,cAAe;YAC/B,MAAMW,cAAc,IAAI,CAACvC,MAAM,CAACwC,WAAW,CACvCJ,MAAMY,OAAO,CAACP,QAAQ,EACtBL,MAAMY,OAAO,CAACN,WAAW;YAE7B,IAAIH,aAAa;gBACbJ,OAAOQ,IAAI,CAAC,IAAI,CAACC,iBAAiB,CAACL,aAAaH,MAAMlC,OAAO,EAAEkC,MAAMY,OAAO;YAChF,OAAO;gBACHnB,YAAYkB,MAAM,CAACX,MAAMlC,OAAO,CAAC+B,GAAG;YACxC;QACJ;QAEA,+DAA+D;QAC/D,KAAK,MAAMI,QAAQtB,UAAW;YAC1B,IAAI,CAACc,YAAYoB,GAAG,CAACZ,KAAKJ,GAAG,GAAG;gBAC5BE,OAAOQ,IAAI,CAAC,IAAI,CAACO,mBAAmB,CAACb;YACzC;QACJ;QAEA,OAAOF;IACX;IAEA;;;;;;KAMC,GACD,AAAQR,iBAAiBZ,SAAwB,EAAiB;QAC9D,MAAMoC,WAAW,IAAIC;QAErB,KAAK,MAAMf,QAAQtB,UAAW;YAC1B,IAAI,CAACsB,KAAKgB,GAAG,EAAE;YAEf,MAAMC,aAAa,IAAI,CAACC,aAAa,CAAClB,KAAKgB,GAAG;YAC9C,IAAIF,SAASF,GAAG,CAACK,aAAa;YAE9B,IAAI;gBACA,IAAI,CAAC1E,GAAG4E,QAAQ,CAACF,YAAYnE,WAAW,IAAI;YAChD,EAAE,OAAM;gBACJ;YACJ;YAEAgE,SAASM,GAAG,CAACH,YAAYjB,KAAKgB,GAAG;QACrC;QAEA,IAAIF,SAASO,IAAI,KAAK,GAAG,OAAO,EAAE;QAElC,MAAMC,QAAQzE,8BAA8B;eAAIiE,SAASS,IAAI;SAAG;QAEhE,KAAK,MAAMC,QAAQF,MAAO;YACtBE,KAAKnB,WAAW,GAAGS,SAASW,GAAG,CAACD,KAAKP,UAAU,KAAK;QACxD;QAEA,OAAOK;IACX;IAEA;;;;;KAKC,GACD,AAAQpC,kBAAkBR,SAAwB,EAGhD;QACE,MAAMI,SAAwB,EAAE;QAChC,MAAME,WAA0B,EAAE;QAElC,KAAK,MAAMgB,QAAQtB,UAAW;YAC1B,MAAMgD,YAAY,IAAI,CAACC,sBAAsB,CAAC3B,KAAK3B,OAAO;YAC1D,IAAI,CAACqD,aAAa,CAAC1B,KAAKgB,GAAG,EAAE;gBACzBhC,SAASsB,IAAI,CAACN;gBACd;YACJ;YAEA,MAAMiB,aAAa,IAAI,CAACC,aAAa,CAAClB,KAAKgB,GAAG;YAC9C,MAAMY,YAAYpF,KAAKyB,IAAI,CAACgD,YAAY,GAAGS,UAAU,MAAM,CAAC;YAE5D,MAAMG,OAAO5E,SAAS2E;YACtB,IAAI,CAACC,MAAM;gBACP7C,SAASsB,IAAI,CAACN;gBACd;YACJ;YAEA,8DAA8D;YAC9D,kEAAkE;YAClE,8DAA8D;YAC9D,qBAAqB;YACrB,MAAM8B,WAAW,IAAI,CAACC,mBAAmB,CAAC/B,KAAKJ,GAAG,EAAEI,KAAKgC,SAAS;YAElElD,OAAOwB,IAAI,CAAC;gBACRzC,SAASmC;gBACTC,aAAa;oBACTyB;oBACAtB,UAAUwB;oBACVX;oBACAgB,aAAaJ,KAAKI,WAAW;oBAC7B5B,aAAaL,KAAKgB,GAAG;gBACzB;gBACAR,WAAW,IAAI,CAAC0B,YAAY,CAACJ,UAAUK;gBACvC1B,YAAYqB,UAAUrB;YAC1B;QACJ;QAEA,OAAO;YAAE3B;YAAQE;QAAS;IAC9B;IAEQ2C,uBAAuBtD,OAAe,EAAiB;QAC3D,MAAM0B,QAAQ1B,QAAQ0B,KAAK,CAAC;QAC5B,OAAOA,OAAO,CAAC,EAAE,IAAI;IACzB;IAEA;;;;;;;;KAQC,GACD,AAAQgC,oBAAoBnC,GAAW,EAAEwC,aAAoB,EAAuB;QAChF,MAAMC,cAAc7F,KAAKyB,IAAI,CAAC,IAAI,CAACP,WAAW,EAAE,GAAGkC,IAAI,KAAK,CAAC;QAC7D,IAAI;YACA,MAAM0C,QAAQC,KAAKC,KAAK,CACpBjG,GAAGkG,YAAY,CAACJ,aAAa;YAGjC,IAAID,eAAe;gBACf,MAAMM,UAAUC,KAAKC,GAAG,CAACR,cAAcS,OAAO,KAAKP,MAAMQ,SAAS;gBAClE,IAAIJ,UAAUrF,uBAAuB;oBACjC,OAAO;gBACX;YACJ;YAEA,OAAOiF;QACX,EAAE,OAAM;YACJ,OAAO;QACX;IACJ;IAEA;;;;;KAKC,GACD,AAAQJ,aAAaC,MAA0B,EAA2B;QACtE,OAAQA;YACJ,KAAK;gBACD,OAAO1F,YAAYsG,OAAO;YAC9B,KAAK;gBACD,OAAOtG,YAAYuG,OAAO;YAC9B,KAAK;gBACD,OAAOvG,YAAYwG,IAAI;YAC3B;gBACI,OAAOC;QACf;IACJ;IAEA;;;;;;;;;KASC,GACD,AAAQ9D,mBAAmBV,SAAwB,EAGjD;QACE,MAAMI,SAAwB,EAAE;QAChC,MAAME,WAA0B,EAAE;QAElC,KAAK,MAAMgB,QAAQtB,UAAW;YAC1B,MAAM4D,QAAQ,IAAI,CAACP,mBAAmB,CAAC/B,KAAKJ,GAAG,EAAEI,KAAKgC,SAAS;YAC/D,IAAI,CAACM,OAAO;gBACRtD,SAASsB,IAAI,CAACN;gBACd;YACJ;YAEA,MAAMiB,aAAa,IAAI,CAACC,aAAa,CAACoB,MAAMtB,GAAG;YAC/C,MAAMY,YAAYpF,KAAKyB,IAAI,CAACgD,YAAY,GAAGqB,MAAMZ,SAAS,CAAC,MAAM,CAAC;YAElE,IAAI,CAACnF,GAAG4G,UAAU,CAACvB,YAAY;gBAC3B5C,SAASsB,IAAI,CAACN;gBACd;YACJ;YAEAlB,OAAOwB,IAAI,CAAC;gBACRzC,SAASmC;gBACTC,aAAa;oBACTyB,WAAWY,MAAMZ,SAAS;oBAC1BtB,UAAUwB;oBACVX;oBACAgB,aAAaK,MAAMQ,SAAS;oBAC5BzC,aAAaiC,MAAMtB,GAAG;gBAC1B;gBACAR,WAAW,IAAI,CAAC0B,YAAY,CAACI,MAAMH,MAAM;gBACzC1B,YAAY6B,MAAM7B,UAAU;YAChC;QACJ;QAEA,OAAO;YAAE3B;YAAQE;QAAS;IAC9B;IAEA;;;;;;;;;;;;KAYC,GACD,AAAQkC,cAAcF,GAAW,EAAU;QACvC,MAAMoC,UAAUpC,IAAIqC,OAAO,CAAC,iBAAiB;QAC7C,OAAO7G,KAAKyB,IAAI,CAAC,IAAI,CAACR,WAAW,EAAE2F;IACvC;IAEQ7C,kBACJI,OAAsB,EACtBxC,WAAwB,EACxB8B,WAAwB,EACxBqD,QAA2D,EAClD;QACT,qEAAqE;QACrE,kEAAkE;QAClE,8CAA8C;QAC9C,MAAMnB,SAASmB,UAAU9C,aAAa,IAAI,CAAC7C,MAAM,CAAC4F,eAAe,CAAC5C;QAClE,MAAM6C,cAAc7C,QAAQ8C,eAAe,IAAI;QAC/C,MAAMC,UAAUvB,WAAW1F,YAAYuG,OAAO,IAAIM,UAAU7C,aACtD,GAAG+C,YAAY,eAAe,EAAEF,SAAS7C,UAAU,EAAE,GACrD+C;QAEN,OAAO;YACHG,MAAMxG,kBAAkBgB,YAAY6C,GAAG,EAAE7C,YAAYyB,GAAG;YACxDrC,MAAM,IAAI,CAACA,IAAI;YACf4E;YACAuB;YACA9D,KAAKzB,YAAYyB,GAAG;YACpBgE,aAAa3D,YAAYI,WAAW,IAAIlC,YAAY6C,GAAG,IAAI;YAC3DU,WAAWzB,YAAYyB,SAAS;YAChCmC,YAAYlD,QAAQkD,UAAU;YAC9BC,iBAAiB7D,YAAYG,QAAQ;QACzC;IACJ;IAEQS,oBAAoB1C,WAAwB,EAAa;QAC7D,OAAO;YACHwF,MAAMxG,kBAAkBgB,YAAY6C,GAAG,IAAI,IAAI7C,YAAYyB,GAAG;YAC9DrC,MAAM,IAAI,CAACA,IAAI;YACf4E,QAAQ1F,YAAYwG,IAAI;YACxBS,SAAS;YACT9D,KAAKzB,YAAYyB,GAAG;YACpBgE,aAAazF,YAAY6C,GAAG,IAAI;YAChCU,WAAW,CAAC,IAAI,EAAEvD,YAAYyB,GAAG,EAAE;YACnCiE,YAAY,IAAIE;QACpB;IACJ;IAEAC,gBAAgBF,eAAuB,EAAEG,OAA+B,EAAyB;QAC7F,OAAO,IAAI,CAACtG,MAAM,CAACqG,eAAe,CAACF,iBAAiBG;IACxD;IAEA,MAAMC,aAAaC,IAA0B,EAA6B;QACtE,MAAMC,YAAYD,MAAMnD;QACxB,MAAMqD,aAAa,IAAI,CAACC,oBAAoB;QAC5C,MAAMC,YAA8B,EAAE;QAEtC,KAAK,MAAM,EAAEnE,QAAQ,EAAEoE,UAAU,EAAE,IAAIH,WAAY;YAC/C,MAAM1D,UAAU,IAAI,CAAChD,MAAM,CAACwC,WAAW,CAACC,UAAUoE;YAClD,IAAI,CAAC7D,SAAS;YAEd,mEAAmE;YACnE,oEAAoE;YACpE,mEAAmE;YACnE,qCAAqC;YACrC,IAAI,CAACA,QAAQ8D,aAAa,EAAE;YAE5B,MAAMC,cAAc/D,QAAQgE,OAAO,IAAIH;YACvC,IAAIJ,cAAclB,aAAawB,gBAAgBN,WAAW;YAE1D,MAAMvC,OAAO5E,SAASmD;YAEtBmE,UAAUjE,IAAI,CAAC;gBACX/C,MAAM;gBACNmE,WAAWf,QAAQe,SAAS;gBAC5BV,KAAK0D;gBACLE,kBAAkBjE,QAAQiE,gBAAgB,IAAI;gBAC9Cf,YAAYlD,QAAQkD,UAAU,IAAIhC,MAAMgD,SAAS,IAAId;gBACrDjB,WAAWnC,QAAQmE,YAAY,IAAIjD,MAAMkD,aAAalD,MAAMgD,SAAS,IAAId;gBACzED,iBAAiB1D;YACrB;QACJ;QAEA,OAAOmE;IACX;IAEA;;;;;;;;;;KAUC,GACD,AAAQD,uBAAwE;QAC5E,MAAMU,MAAuD,EAAE;QAE/D,IAAI,CAAClI,YAAY,IAAI,CAACW,WAAW,GAAG,OAAOuH;QAE3C,KAAK,MAAMC,WAAWjI,YAAY,IAAI,CAACS,WAAW,EAAG;YACjD,MAAMwD,aAAazE,KAAKyB,IAAI,CAAC,IAAI,CAACR,WAAW,EAAEwH;YAC/C,IAAI,CAACnI,YAAYmE,aAAa;YAE9B,8DAA8D;YAC9D,+DAA+D;YAC/D,4DAA4D;YAC5D,uBAAuB;YACvB,MAAMiE,UAAUD,QAAQ5B,OAAO,CAAC,MAAM;YACtC,KAAK,MAAMM,QAAQ5G,UAAUkE,YAAa;gBACtC+D,IAAI1E,IAAI,CAAC;oBAAEF,UAAU5D,KAAKyB,IAAI,CAACgD,YAAY0C;oBAAOa,YAAYU;gBAAQ;YAC1E;QACJ;QAEA,OAAOF;IACX;AACJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ClaudeCliProbe.d.ts","sourceRoot":"","sources":["../../src/durable/ClaudeCliProbe.ts"],"names":[],"mappings":"AAIA,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/ClaudeCliProbe.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/durable/ClaudeCliProbe.ts"],"sourcesContent":["import { execFile } from 'child_process';\nimport { promisify } from 'util';\nimport { ClaudePrintError } from './DurableAgent.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: sanitize(versionResult.stdout, 256) || 'unknown',\n            };\n        } catch (error) {\n            if (error instanceof ClaudePrintError) throw error;\n            throw new ClaudePrintError(\n                `Claude CLI validation failed: ${sanitize((error as Error).message, 512)}`,\n                'CLAUDE_CLI_UNAVAILABLE',\n            );\n        }\n    }\n}\n\nfunction sanitize(value: string, max: number): string {\n    return Array.from(value, (character) => {\n        const code = character.charCodeAt(0);\n        return code <= 31 || code === 127 ? ' ' : character;\n    }).join('').trim().slice(0, max);\n}\n"],"names":["execFile","promisify","ClaudePrintError","execFileAsync","REQUIRED","ClaudeCliProbe","executable","exec","options","file","args","result","encoding","maxBuffer","stdout","stderr","validate","versionResult","helpResult","missing","filter","capability","includes","length","join","version","sanitize","error","message","value","max","Array","from","character","code","charCodeAt","trim","slice"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,gBAAgB;AACzC,SAASC,SAAS,QAAQ,OAAO;AACjC,SAASC,gBAAgB,QAAQ,oBAAoB;AAKrD,MAAMC,gBAAgBF,UAAUD;AAChC,MAAMI,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,IAAIrB,iBACN,CAAC,8DAA8D,EAAEiB,QAAQK,IAAI,CAAC,MAAM,CAAC,CAAC,EACtF;YAER;YACA,OAAO;gBACHlB,YAAY,IAAI,CAACA,UAAU;gBAC3BmB,SAASC,SAAST,cAAcH,MAAM,EAAE,QAAQ;YACpD;QACJ,EAAE,OAAOa,OAAO;YACZ,IAAIA,iBAAiBzB,kBAAkB,MAAMyB;YAC7C,MAAM,IAAIzB,iBACN,CAAC,8BAA8B,EAAEwB,SAAS,AAACC,MAAgBC,OAAO,EAAE,MAAM,EAC1E;QAER;IACJ;AACJ;AAEA,SAASF,SAASG,KAAa,EAAEC,GAAW;IACxC,OAAOC,MAAMC,IAAI,CAACH,OAAO,CAACI;QACtB,MAAMC,OAAOD,UAAUE,UAAU,CAAC;QAClC,OAAOD,QAAQ,MAAMA,SAAS,MAAM,MAAMD;IAC9C,GAAGT,IAAI,CAAC,IAAIY,IAAI,GAAGC,KAAK,CAAC,GAAGP;AAChC"}

package/dist/durable/ClaudePrintAgentService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClaudePrintAgentService.d.ts","sourceRoot":"","sources":["../../src/durable/ClaudePrintAgentService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGvE,OAAO,EAAE,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,EAA0B,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAE9H,UAAU,cAAc;IACpB,MAAM,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC9D,IAAI,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAChC,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,YAAY,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1E,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3F,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC/F;AAED,UAAU,SAAS;IAAG,QAAQ,IAAI,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE;AACpF,UAAU,UAAU;IAAG,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAA;CAAE;AAE7G,MAAM,WAAW,8BAA8B;IAC3C,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,uBAAuB;IAChC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAS;gBAEzB,OAAO,GAAE,8BAAmC;IAOlD,MAAM,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,YAAY,CAAC;IAK7D,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAoChF"}

package/dist/durable/ClaudePrintAgentService.js

@@ -1,66 +0,0 @@
-import { ClaudePrintError, DurableAgentNotFoundError } from './DurableAgent.js';
-import { ClaudeCliProbe } from './ClaudeCliProbe.js';
-import { ClaudePrintRunner } from './ClaudePrintRunner.js';
-import { DurableAgentRepository } from './DurableAgentRepository.js';
-export class ClaudePrintAgentService {
-    repository;
-    probe;
-    runner;
-    executable;
-    constructor(options = {}){
-        this.repository = options.repository ?? new DurableAgentRepository();
-        this.probe = options.probe ?? new ClaudeCliProbe();
-        this.runner = options.runner ?? new ClaudePrintRunner();
-        this.executable = options.executable;
-    }
-    async create(input) {
-        await this.probe.validate();
-        return this.repository.create(input);
-    }
-    async send(reference, prompt) {
-        const resolved = await this.repository.resolve(reference);
-        if (!resolved) throw new DurableAgentNotFoundError(reference);
-        if (Array.isArray(resolved)) {
-            throw new ClaudePrintError(`Multiple durable agents match "${reference}".`, 'DURABLE_AGENT_AMBIGUOUS');
-        }
-        const acquired = await this.repository.acquireRun(resolved.id);
-        try {
-            const result = await this.runner.run({
-                agent: acquired.agent,
-                prompt,
-                executable: this.executable,
-                firstRun: acquired.agent.sessionHealth === 'uninitialized',
-                onSpawn: (identity)=>this.repository.recordProviderProcess(resolved.id, acquired.token, identity)
-            });
-            await this.repository.completeRun(resolved.id, acquired.token, {
-                status: 'succeeded',
-                exitCode: result.exitCode,
-                summary: sanitize(result.result, 4096),
-                sessionHealth: 'healthy'
-            });
-            return {
-                ...result,
-                agentId: resolved.id,
-                agentName: resolved.name
-            };
-        } catch (error) {
-            const failure = error instanceof Error ? error : new Error(String(error));
-            const sessionHealth = error instanceof ClaudePrintError && error.code === 'CLAUDE_SESSION_MISMATCH' ? 'mismatch' : 'unknown';
-            await this.repository.completeRun(resolved.id, acquired.token, {
-                status: 'failed',
-                exitCode: null,
-                summary: sanitize(failure.message, 4096),
-                sessionHealth
-            });
-            throw error;
-        }
-    }
-}
-function sanitize(value, max) {
-    return Array.from(value, (character)=>{
-        const code = character.charCodeAt(0);
-        return code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 ? ' ' : character;
-    }).join('').trim().slice(0, max);
-}
-
-//# sourceMappingURL=ClaudePrintAgentService.js.map

package/dist/durable/ClaudePrintAgentService.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/durable/ClaudePrintAgentService.ts"],"sourcesContent":["import type { DurableAgent, ProcessIdentity } from './DurableAgent.js';\nimport { ClaudePrintError, DurableAgentNotFoundError } from './DurableAgent.js';\nimport { ClaudeCliProbe } from './ClaudeCliProbe.js';\nimport { ClaudePrintRunner, type ClaudePrintRunResult } from './ClaudePrintRunner.js';\nimport { DurableAgentRepository, type CreateDurableAgentInput, type DurableRunCompletion } from './DurableAgentRepository.js';\n\ninterface RepositoryLike {\n    create(input: CreateDurableAgentInput): Promise<DurableAgent>;\n    list(): Promise<DurableAgent[]>;\n    resolve(reference: string): Promise<DurableAgent | DurableAgent[] | null>;\n    acquireRun(id: string): Promise<{ agent: DurableAgent; token: string }>;\n    recordProviderProcess(id: string, token: string, identity: ProcessIdentity): Promise<void>;\n    completeRun(id: string, token: string, result: DurableRunCompletion): Promise<DurableAgent>;\n}\n\ninterface ProbeLike { validate(): Promise<{ executable: string; version: string }> }\ninterface RunnerLike { run(request: Parameters<ClaudePrintRunner['run']>[0]): Promise<ClaudePrintRunResult> }\n\nexport interface ClaudePrintAgentServiceOptions {\n    repository?: RepositoryLike;\n    probe?: ProbeLike;\n    runner?: RunnerLike;\n    executable?: string;\n}\n\nexport interface ClaudePrintSendResult extends ClaudePrintRunResult {\n    agentId: string;\n    agentName: string;\n}\n\nexport class ClaudePrintAgentService {\n    readonly repository: RepositoryLike;\n    private readonly probe: ProbeLike;\n    private readonly runner: RunnerLike;\n    private readonly executable?: string;\n\n    constructor(options: ClaudePrintAgentServiceOptions = {}) {\n        this.repository = options.repository ?? new DurableAgentRepository();\n        this.probe = options.probe ?? new ClaudeCliProbe();\n        this.runner = options.runner ?? new ClaudePrintRunner();\n        this.executable = options.executable;\n    }\n\n    async create(input: CreateDurableAgentInput): Promise<DurableAgent> {\n        await this.probe.validate();\n        return this.repository.create(input);\n    }\n\n    async send(reference: string, prompt: string): Promise<ClaudePrintSendResult> {\n        const resolved = await this.repository.resolve(reference);\n        if (!resolved) throw new DurableAgentNotFoundError(reference);\n        if (Array.isArray(resolved)) {\n            throw new ClaudePrintError(`Multiple durable agents match \"${reference}\".`, 'DURABLE_AGENT_AMBIGUOUS');\n        }\n        const acquired = await this.repository.acquireRun(resolved.id);\n        try {\n            const result = await this.runner.run({\n                agent: acquired.agent,\n                prompt,\n                executable: this.executable,\n                firstRun: acquired.agent.sessionHealth === 'uninitialized',\n                onSpawn: (identity) => this.repository.recordProviderProcess(resolved.id, acquired.token, identity),\n            });\n            await this.repository.completeRun(resolved.id, acquired.token, {\n                status: 'succeeded',\n                exitCode: result.exitCode,\n                summary: sanitize(result.result, 4096),\n                sessionHealth: 'healthy',\n            });\n            return { ...result, agentId: resolved.id, agentName: resolved.name };\n        } catch (error) {\n            const failure = error instanceof Error ? error : new Error(String(error));\n            const sessionHealth = error instanceof ClaudePrintError && error.code === 'CLAUDE_SESSION_MISMATCH'\n                ? 'mismatch' as const\n                : 'unknown' as const;\n            await this.repository.completeRun(resolved.id, acquired.token, {\n                status: 'failed',\n                exitCode: null,\n                summary: sanitize(failure.message, 4096),\n                sessionHealth,\n            });\n            throw error;\n        }\n    }\n}\n\nfunction sanitize(value: string, max: number): string {\n    return Array.from(value, (character) => {\n        const code = character.charCodeAt(0);\n        return (code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31) || code === 127)\n            ? ' '\n            : character;\n    }).join('').trim().slice(0, max);\n}\n"],"names":["ClaudePrintError","DurableAgentNotFoundError","ClaudeCliProbe","ClaudePrintRunner","DurableAgentRepository","ClaudePrintAgentService","repository","probe","runner","executable","options","create","input","validate","send","reference","prompt","resolved","resolve","Array","isArray","acquired","acquireRun","id","result","run","agent","firstRun","sessionHealth","onSpawn","identity","recordProviderProcess","token","completeRun","status","exitCode","summary","sanitize","agentId","agentName","name","error","failure","Error","String","code","message","value","max","from","character","charCodeAt","join","trim","slice"],"mappings":"AACA,SAASA,gBAAgB,EAAEC,yBAAyB,QAAQ,oBAAoB;AAChF,SAASC,cAAc,QAAQ,sBAAsB;AACrD,SAASC,iBAAiB,QAAmC,yBAAyB;AACtF,SAASC,sBAAsB,QAAiE,8BAA8B;AA0B9H,OAAO,MAAMC;IACAC,WAA2B;IACnBC,MAAiB;IACjBC,OAAmB;IACnBC,WAAoB;IAErC,YAAYC,UAA0C,CAAC,CAAC,CAAE;QACtD,IAAI,CAACJ,UAAU,GAAGI,QAAQJ,UAAU,IAAI,IAAIF;QAC5C,IAAI,CAACG,KAAK,GAAGG,QAAQH,KAAK,IAAI,IAAIL;QAClC,IAAI,CAACM,MAAM,GAAGE,QAAQF,MAAM,IAAI,IAAIL;QACpC,IAAI,CAACM,UAAU,GAAGC,QAAQD,UAAU;IACxC;IAEA,MAAME,OAAOC,KAA8B,EAAyB;QAChE,MAAM,IAAI,CAACL,KAAK,CAACM,QAAQ;QACzB,OAAO,IAAI,CAACP,UAAU,CAACK,MAAM,CAACC;IAClC;IAEA,MAAME,KAAKC,SAAiB,EAAEC,MAAc,EAAkC;QAC1E,MAAMC,WAAW,MAAM,IAAI,CAACX,UAAU,CAACY,OAAO,CAACH;QAC/C,IAAI,CAACE,UAAU,MAAM,IAAIhB,0BAA0Bc;QACnD,IAAII,MAAMC,OAAO,CAACH,WAAW;YACzB,MAAM,IAAIjB,iBAAiB,CAAC,+BAA+B,EAAEe,UAAU,EAAE,CAAC,EAAE;QAChF;QACA,MAAMM,WAAW,MAAM,IAAI,CAACf,UAAU,CAACgB,UAAU,CAACL,SAASM,EAAE;QAC7D,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAChB,MAAM,CAACiB,GAAG,CAAC;gBACjCC,OAAOL,SAASK,KAAK;gBACrBV;gBACAP,YAAY,IAAI,CAACA,UAAU;gBAC3BkB,UAAUN,SAASK,KAAK,CAACE,aAAa,KAAK;gBAC3CC,SAAS,CAACC,WAAa,IAAI,CAACxB,UAAU,CAACyB,qBAAqB,CAACd,SAASM,EAAE,EAAEF,SAASW,KAAK,EAAEF;YAC9F;YACA,MAAM,IAAI,CAACxB,UAAU,CAAC2B,WAAW,CAAChB,SAASM,EAAE,EAAEF,SAASW,KAAK,EAAE;gBAC3DE,QAAQ;gBACRC,UAAUX,OAAOW,QAAQ;gBACzBC,SAASC,SAASb,OAAOA,MAAM,EAAE;gBACjCI,eAAe;YACnB;YACA,OAAO;gBAAE,GAAGJ,MAAM;gBAAEc,SAASrB,SAASM,EAAE;gBAAEgB,WAAWtB,SAASuB,IAAI;YAAC;QACvE,EAAE,OAAOC,OAAO;YACZ,MAAMC,UAAUD,iBAAiBE,QAAQF,QAAQ,IAAIE,MAAMC,OAAOH;YAClE,MAAMb,gBAAgBa,iBAAiBzC,oBAAoByC,MAAMI,IAAI,KAAK,4BACpE,aACA;YACN,MAAM,IAAI,CAACvC,UAAU,CAAC2B,WAAW,CAAChB,SAASM,EAAE,EAAEF,SAASW,KAAK,EAAE;gBAC3DE,QAAQ;gBACRC,UAAU;gBACVC,SAASC,SAASK,QAAQI,OAAO,EAAE;gBACnClB;YACJ;YACA,MAAMa;QACV;IACJ;AACJ;AAEA,SAASJ,SAASU,KAAa,EAAEC,GAAW;IACxC,OAAO7B,MAAM8B,IAAI,CAACF,OAAO,CAACG;QACtB,MAAML,OAAOK,UAAUC,UAAU,CAAC;QAClC,OAAO,AAACN,QAAQ,KAAKA,SAAS,MAAMA,SAAS,MAAOA,QAAQ,MAAMA,QAAQ,MAAOA,SAAS,MACpF,MACAK;IACV,GAAGE,IAAI,CAAC,IAAIC,IAAI,GAAGC,KAAK,CAAC,GAAGN;AAChC"}

package/dist/durable/ClaudePrintRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClaudePrintRunner.d.ts","sourceRoot":"","sources":["../../src/durable/ClaudePrintRunner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,8BAA8B,EAAE,KAAK,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACvH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE3F,KAAK,KAAK,GAAG,CACT,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,wBAAwB,GAAG;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,KACtE,8BAA8B,CAAC;AAEpC,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACrC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAE1B,OAAO,GAAE,wBAA6B;IAM5C,GAAG,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAgG3E"}

package/dist/durable/ClaudePrintRunner.js

@@ -1,128 +0,0 @@
-import { spawn as nodeSpawn } from 'child_process';
-import { ClaudePrintError } from './DurableAgent.js';
-import { LocalProcessInspector } from './DurableAgentRepository.js';
-export class ClaudePrintRunner {
-    spawn;
-    processInspector;
-    maxLineBytes;
-    constructor(options = {}){
-        this.spawn = options.spawn ?? nodeSpawn;
-        this.processInspector = options.processInspector ?? new LocalProcessInspector();
-        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
-    }
-    async run(request) {
-        const sessionArgs = request.firstRun ? [
-            '--session-id',
-            request.agent.providerSessionId
-        ] : [
-            '--resume',
-            request.agent.providerSessionId
-        ];
-        const args = [
-            '-p',
-            ...sessionArgs,
-            '--output-format',
-            'stream-json',
-            '--verbose'
-        ];
-        const child = this.spawn(request.executable ?? 'claude', args, {
-            cwd: request.agent.cwd,
-            shell: false,
-            stdio: [
-                'pipe',
-                'pipe',
-                'pipe'
-            ]
-        });
-        if (!child.pid) {
-            child.kill();
-            throw new ClaudePrintError('Claude process did not provide a PID.', 'CLAUDE_PROCESS_IDENTITY');
-        }
-        const identity = this.processInspector.getIdentity(child.pid);
-        if (!identity) {
-            child.kill();
-            throw new ClaudePrintError('Cannot verify Claude process identity.', 'CLAUDE_PROCESS_IDENTITY');
-        }
-        let buffer = Buffer.alloc(0);
-        let terminal = null;
-        let protocolError = null;
-        child.stdout.on('data', (chunk)=>{
-            if (protocolError) return;
-            buffer = Buffer.concat([
-                buffer,
-                Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
-            ]);
-            if (buffer.length > this.maxLineBytes && buffer.indexOf(0x0a) < 0) {
-                protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');
-                return;
-            }
-            let newline;
-            while((newline = buffer.indexOf(0x0a)) >= 0){
-                const line = buffer.subarray(0, newline);
-                buffer = buffer.subarray(newline + 1);
-                if (line.length === 0) continue;
-                if (line.length > this.maxLineBytes) {
-                    protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');
-                    return;
-                }
-                try {
-                    const value = JSON.parse(line.toString('utf8'));
-                    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-                        throw new ClaudePrintError('Claude emitted a non-object stream message.', 'CLAUDE_STREAM_INVALID');
-                    }
-                    const event = value;
-                    if (typeof event.session_id === 'string' && event.session_id !== request.agent.providerSessionId) {
-                        throw new ClaudePrintError('Claude returned a different session identity.', 'CLAUDE_SESSION_MISMATCH');
-                    }
-                    if (event.type === 'result') {
-                        if (terminal) throw new ClaudePrintError('Claude emitted more than one terminal result.', 'CLAUDE_STREAM_INVALID');
-                        if (typeof event.session_id !== 'string' || typeof event.result !== 'string') {
-                            throw new ClaudePrintError('Claude emitted an invalid terminal result.', 'CLAUDE_STREAM_INVALID');
-                        }
-                        terminal = {
-                            sessionId: event.session_id,
-                            result: event.result,
-                            exitCode: 0
-                        };
-                    }
-                } catch (error) {
-                    protocolError = error instanceof ClaudePrintError ? error : new ClaudePrintError('Claude emitted malformed stream JSON.', 'CLAUDE_STREAM_INVALID');
-                    return;
-                }
-            }
-        });
-        // Drain provider diagnostics without reflecting potentially sensitive prompt/tool data.
-        child.stderr.resume();
-        const closed = new Promise((resolve, reject)=>{
-            child.once('error', reject);
-            child.once('close', (code, signal)=>resolve({
-                    code,
-                    signal
-                }));
-        });
-        try {
-            await request.onSpawn(identity);
-        } catch (error) {
-            child.kill();
-            throw error;
-        }
-        child.stdin.end(request.prompt);
-        const { code, signal } = await closed;
-        if (protocolError) throw protocolError;
-        if (buffer.length > 0) {
-            throw new ClaudePrintError('Claude stream ended with incomplete JSON.', 'CLAUDE_STREAM_INVALID');
-        }
-        if (code !== 0) {
-            throw new ClaudePrintError(`Claude print run failed${signal ? ` (${signal})` : '.'}`, 'CLAUDE_PROCESS_FAILED');
-        }
-        if (!terminal) throw new ClaudePrintError('Claude stream ended without a terminal result.', 'CLAUDE_RESULT_MISSING');
-        const finalResult = terminal;
-        return {
-            sessionId: finalResult.sessionId,
-            result: finalResult.result,
-            exitCode: code
-        };
-    }
-}
-
-//# sourceMappingURL=ClaudePrintRunner.js.map

package/dist/durable/ClaudePrintRunner.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/durable/ClaudePrintRunner.ts"],"sourcesContent":["import { spawn as nodeSpawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'child_process';\nimport type { DurableAgent, ProcessIdentity } from './DurableAgent.js';\nimport { ClaudePrintError } from './DurableAgent.js';\nimport { LocalProcessInspector, type ProcessInspector } from './DurableAgentRepository.js';\n\ntype Spawn = (\n    command: string,\n    args: readonly string[],\n    options: SpawnOptionsWithoutStdio & { stdio: ['pipe', 'pipe', 'pipe'] },\n) => ChildProcessWithoutNullStreams;\n\nexport interface ClaudePrintRunRequest {\n    agent: DurableAgent;\n    prompt: string;\n    executable?: string;\n    firstRun: boolean;\n    onSpawn(identity: ProcessIdentity): Promise<void>;\n}\n\nexport interface ClaudePrintRunResult {\n    sessionId: string;\n    result: string;\n    exitCode: number;\n}\n\nexport interface ClaudePrintRunnerOptions {\n    spawn?: Spawn;\n    processInspector?: ProcessInspector;\n    maxLineBytes?: number;\n}\n\nexport class ClaudePrintRunner {\n    private readonly spawn: Spawn;\n    private readonly processInspector: ProcessInspector;\n    private readonly maxLineBytes: number;\n\n    constructor(options: ClaudePrintRunnerOptions = {}) {\n        this.spawn = options.spawn ?? (nodeSpawn as Spawn);\n        this.processInspector = options.processInspector ?? new LocalProcessInspector();\n        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;\n    }\n\n    async run(request: ClaudePrintRunRequest): Promise<ClaudePrintRunResult> {\n        const sessionArgs = request.firstRun\n            ? ['--session-id', request.agent.providerSessionId]\n            : ['--resume', request.agent.providerSessionId];\n        const args = ['-p', ...sessionArgs, '--output-format', 'stream-json', '--verbose'];\n        const child = this.spawn(request.executable ?? 'claude', args, {\n            cwd: request.agent.cwd,\n            shell: false,\n            stdio: ['pipe', 'pipe', 'pipe'],\n        });\n        if (!child.pid) {\n            child.kill();\n            throw new ClaudePrintError('Claude process did not provide a PID.', 'CLAUDE_PROCESS_IDENTITY');\n        }\n        const identity = this.processInspector.getIdentity(child.pid);\n        if (!identity) {\n            child.kill();\n            throw new ClaudePrintError('Cannot verify Claude process identity.', 'CLAUDE_PROCESS_IDENTITY');\n        }\n\n        let buffer = Buffer.alloc(0);\n        let terminal: ClaudePrintRunResult | null = null;\n        let protocolError: ClaudePrintError | null = null;\n\n        child.stdout.on('data', (chunk: Buffer | string) => {\n            if (protocolError) return;\n            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);\n            if (buffer.length > this.maxLineBytes && buffer.indexOf(0x0a) < 0) {\n                protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');\n                return;\n            }\n            let newline: number;\n            while ((newline = buffer.indexOf(0x0a)) >= 0) {\n                const line = buffer.subarray(0, newline);\n                buffer = buffer.subarray(newline + 1);\n                if (line.length === 0) continue;\n                if (line.length > this.maxLineBytes) {\n                    protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');\n                    return;\n                }\n                try {\n                    const value = JSON.parse(line.toString('utf8')) as unknown;\n                    if (!value || typeof value !== 'object' || Array.isArray(value)) {\n                        throw new ClaudePrintError('Claude emitted a non-object stream message.', 'CLAUDE_STREAM_INVALID');\n                    }\n                    const event = value as Record<string, unknown>;\n                    if (typeof event.session_id === 'string' && event.session_id !== request.agent.providerSessionId) {\n                        throw new ClaudePrintError('Claude returned a different session identity.', 'CLAUDE_SESSION_MISMATCH');\n                    }\n                    if (event.type === 'result') {\n                        if (terminal) throw new ClaudePrintError('Claude emitted more than one terminal result.', 'CLAUDE_STREAM_INVALID');\n                        if (typeof event.session_id !== 'string' || typeof event.result !== 'string') {\n                            throw new ClaudePrintError('Claude emitted an invalid terminal result.', 'CLAUDE_STREAM_INVALID');\n                        }\n                        terminal = { sessionId: event.session_id, result: event.result, exitCode: 0 };\n                    }\n                } catch (error) {\n                    protocolError = error instanceof ClaudePrintError\n                        ? error\n                        : new ClaudePrintError('Claude emitted malformed stream JSON.', 'CLAUDE_STREAM_INVALID');\n                    return;\n                }\n            }\n        });\n        // Drain provider diagnostics without reflecting potentially sensitive prompt/tool data.\n        child.stderr.resume();\n\n        const closed = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {\n            child.once('error', reject);\n            child.once('close', (code, signal) => resolve({ code, signal }));\n        });\n\n        try {\n            await request.onSpawn(identity);\n        } catch (error) {\n            child.kill();\n            throw error;\n        }\n\n        child.stdin.end(request.prompt);\n        const { code, signal } = await closed;\n\n        if (protocolError) throw protocolError;\n        if (buffer.length > 0) {\n            throw new ClaudePrintError('Claude stream ended with incomplete JSON.', 'CLAUDE_STREAM_INVALID');\n        }\n        if (code !== 0) {\n            throw new ClaudePrintError(\n                `Claude print run failed${signal ? ` (${signal})` : '.'}`,\n                'CLAUDE_PROCESS_FAILED',\n            );\n        }\n        if (!terminal) throw new ClaudePrintError('Claude stream ended without a terminal result.', 'CLAUDE_RESULT_MISSING');\n        const finalResult = terminal as ClaudePrintRunResult;\n        return { sessionId: finalResult.sessionId, result: finalResult.result, exitCode: code };\n    }\n}\n"],"names":["spawn","nodeSpawn","ClaudePrintError","LocalProcessInspector","ClaudePrintRunner","processInspector","maxLineBytes","options","run","request","sessionArgs","firstRun","agent","providerSessionId","args","child","executable","cwd","shell","stdio","pid","kill","identity","getIdentity","buffer","Buffer","alloc","terminal","protocolError","stdout","on","chunk","concat","isBuffer","from","length","indexOf","newline","line","subarray","value","JSON","parse","toString","Array","isArray","event","session_id","type","result","sessionId","exitCode","error","stderr","resume","closed","Promise","resolve","reject","once","code","signal","onSpawn","stdin","end","prompt","finalResult"],"mappings":"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"}

package/dist/utils/ClaudeSessionParser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClaudeSessionParser.d.ts","sourceRoot":"","sources":["../../src/utils/ClaudeSessionParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D;;;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/ClaudeSessionParser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/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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"}