@a1hvdy/cc-openclaw 0.5.2 → 0.7.0

package/vendor/persistent-session.js

@@ -1,684 +0,0 @@
-/**
- * Persistent Claude Code Session — wraps `claude` CLI via child_process.spawn
- *
- * Maintains a long-running Claude Code process with streaming JSON I/O.
- * Enables multi-turn agent loops, continuous conversation, and real-time streaming.
- */
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import * as readline from 'node:readline';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { getModelPricing, } from './types.js';
-import { resolveAlias, getContextWindow, isClaudeModel } from './models.js';
-import { CONTEXT_HIGH_THRESHOLD, MAX_HISTORY_ITEMS, DEFAULT_HISTORY_LIMIT, SESSION_READY_TIMEOUT_MS, SESSION_READY_FALLBACK_MS, TURN_TIMEOUT_MS, COMPACT_TIMEOUT_MS, STOP_SIGKILL_DELAY_MS, SESSION_EVENT, } from './constants.js';
-// ─── PersistentClaudeSession ─────────────────────────────────────────────────
-export class PersistentClaudeSession extends EventEmitter {
-    options;
-    claudeBin;
-    proc = null;
-    _rl = null;
-    _isReady = false;
-    _isPaused = false;
-    _isBusy = false;
-    currentRequestId = 0;
-    _streamCallbacks = null;
-    _contextHighFired = false;
-    _realModel = null;
-    sessionId;
-    stats;
-    constructor(config, claudeBin) {
-        super();
-        this.claudeBin = claudeBin || process.env.CLAUDE_BIN || 'claude';
-        this.options = {
-            ...config,
-            permissionMode: config.permissionMode || 'acceptEdits',
-            hooks: {},
-            modelOverrides: config.modelOverrides || {},
-        };
-        this.stats = {
-            turns: 0,
-            toolCalls: 0,
-            toolErrors: 0,
-            tokensIn: 0,
-            tokensOut: 0,
-            cachedTokens: 0,
-            costUsd: 0,
-            startTime: null,
-            lastActivity: null,
-            history: [],
-        };
-    }
-    get pid() {
-        return this.proc?.pid ?? undefined;
-    }
-    get isReady() {
-        return this._isReady;
-    }
-    get isPaused() {
-        return this._isPaused;
-    }
-    get isBusy() {
-        return this._isBusy;
-    }
-    // ─── Start ───────────────────────────────────────────────────────────────
-    async start() {
-        const resolvedBin = this.claudeBin;
-        const args = [
-            '-p',
-            '--input-format',
-            'stream-json',
-            '--output-format',
-            'stream-json',
-            '--replay-user-messages',
-            '--verbose',
-            '--include-partial-messages',
-            '--permission-mode',
-            this.options.permissionMode || 'acceptEdits',
-        ];
-        // Model alias resolution
-        if (this.options.model) {
-            const resolved = this.resolveModel(this.options.model);
-            if (resolved !== this.options.model)
-                this.options.model = resolved;
-        }
-        // Resume / fork
-        const resumeId = this.options.claudeResumeId || this.options.resumeSessionId;
-        if (resumeId) {
-            args.push('--resume', resumeId);
-            if (this.options.forkSession)
-                args.push('--fork-session');
-        }
-        if (this.options.customSessionId)
-            args.push('--session-id', this.options.customSessionId);
-        // Model — proxy mode mapping
-        if (this.options.model) {
-            if (!isClaudeModel(this.options.model) && this.options.baseUrl) {
-                this._realModel = this.options.model;
-                args.push('--model', 'opus');
-            }
-            else {
-                const cliModel = this.options.model.includes('/') ? this.options.model.split('/').pop() : this.options.model;
-                args.push('--model', cliModel);
-            }
-        }
-        // Tool control
-        if (this.options.allowedTools?.length)
-            args.push('--allowed-tools', this.options.allowedTools.join(','));
-        if (this.options.disallowedTools?.length)
-            args.push('--disallowed-tools', this.options.disallowedTools.join(','));
-        if (this.options.tools !== undefined && this.options.tools !== null) {
-            const t = Array.isArray(this.options.tools) ? this.options.tools.join(',') : this.options.tools;
-            args.push('--tools', t);
-        }
-        // System prompts
-        if (this.options.systemPrompt)
-            args.push('--system-prompt', this.options.systemPrompt);
-        if (this.options.appendSystemPrompt)
-            args.push('--append-system-prompt', this.options.appendSystemPrompt);
-        // Limits
-        if (this.options.maxTurns)
-            args.push('--max-turns', String(this.options.maxTurns));
-        if (this.options.maxBudgetUsd)
-            args.push('--max-budget-usd', String(this.options.maxBudgetUsd));
-        // Permissions
-        if (this.options.dangerouslySkipPermissions)
-            args.push('--dangerously-skip-permissions');
-        // Agents
-        if (this.options.agents) {
-            const json = typeof this.options.agents === 'string' ? this.options.agents : JSON.stringify(this.options.agents);
-            args.push('--agents', json);
-        }
-        if (this.options.agent)
-            args.push('--agent', this.options.agent);
-        // Directories
-        if (this.options.addDir?.length) {
-            for (const dir of this.options.addDir)
-                args.push('--add-dir', dir);
-        }
-        // Effort
-        if (this.options.effort && this.options.effort !== 'auto')
-            args.push('--effort', this.options.effort);
-        // Auto mode
-        if (this.options.enableAutoMode || this.options.permissionMode === 'auto')
-            args.push('--enable-auto-mode');
-        // Session name
-        if (this.options.sessionName)
-            args.push('-n', this.options.sessionName);
-        // New CLI flags
-        if (this.options.bare)
-            args.push('--bare');
-        if (this.options.worktree) {
-            args.push('--worktree');
-            if (typeof this.options.worktree === 'string' && this.options.worktree !== 'true')
-                args.push(this.options.worktree);
-        }
-        if (this.options.fallbackModel)
-            args.push('--fallback-model', this.options.fallbackModel);
-        if (this.options.jsonSchema)
-            args.push('--json-schema', this.options.jsonSchema);
-        if (this.options.mcpConfig) {
-            const configs = Array.isArray(this.options.mcpConfig) ? this.options.mcpConfig : [this.options.mcpConfig];
-            for (const c of configs)
-                args.push('--mcp-config', c);
-        }
-        if (this.options.settings)
-            args.push('--settings', this.options.settings);
-        if (this.options.noSessionPersistence)
-            args.push('--no-session-persistence');
-        if (this.options.betas) {
-            const bl = Array.isArray(this.options.betas) ? this.options.betas : this.options.betas.split(',');
-            for (const b of bl)
-                args.push('--betas', b.trim());
-        }
-        // Ensure CWD exists (normalize to prevent path traversal)
-        if (this.options.cwd) {
-            this.options.cwd = path.resolve(this.options.cwd);
-            if (!fs.existsSync(this.options.cwd)) {
-                fs.mkdirSync(this.options.cwd, { recursive: true });
-            }
-        }
-        // Build spawn environment
-        // Preserve the parent process PATH so the resolved binary and any PATH-relative
-        // tools (git, node, npm, etc.) remain accessible on all platforms and distros.
-        const spawnEnv = {
-            ...process.env,
-            PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin',
-        };
-        if (this.options.baseUrl)
-            spawnEnv.ANTHROPIC_BASE_URL = this.options.baseUrl;
-        if (this.options.enableAgentTeams)
-            spawnEnv.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = 'true';
-        if (this._realModel && this.options.baseUrl) {
-            const base = this.options.baseUrl.replace(/\/$/, '');
-            spawnEnv.ANTHROPIC_BASE_URL = `${base}/real/${this._realModel}`;
-        }
-        // Spawn
-        this.proc = spawn(resolvedBin, args, {
-            cwd: this.options.cwd,
-            env: spawnEnv,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            detached: true,
-        });
-        // Unref so the parent process can exit independently of the child.
-        this.proc.unref();
-        // Parse stdout line-by-line
-        this._rl = readline.createInterface({ input: this.proc.stdout, crlfDelay: Infinity });
-        this._rl.on('line', (line) => {
-            if (!line.trim())
-                return;
-            try {
-                const event = JSON.parse(line);
-                this._handleEvent(event);
-            }
-            catch {
-                this.emit(SESSION_EVENT.LOG, `[stdout] ${line}`);
-            }
-        });
-        this.proc.stderr?.on('data', (data) => {
-            const sanitized = data
-                .toString()
-                .replace(/sk-[a-zA-Z0-9_-]{10,}/g, 'sk-***')
-                .replace(/ANTHROPIC_API_KEY=[^\s]+/g, 'ANTHROPIC_API_KEY=***')
-                .replace(/OPENAI_API_KEY=[^\s]+/g, 'OPENAI_API_KEY=***')
-                .replace(/GEMINI_API_KEY=[^\s]+/g, 'GEMINI_API_KEY=***')
-                .replace(/Bearer [a-zA-Z0-9_-]+/g, 'Bearer ***');
-            this.emit(SESSION_EVENT.LOG, `[stderr] ${sanitized}`);
-        });
-        this.proc.on('close', (code) => {
-            this._isReady = false;
-            this.emit(SESSION_EVENT.CLOSE, code);
-        });
-        this.proc.on('error', (err) => {
-            this.emit(SESSION_EVENT.ERROR, err);
-        });
-        // Wait for ready
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(new Error('Timeout waiting for session ready')), SESSION_READY_TIMEOUT_MS);
-            this.once(SESSION_EVENT.READY, () => {
-                clearTimeout(timeout);
-                resolve(this);
-            });
-            this.once(SESSION_EVENT.ERROR, (err) => {
-                clearTimeout(timeout);
-                reject(err);
-            });
-            // Detect premature CLI exit to avoid hanging or marking a dead process as "ready".
-            const onCloseBeforeReady = (code) => {
-                if (!this._isReady) {
-                    clearTimeout(timeout);
-                    reject(new Error(`Claude process exited prematurely with code ${code}. Session failed to start.`));
-                }
-            };
-            this.once(SESSION_EVENT.CLOSE, onCloseBeforeReady);
-            // Emit ready on the first `system` init event from the CLI.
-            // Fall back to a 2 s timer in case the CLI version doesn't emit one.
-            const onInit = () => {
-                if (!this._isReady) {
-                    this._isReady = true;
-                    // Cleanup the early-close listener since initialization succeeded
-                    this.removeListener(SESSION_EVENT.CLOSE, onCloseBeforeReady);
-                    this.emit(SESSION_EVENT.READY);
-                }
-            };
-            this.once(SESSION_EVENT.INIT, onInit);
-            setTimeout(() => {
-                this.removeListener(SESSION_EVENT.INIT, onInit);
-                // If process already exited, reject instead of falsely marking ready
-                if (this.proc?.killed || this.proc?.exitCode !== null) {
-                    clearTimeout(timeout);
-                    this.removeListener(SESSION_EVENT.CLOSE, onCloseBeforeReady);
-                    reject(new Error('Claude CLI process crashed immediately upon startup. Fallback timer aborted.'));
-                    return;
-                }
-                if (!this._isReady) {
-                    this._isReady = true;
-                    this.removeListener(SESSION_EVENT.CLOSE, onCloseBeforeReady);
-                    this.emit(SESSION_EVENT.READY);
-                }
-            }, SESSION_READY_FALLBACK_MS);
-        });
-    }
-    // ─── Event Handling ──────────────────────────────────────────────────────
-    _handleEvent(event) {
-        const type = event.type;
-        this.stats.lastActivity = new Date().toISOString();
-        // Track history (keep last 100)
-        this.stats.history.push({ time: this.stats.lastActivity, type, event });
-        if (this.stats.history.length > MAX_HISTORY_ITEMS)
-            this.stats.history.shift();
-        switch (type) {
-            case 'system':
-                if (event.subtype === 'init') {
-                    this.sessionId = event.session_id;
-                    this.stats.startTime = new Date().toISOString();
-                    this.emit(SESSION_EVENT.INIT, event);
-                }
-                this.emit(SESSION_EVENT.SYSTEM, event);
-                break;
-            case 'stream_event': {
-                const inner = event.event;
-                if (!inner)
-                    break;
-                const innerType = inner.type;
-                if (innerType === 'content_block_start') {
-                    const block = inner.content_block;
-                    if (block?.type === 'tool_use') {
-                        this.stats.toolCalls++;
-                        const toolEvent = { tool: { name: block.name, input: {} } };
-                        try {
-                            this._streamCallbacks?.onToolUse?.(toolEvent);
-                        }
-                        catch (err) {
-                            this.emit(SESSION_EVENT.LOG, `[stream callback error] onToolUse: ${err.message}`);
-                        }
-                        this.emit(SESSION_EVENT.TOOL_USE, toolEvent);
-                    }
-                }
-                else if (innerType === 'content_block_delta') {
-                    const delta = inner.delta;
-                    if (delta?.type === 'text_delta' && delta.text) {
-                        try {
-                            this._streamCallbacks?.onText?.(delta.text);
-                        }
-                        catch (err) {
-                            this.emit(SESSION_EVENT.LOG, `[stream callback error] onText: ${err.message}`);
-                        }
-                        this.emit(SESSION_EVENT.TEXT, delta.text);
-                    }
-                }
-                else if (innerType === 'message_delta') {
-                    const usage = inner.usage;
-                    if (usage) {
-                        this.stats.tokensIn += usage.input_tokens || 0;
-                        this.stats.tokensOut += usage.output_tokens || 0;
-                        this.stats.cachedTokens += usage.cache_read_input_tokens || 0;
-                        this._updateCost();
-                    }
-                }
-                this.emit(SESSION_EVENT.STREAM_EVENT, event);
-                break;
-            }
-            case 'user':
-                this.stats.turns++;
-                this.emit(SESSION_EVENT.USER_ECHO, event);
-                break;
-            case 'assistant':
-                this.emit(SESSION_EVENT.ASSISTANT, event);
-                if (event.message?.content && Array.isArray(event.message.content)) {
-                    for (const block of event.message.content) {
-                        if (block.type === 'tool_use') {
-                            this.stats.toolCalls++;
-                            const toolEvent = {
-                                tool: {
-                                    name: block.name,
-                                    input: block.input || {},
-                                },
-                            };
-                            try {
-                                this._streamCallbacks?.onToolUse?.(toolEvent);
-                            }
-                            catch (err) {
-                                this.emit(SESSION_EVENT.LOG, `[stream callback error] onToolUse: ${err.message}`);
-                            }
-                            this.emit(SESSION_EVENT.TOOL_USE, toolEvent);
-                        }
-                    }
-                }
-                break;
-            case 'tool_use':
-                this.stats.toolCalls++;
-                try {
-                    this._streamCallbacks?.onToolUse?.(event);
-                }
-                catch (err) {
-                    this.emit(SESSION_EVENT.LOG, `[stream callback error] onToolUse: ${err.message}`);
-                }
-                this.emit(SESSION_EVENT.TOOL_USE, event);
-                break;
-            case 'tool_result':
-                try {
-                    this._streamCallbacks?.onToolResult?.(event);
-                }
-                catch (err) {
-                    this.emit(SESSION_EVENT.LOG, `[stream callback error] onToolResult: ${err.message}`);
-                }
-                if (event.is_error || event.error) {
-                    this.stats.toolErrors++;
-                    this._fireHook('onToolError', {
-                        tool: event.tool_use_id,
-                        error: event.error,
-                    });
-                }
-                this.emit(SESSION_EVENT.TOOL_RESULT, event);
-                break;
-            case 'error':
-                this.emit(SESSION_EVENT.ERROR, new Error(String(event.error) || JSON.stringify(event)));
-                break;
-            case 'result': {
-                const usage = event.usage;
-                if (usage) {
-                    this.stats.tokensIn += usage.input_tokens || 0;
-                    this.stats.tokensOut += usage.output_tokens || 0;
-                    this.stats.cachedTokens += usage.cache_read_input_tokens || 0;
-                    this._updateCost();
-                }
-                this.emit(SESSION_EVENT.RESULT, event);
-                this.emit(SESSION_EVENT.TURN_COMPLETE, event);
-                this._fireHook('onTurnComplete', {
-                    text: event.result,
-                    usage,
-                    stopReason: event.stop_reason,
-                });
-                const totalTokens = this.stats.tokensIn + this.stats.tokensOut;
-                if (totalTokens > CONTEXT_HIGH_THRESHOLD && !this._contextHighFired) {
-                    this._contextHighFired = true;
-                    this._fireHook('onContextHigh', { tokensUsed: totalTokens, threshold: CONTEXT_HIGH_THRESHOLD });
-                }
-                const stopReason = event.stop_reason;
-                if (stopReason === 'error' || stopReason === 'rate_limit') {
-                    this._fireHook('onStopFailure', { reason: stopReason, error: event.error });
-                }
-                break;
-            }
-            default:
-                this.emit(SESSION_EVENT.EVENT, event);
-        }
-    }
-    // ─── Send ────────────────────────────────────────────────────────────────
-    async send(message, options = {}) {
-        if (!this._isReady || !this.proc)
-            throw new Error('Session not ready. Call start() first.');
-        const requestId = ++this.currentRequestId;
-        let finalMessage = typeof message === 'string' ? message : message;
-        if (typeof finalMessage === 'string') {
-            if (options.effort === 'high' || options.effort === 'max') {
-                finalMessage = `ultrathink\n\n${finalMessage}`;
-            }
-            if (options.plan) {
-                finalMessage = `/plan ${finalMessage}`;
-            }
-        }
-        const payload = {
-            type: 'user',
-            message: {
-                role: 'user',
-                content: typeof finalMessage === 'string' ? [{ type: 'text', text: finalMessage }] : finalMessage,
-            },
-        };
-        this.proc.stdin.write(JSON.stringify(payload) + '\n');
-        if (options.callbacks)
-            this._streamCallbacks = options.callbacks;
-        if (options.waitForComplete) {
-            this._isBusy = true;
-            try {
-                return await this._waitForTurnComplete(options.timeout || TURN_TIMEOUT_MS);
-            }
-            finally {
-                this._isBusy = false;
-                if (options.callbacks)
-                    this._streamCallbacks = null;
-            }
-        }
-        return { requestId, sent: true };
-    }
-    // ─── Wait for Turn Complete ──────────────────────────────────────────────
-    _waitForTurnComplete(timeout) {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            let streamedText = '';
-            let allAssistantText = '';
-            const toolNames = [];
-            const onText = (chunk) => {
-                streamedText += chunk;
-            };
-            this.on(SESSION_EVENT.TEXT, onText);
-            const onAssistant = (event) => {
-                if (event.message?.content && Array.isArray(event.message.content)) {
-                    for (const block of event.message.content) {
-                        if (block.type === 'text' && block.text)
-                            allAssistantText += block.text + '\n';
-                    }
-                }
-            };
-            this.on(SESSION_EVENT.ASSISTANT, onAssistant);
-            const onToolUse = (event) => {
-                const tool = event.tool;
-                toolNames.push(tool?.name || event.name || 'unknown');
-            };
-            this.on(SESSION_EVENT.TOOL_USE, onToolUse);
-            const cleanup = () => {
-                clearTimeout(timer);
-                this.removeListener(SESSION_EVENT.TEXT, onText);
-                this.removeListener(SESSION_EVENT.ASSISTANT, onAssistant);
-                this.removeListener(SESSION_EVENT.TOOL_USE, onToolUse);
-                this.removeListener(SESSION_EVENT.TURN_COMPLETE, onTurnComplete);
-                this.removeListener(SESSION_EVENT.ERROR, onError);
-                this.removeListener(SESSION_EVENT.CLOSE, onClose);
-            };
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                reject(new Error('Timeout waiting for response'));
-            }, timeout);
-            const onTurnComplete = (event) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                let text = event.result || streamedText || allAssistantText.trim() || '';
-                if (!text && toolNames.length > 0) {
-                    const unique = [...new Set(toolNames)];
-                    text = `[Agent completed ${toolNames.length} tool calls: ${unique.join(', ')}]`;
-                }
-                resolve({ text, event });
-            };
-            const onError = (err) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                reject(err);
-            };
-            const onClose = (code) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                const text = streamedText || allAssistantText.trim() || '';
-                resolve({
-                    text,
-                    event: {
-                        type: 'result',
-                        result: text,
-                        stop_reason: 'process_exit',
-                        exit_code: code,
-                    },
-                });
-            };
-            this.once(SESSION_EVENT.TURN_COMPLETE, onTurnComplete);
-            this.once(SESSION_EVENT.ERROR, onError);
-            this.once(SESSION_EVENT.CLOSE, onClose);
-        });
-    }
-    // ─── Utilities ───────────────────────────────────────────────────────────
-    getStats() {
-        return {
-            turns: this.stats.turns,
-            toolCalls: this.stats.toolCalls,
-            toolErrors: this.stats.toolErrors,
-            tokensIn: this.stats.tokensIn,
-            tokensOut: this.stats.tokensOut,
-            cachedTokens: this.stats.cachedTokens,
-            costUsd: Math.round(this.stats.costUsd * 10000) / 10000,
-            isReady: this._isReady,
-            startTime: this.stats.startTime,
-            lastActivity: this.stats.lastActivity,
-            // Approximate context window utilization based on model's known window size.
-            // Claude Code doesn't expose exact context usage via the JSON protocol,
-            // so this is a best-effort heuristic. May overcount because cumulative
-            // token counts include the full conversation history replayed each turn.
-            contextPercent: Math.min(100, Math.round(((this.stats.tokensIn + this.stats.tokensOut) /
-                getContextWindow(this.options.resolvedModel || this.options.model || 'claude-sonnet-4-6')) *
-                100)),
-            sessionId: this.sessionId,
-            uptime: this.stats.startTime ? Math.round((Date.now() - new Date(this.stats.startTime).getTime()) / 1000) : 0,
-        };
-    }
-    getHistory(limit = DEFAULT_HISTORY_LIMIT) {
-        return this.stats.history.slice(-limit);
-    }
-    async compact(summary) {
-        const msg = summary ? `/compact ${summary}` : '/compact';
-        return this.send(msg, { waitForComplete: true, timeout: COMPACT_TIMEOUT_MS });
-    }
-    getEffort() {
-        return this.options.effort || 'auto';
-    }
-    setEffort(level) {
-        this.options.effort = level;
-    }
-    getCost() {
-        const pricing = getModelPricing(this.options.model);
-        const nonCachedIn = Math.max(0, this.stats.tokensIn - this.stats.cachedTokens);
-        return {
-            model: this.options.model || 'default',
-            tokensIn: this.stats.tokensIn,
-            tokensOut: this.stats.tokensOut,
-            cachedTokens: this.stats.cachedTokens,
-            pricing: { inputPer1M: pricing.input, outputPer1M: pricing.output, cachedPer1M: pricing.cached },
-            breakdown: {
-                inputCost: (nonCachedIn / 1_000_000) * pricing.input,
-                cachedCost: (this.stats.cachedTokens / 1_000_000) * (pricing.cached ?? 0),
-                outputCost: (this.stats.tokensOut / 1_000_000) * pricing.output,
-            },
-            totalUsd: this.stats.costUsd,
-        };
-    }
-    resolveModel(alias) {
-        if (this.options.modelOverrides?.[alias])
-            return this.options.modelOverrides[alias];
-        return resolveAlias(alias);
-    }
-    pause() {
-        this._isPaused = true;
-        this.emit(SESSION_EVENT.PAUSED, { sessionId: this.sessionId });
-    }
-    resume() {
-        this._isPaused = false;
-        this.emit(SESSION_EVENT.RESUMED, { sessionId: this.sessionId });
-    }
-    stop() {
-        this._fireHook('onStop', { cost: this.getCost(), stats: this.getStats() });
-        if (this._rl) {
-            this._rl.close();
-            this._rl = null;
-        }
-        if (this.proc) {
-            const pid = this.proc.pid;
-            this.proc.stdin?.end();
-            this.proc.stdout?.destroy();
-            this.proc.stderr?.destroy();
-            try {
-                process.kill(-pid, 'SIGTERM');
-            }
-            catch (err) {
-                if (err.code !== 'ESRCH') {
-                    this.emit(SESSION_EVENT.LOG, `[stop] kill(-${pid}, SIGTERM) failed: ${err.message}`);
-                }
-                try {
-                    this.proc.kill('SIGTERM');
-                }
-                catch (innerErr) {
-                    if (innerErr.code !== 'ESRCH') {
-                        this.emit(SESSION_EVENT.LOG, `[stop] proc.kill(SIGTERM) failed: ${innerErr.message}`);
-                    }
-                }
-            }
-            const p = this.proc;
-            setTimeout(() => {
-                try {
-                    process.kill(-pid, 'SIGKILL');
-                }
-                catch {
-                    /* ESRCH expected — process already gone */
-                }
-                try {
-                    p.kill('SIGKILL');
-                }
-                catch {
-                    /* ESRCH expected */
-                }
-            }, STOP_SIGKILL_DELAY_MS);
-            this.proc = null;
-        }
-        this._isReady = false;
-        this._isPaused = false;
-        this.emit(SESSION_EVENT.CLOSE, 143);
-    }
-    // ─── Private ─────────────────────────────────────────────────────────────
-    _updateCost() {
-        const pricing = getModelPricing(this.options.model);
-        const nonCachedIn = Math.max(0, this.stats.tokensIn - this.stats.cachedTokens);
-        this.stats.costUsd =
-            (nonCachedIn / 1_000_000) * pricing.input +
-                (this.stats.cachedTokens / 1_000_000) * (pricing.cached ?? 0) +
-                (this.stats.tokensOut / 1_000_000) * pricing.output;
-    }
-    _fireHook(hookName, data) {
-        const hooks = this.options.hooks;
-        const hook = hooks?.[hookName];
-        if (typeof hook === 'function') {
-            try {
-                hook(data);
-            }
-            catch (err) {
-                this.emit(SESSION_EVENT.LOG, `[hook error] ${hookName}: ${err.message}`);
-            }
-        }
-        this.emit(`hook:${hookName}`, data);
-    }
-}
-//# sourceMappingURL=persistent-session.js.map