aicodeman 0.2.9 → 0.3.1

package/dist/session.js

@@ -1,16 +1,29 @@
 /**
  * @fileoverview Core PTY session wrapper for Claude CLI interactions.
  *
- * This module provides the Session class which manages a PTY (pseudo-terminal)
- * process running the Claude CLI. It supports three operation modes:
+ * Manages a PTY (pseudo-terminal) process running Claude CLI or OpenCode CLI.
+ * Three operation modes:
+ * 1. **One-shot** (`runPrompt`): Single prompt → JSON response
+ * 2. **Interactive** (`startInteractive`): Persistent interactive session
+ * 3. **Shell** (`startShell`): Plain bash shell for debugging
  *
- * 1. **One-shot mode** (`runPrompt`): Execute a single prompt and get JSON response
- * 2. **Interactive mode** (`startInteractive`): Start an interactive Claude session
- * 3. **Shell mode**: Run a plain bash shell for debugging/testing
+ * Optionally wraps in a tmux session for persistence across disconnects.
+ * Tracks tokens, costs, background tasks, and auto-compact/clear.
  *
- * The session can optionally run inside a tmux session for persistence across disconnects.
- * It tracks tokens, costs, background tasks, and supports
- * auto-clear/auto-compact functionality when token limits are approached.
+ * Key exports:
+ * - `Session` class — main entity, extends EventEmitter
+ * - `ClaudeMessage` interface — parsed JSON messages from Claude output
+ * - `SessionEvents` interface — typed event map
+ *
+ * Key methods: `runPrompt()`, `startInteractive()`, `startShell()`,
+ * `writeViaMux()`, `toState()`, `stop()`, `resize()`, `isIdle()`,
+ * `setAutoCompact()`, `findTaskDescriptionNear()`, `getTerminalBuffer()`
+ *
+ * @dependencies session-cli-builder (args/env), session-auto-ops (auto-compact/clear),
+ *   ralph-tracker (todo/completion parsing), bash-tool-parser (tool invocation tracking),
+ *   task-tracker (background tasks), mux-interface (tmux abstraction)
+ * @consumedby session-manager, web/server, respawn-controller
+ * @emits session:terminal, session:idle, session:working, session:completion, session:exit
  *
  * @module session
  */
@@ -22,9 +35,11 @@ import { TaskTracker } from './task-tracker.js';
 import { RalphTracker } from './ralph-tracker.js';
 import { BashToolParser } from './bash-tool-parser.js';
 import { BufferAccumulator } from './utils/buffer-accumulator.js';
-import { LRUMap } from './utils/lru-map.js';
 import { ANSI_ESCAPE_PATTERN_FULL, TOKEN_PATTERN, SPINNER_PATTERN, MAX_SESSION_TOKENS } from './utils/index.js';
 import { MAX_TERMINAL_BUFFER_SIZE, TRIM_TERMINAL_TO as TERMINAL_BUFFER_TRIM_SIZE, MAX_TEXT_OUTPUT_SIZE, TRIM_TEXT_TO as TEXT_OUTPUT_TRIM_SIZE, MAX_MESSAGES, MAX_LINE_BUFFER_SIZE, } from './config/buffer-limits.js';
+import { buildInteractiveArgs, buildPromptArgs, buildClaudeEnv, buildMuxAttachEnv, buildShellEnv, } from './session-cli-builder.js';
+import { SessionAutoOps } from './session-auto-ops.js';
+import { SessionTaskCache } from './session-task-cache.js';
 /** Line buffer flush interval (100ms) - forces processing of partial lines */
 const LINE_BUFFER_FLUSH_INTERVAL = 100;
 // ============================================================================
@@ -34,10 +49,7 @@ const LINE_BUFFER_FLUSH_INTERVAL = 100;
 const MUX_STARTUP_DELAY_MS = 300;
 /** Delay before declaring session idle after last output (2 seconds) */
 const IDLE_DETECTION_DELAY_MS = 2000;
-/** Delay for auto-compact/clear retry attempts (2 seconds) */
-const AUTO_RETRY_DELAY_MS = 2000;
-/** Delay for auto-compact/clear initial check (1 second) */
-const AUTO_INITIAL_DELAY_MS = 1000;
+// Note: Auto-compact/clear timing constants moved to session-auto-ops.ts
 /** Graceful shutdown delay when stopping session (100ms) */
 const GRACEFUL_SHUTDOWN_DELAY_MS = 100;
 // Filter out terminal focus escape sequences (focus in/out reports)
@@ -58,8 +70,6 @@ const LEADING_ANSI_WHITESPACE_PATTERN = /^(\x1b\[\??[\d;]*[A-Za-z]|[\s\r\n])+/;
 const CTRL_L_PATTERN = /\x0c/g;
 /** Pattern to split by newlines (CR or LF) */
 const NEWLINE_SPLIT_PATTERN = /\r?\n/;
-// Claude CLI PATH resolution — shared utility
-import { getAugmentedPath } from './utils/claude-cli-resolver.js';
 /**
  * Core session class that wraps a PTY process running Claude CLI or a shell.
  *
@@ -96,9 +106,8 @@ export class Session extends EventEmitter {
     workingDir;
     createdAt;
     mode;
-    /** Maximum number of task descriptions to keep (LRUMap handles size limit automatically) */
-    static MAX_TASK_DESCRIPTIONS = 100;
-    static TASK_DESCRIPTION_MAX_AGE_MS = 30000; // Keep descriptions for 30 seconds
+    // Task description cache (extracted to SessionTaskCache)
+    _taskCache = new SessionTaskCache();
     _name;
     ptyProcess = null;
     _pid = null;
@@ -125,14 +134,8 @@ export class Session extends EventEmitter {
     // Token tracking for auto-clear
     _totalInputTokens = 0;
     _totalOutputTokens = 0;
-    _autoClearThreshold = 140000; // Default 140k tokens
-    _autoClearEnabled = false;
-    _isClearing = false; // Prevent recursive clearing
-    // Auto-compact settings
-    _autoCompactThreshold = 110000; // Default 110k tokens (lower than clear)
-    _autoCompactEnabled = false;
-    _autoCompactPrompt = ''; // Optional prompt for compact
-    _isCompacting = false; // Prevent recursive compacting
+    // Auto-compact/auto-clear automation (extracted to SessionAutoOps)
+    _autoOps;
     // Image watcher setting (per-session toggle)
     _imageWatcherEnabled = false;
     // Flicker filter setting (per-session toggle, applied on frontend)
@@ -144,8 +147,6 @@ export class Session extends EventEmitter {
     _cliLatestVersion = '';
     _cliInfoParsed = false; // Only parse once per session
     // Timer tracking for cleanup (prevents memory leaks)
-    _autoCompactTimer = null;
-    _autoClearTimer = null;
     _promptCheckInterval = null;
     _promptCheckTimeout = null;
     _shellIdleTimer = null;
@@ -177,12 +178,7 @@ export class Session extends EventEmitter {
     // Bash tool tracking (file paths for live log viewing)
     _bashToolParser;
     _bashToolHandlers = null;
-    // Task descriptions parsed from terminal output (e.g., "Explore(Description)")
-    // Used to correlate with SubagentWatcher discoveries for better window titles
-    // Uses LRUMap for automatic eviction at MAX_TASK_DESCRIPTIONS limit
-    _recentTaskDescriptions = new LRUMap({
-        maxSize: Session.MAX_TASK_DESCRIPTIONS,
-    });
+    // Task descriptions parsed from terminal output — delegated to SessionTaskCache
     // Throttle expensive PTY processing (Ralph, bash parser, task descriptions)
     // Accumulates clean data between processing windows to avoid running regex on every chunk
     _lastExpensiveProcessTime = 0;
@@ -268,6 +264,21 @@ export class Session extends EventEmitter {
         this._bashToolParser.on('toolStart', this._bashToolHandlers.toolStart);
         this._bashToolParser.on('toolEnd', this._bashToolHandlers.toolEnd);
         this._bashToolParser.on('toolsUpdate', this._bashToolHandlers.toolsUpdate);
+        // Initialize auto-compact/auto-clear automation and forward events
+        this._autoOps = new SessionAutoOps({
+            writeCommand: (cmd) => this.writeViaMux(cmd),
+            isWorking: () => this._isWorking,
+            isStopped: () => this._isStopped,
+            getTotalTokens: () => this._totalInputTokens + this._totalOutputTokens,
+            getSessionId: () => this.id,
+        });
+        this._autoOps.on('autoCompact', (data) => this.emit('autoCompact', data));
+        this._autoOps.on('autoClear', (data) => {
+            // Reset token counts on clear
+            this._totalInputTokens = 0;
+            this._totalOutputTokens = 0;
+            this.emit('autoClear', data);
+        });
     }
     get status() {
         return this._status;
@@ -371,25 +382,7 @@ export class Session extends EventEmitter {
     get allowedTools() {
         return this._allowedTools;
     }
-    /**
-     * Build Claude CLI permission flags based on the configured mode.
-     * Returns an array of args to pass to the CLI.
-     */
-    _buildPermissionArgs() {
-        switch (this._claudeMode) {
-            case 'dangerously-skip-permissions':
-                return ['--dangerously-skip-permissions'];
-            case 'allowedTools':
-                if (this._allowedTools) {
-                    return ['--allowedTools', this._allowedTools];
-                }
-                // Fall back to normal mode if no tools specified
-                return [];
-            case 'normal':
-            default:
-                return [];
-        }
-    }
+    // Note: _buildPermissionArgs removed — now using buildInteractiveArgs from session-cli-builder.ts
     /**
      * Set CPU priority configuration.
      * Note: This only affects new sessions; existing running processes won't be changed.
@@ -448,10 +441,10 @@ export class Session extends EventEmitter {
         this._totalCost = totalCost;
     }
     get autoClearThreshold() {
-        return this._autoClearThreshold;
+        return this._autoOps.autoClearThreshold;
     }
     get autoClearEnabled() {
-        return this._autoClearEnabled;
+        return this._autoOps.autoClearEnabled;
     }
     get name() {
         return this._name;
@@ -459,51 +452,20 @@ export class Session extends EventEmitter {
     set name(value) {
         this._name = value;
     }
-    /** Minimum valid threshold for auto-clear/compact (1000 tokens) */
-    static MIN_AUTO_THRESHOLD = 1000;
-    /** Maximum valid threshold for auto-clear/compact (500k tokens) */
-    static MAX_AUTO_THRESHOLD = 500_000;
-    /** Default auto-clear threshold when invalid value provided */
-    static DEFAULT_AUTO_CLEAR_THRESHOLD = 140_000;
-    /** Default auto-compact threshold when invalid value provided */
-    static DEFAULT_AUTO_COMPACT_THRESHOLD = 110_000;
     setAutoClear(enabled, threshold) {
-        this._autoClearEnabled = enabled;
-        if (threshold !== undefined) {
-            // Validate threshold bounds
-            if (threshold < Session.MIN_AUTO_THRESHOLD || threshold > Session.MAX_AUTO_THRESHOLD) {
-                console.warn(`[Session ${this.id}] Invalid autoClear threshold ${threshold}, must be between ${Session.MIN_AUTO_THRESHOLD} and ${Session.MAX_AUTO_THRESHOLD}. Using default ${Session.DEFAULT_AUTO_CLEAR_THRESHOLD}.`);
-                this._autoClearThreshold = Session.DEFAULT_AUTO_CLEAR_THRESHOLD;
-            }
-            else {
-                this._autoClearThreshold = threshold;
-            }
-        }
+        this._autoOps.setAutoClear(enabled, threshold);
     }
     get autoCompactThreshold() {
-        return this._autoCompactThreshold;
+        return this._autoOps.autoCompactThreshold;
     }
     get autoCompactEnabled() {
-        return this._autoCompactEnabled;
+        return this._autoOps.autoCompactEnabled;
     }
     get autoCompactPrompt() {
-        return this._autoCompactPrompt;
+        return this._autoOps.autoCompactPrompt;
     }
     setAutoCompact(enabled, threshold, prompt) {
-        this._autoCompactEnabled = enabled;
-        if (threshold !== undefined) {
-            // Validate threshold bounds
-            if (threshold < Session.MIN_AUTO_THRESHOLD || threshold > Session.MAX_AUTO_THRESHOLD) {
-                console.warn(`[Session ${this.id}] Invalid autoCompact threshold ${threshold}, must be between ${Session.MIN_AUTO_THRESHOLD} and ${Session.MAX_AUTO_THRESHOLD}. Using default ${Session.DEFAULT_AUTO_COMPACT_THRESHOLD}.`);
-                this._autoCompactThreshold = Session.DEFAULT_AUTO_COMPACT_THRESHOLD;
-            }
-            else {
-                this._autoCompactThreshold = threshold;
-            }
-        }
-        if (prompt !== undefined) {
-            this._autoCompactPrompt = prompt;
-        }
+        this._autoOps.setAutoCompact(enabled, threshold, prompt);
     }
     get imageWatcherEnabled() {
         return this._imageWatcherEnabled;
@@ -537,11 +499,11 @@ export class Session extends EventEmitter {
             lastActivityAt: this._lastActivityAt,
             name: this._name,
             mode: this.mode,
-            autoClearEnabled: this._autoClearEnabled,
-            autoClearThreshold: this._autoClearThreshold,
-            autoCompactEnabled: this._autoCompactEnabled,
-            autoCompactThreshold: this._autoCompactThreshold,
-            autoCompactPrompt: this._autoCompactPrompt,
+            autoClearEnabled: this._autoOps.autoClearEnabled,
+            autoClearThreshold: this._autoOps.autoClearThreshold,
+            autoCompactEnabled: this._autoOps.autoCompactEnabled,
+            autoCompactThreshold: this._autoOps.autoCompactThreshold,
+            autoCompactPrompt: this._autoOps.autoCompactPrompt,
             imageWatcherEnabled: this._imageWatcherEnabled,
             totalCost: this._totalCost,
             inputTokens: this._totalInputTokens,
@@ -603,8 +565,8 @@ export class Session extends EventEmitter {
                 total: this._totalInputTokens + this._totalOutputTokens,
             },
             autoClear: {
-                enabled: this._autoClearEnabled,
-                threshold: this._autoClearThreshold,
+                enabled: this._autoOps.autoClearEnabled,
+                threshold: this._autoOps.autoClearThreshold,
             },
             // CPU priority configuration
             nice: {
@@ -707,14 +669,7 @@ export class Session extends EventEmitter {
                         cols: 120,
                         rows: 40,
                         cwd: this.workingDir,
-                        env: {
-                            ...process.env,
-                            LANG: 'en_US.UTF-8',
-                            LC_ALL: 'en_US.UTF-8',
-                            TERM: 'xterm-256color',
-                            COLORTERM: undefined,
-                            CLAUDECODE: undefined,
-                        },
+                        env: buildMuxAttachEnv(),
                     });
                     // Set claudeSessionId immediately since we passed --session-id to Claude
                     // The mux manager passes --session-id ${sessionId} to Claude
@@ -789,27 +744,13 @@ export class Session extends EventEmitter {
             try {
                 // Pass --session-id to use the SAME ID as the Codeman session
                 // This ensures subagents can be directly matched to the correct tab
-                const args = [...this._buildPermissionArgs(), '--session-id', this.id];
-                if (this._model)
-                    args.push('--model', this._model);
+                const args = buildInteractiveArgs(this.id, this._claudeMode, this._model, this._allowedTools);
                 this.ptyProcess = pty.spawn('claude', args, {
                     name: 'xterm-256color',
                     cols: 120,
                     rows: 40,
                     cwd: this.workingDir,
-                    env: {
-                        ...process.env,
-                        LANG: 'en_US.UTF-8',
-                        LC_ALL: 'en_US.UTF-8',
-                        PATH: getAugmentedPath(),
-                        TERM: 'xterm-256color',
-                        COLORTERM: undefined,
-                        CLAUDECODE: undefined,
-                        // Inform Claude it's running within Codeman (helps prevent self-termination)
-                        CODEMAN_MUX: '1',
-                        CODEMAN_SESSION_ID: this.id,
-                        CODEMAN_API_URL: process.env.CODEMAN_API_URL || 'http://localhost:3000',
-                    },
+                    env: buildClaudeEnv(this.id),
                 });
             }
             catch (spawnErr) {
@@ -1078,14 +1019,7 @@ export class Session extends EventEmitter {
                         cols: 120,
                         rows: 40,
                         cwd: this.workingDir,
-                        env: {
-                            ...process.env,
-                            LANG: 'en_US.UTF-8',
-                            LC_ALL: 'en_US.UTF-8',
-                            TERM: 'xterm-256color',
-                            COLORTERM: undefined,
-                            CLAUDECODE: undefined,
-                        },
+                        env: buildMuxAttachEnv(),
                     });
                 }
                 catch (spawnErr) {
@@ -1118,15 +1052,7 @@ export class Session extends EventEmitter {
                     cols: 120,
                     rows: 40,
                     cwd: this.workingDir,
-                    env: {
-                        ...process.env,
-                        LANG: 'en_US.UTF-8',
-                        LC_ALL: 'en_US.UTF-8',
-                        TERM: 'xterm-256color',
-                        CODEMAN_MUX: '1',
-                        CODEMAN_SESSION_ID: this.id,
-                        CODEMAN_API_URL: process.env.CODEMAN_API_URL || 'http://localhost:3000',
-                    },
+                    env: buildShellEnv(this.id),
                 });
             }
             catch (spawnErr) {
@@ -1219,30 +1145,14 @@ export class Session extends EventEmitter {
                 // Spawn claude in a real PTY
                 const model = options?.model;
                 console.log('[Session] Spawning PTY for claude with prompt:', prompt.substring(0, 50), model ? `(model: ${model})` : '');
-                const args = ['-p', '--verbose', '--dangerously-skip-permissions', '--output-format', 'stream-json'];
-                if (model) {
-                    args.push('--model', model);
-                }
-                args.push(prompt);
+                const args = buildPromptArgs(prompt, model);
                 try {
                     this.ptyProcess = pty.spawn('claude', args, {
                         name: 'xterm-256color',
                         cols: 120,
                         rows: 40,
                         cwd: this.workingDir,
-                        env: {
-                            ...process.env,
-                            LANG: 'en_US.UTF-8',
-                            LC_ALL: 'en_US.UTF-8',
-                            PATH: getAugmentedPath(),
-                            TERM: 'xterm-256color',
-                            COLORTERM: undefined,
-                            CLAUDECODE: undefined,
-                            // Inform Claude it's running within Codeman
-                            CODEMAN_MUX: '1',
-                            CODEMAN_SESSION_ID: this.id,
-                            CODEMAN_API_URL: process.env.CODEMAN_API_URL || 'http://localhost:3000',
-                        },
+                        env: buildClaudeEnv(this.id),
                     });
                 }
                 catch (spawnErr) {
@@ -1390,8 +1300,8 @@ export class Session extends EventEmitter {
                                 this._totalOutputTokens += outputDelta;
                             }
                             // Check if we should auto-compact or auto-clear
-                            this.checkAutoCompact();
-                            this.checkAutoClear();
+                            this._autoOps.checkAutoCompact();
+                            this._autoOps.checkAutoClear();
                         }
                     }
                     if (msg.type === 'result' && msg.total_cost_usd) {
@@ -1443,29 +1353,7 @@ export class Session extends EventEmitter {
         while ((match = TASK_TOOL_PATTERN.exec(cleanLine)) !== null) {
             const description = match[2].trim();
             if (description && description.length > 0) {
-                const now = Date.now();
-                this._recentTaskDescriptions.set(now, description);
-                // Cleanup old entries
-                this.cleanupOldTaskDescriptions();
-            }
-        }
-    }
-    /**
-     * Remove task descriptions older than TASK_DESCRIPTION_MAX_AGE_MS.
-     * Size limit is handled automatically by LRUMap eviction on set().
-     */
-    cleanupOldTaskDescriptions() {
-        const cutoff = Date.now() - Session.TASK_DESCRIPTION_MAX_AGE_MS;
-        // Keys are timestamps - iterate and delete expired entries
-        // LRUMap maintains insertion order, so we can break early once we find a non-expired entry
-        for (const timestamp of this._recentTaskDescriptions.keysInOrder()) {
-            if (timestamp < cutoff) {
-                this._recentTaskDescriptions.delete(timestamp);
-            }
-            else {
-                // Keys are ordered by insertion time (which is the timestamp)
-                // Once we find a non-expired one, all subsequent are also non-expired
-                break;
+                this._taskCache.add(Date.now(), description);
             }
         }
     }
@@ -1474,12 +1362,7 @@ export class Session extends EventEmitter {
      * Returns descriptions sorted by timestamp (most recent first).
      */
     getRecentTaskDescriptions() {
-        this.cleanupOldTaskDescriptions();
-        const results = [];
-        for (const [timestamp, description] of this._recentTaskDescriptions) {
-            results.push({ timestamp, description });
-        }
-        return results.sort((a, b) => b.timestamp - a.timestamp);
+        return this._taskCache.getAll();
     }
     /**
      * Find a task description that was parsed close to a given timestamp.
@@ -1490,18 +1373,7 @@ export class Session extends EventEmitter {
      * @returns The matching description or undefined
      */
     findTaskDescriptionNear(subagentStartTime, maxAgeMs = 10000) {
-        this.cleanupOldTaskDescriptions();
-        // Find the most recent description that was parsed before or around the subagent start time
-        let bestMatch;
-        let bestDiff = Infinity;
-        for (const [timestamp, description] of this._recentTaskDescriptions) {
-            const diff = Math.abs(subagentStartTime - timestamp);
-            if (diff < maxAgeMs && diff < bestDiff) {
-                bestMatch = { timestamp, description };
-                bestDiff = diff;
-            }
-        }
-        return bestMatch?.description;
+        return this._taskCache.findNear(subagentStartTime, maxAgeMs);
     }
     // Parse token count from Claude's status line in interactive mode
     // Matches patterns like "123.4k tokens", "5234 tokens", "1.2M tokens"
@@ -1555,8 +1427,8 @@ export class Session extends EventEmitter {
                 this._totalInputTokens += Math.round(delta * 0.6);
                 this._totalOutputTokens += Math.round(delta * 0.4);
                 // Check if we should auto-compact or auto-clear
-                this.checkAutoCompact();
-                this.checkAutoClear();
+                this._autoOps.checkAutoCompact();
+                this._autoOps.checkAutoClear();
             }
         }
     }
@@ -1629,108 +1501,7 @@ export class Session extends EventEmitter {
             });
         }
     }
-    // Check if we should auto-compact based on token threshold
-    checkAutoCompact() {
-        if (this._isStopped)
-            return; // Early exit check
-        if (!this._autoCompactEnabled || this._isCompacting || this._isClearing)
-            return;
-        const totalTokens = this._totalInputTokens + this._totalOutputTokens;
-        if (totalTokens >= this._autoCompactThreshold) {
-            this._isCompacting = true;
-            console.log(`[Session] Auto-compact triggered: ${totalTokens} tokens >= ${this._autoCompactThreshold} threshold`);
-            // Wait for Claude to be idle before compacting
-            const checkAndCompact = async () => {
-                // Check if session is still valid (not stopped) - must be first check
-                if (this._isStopped)
-                    return;
-                if (!this._isCompacting)
-                    return;
-                if (!this._isWorking) {
-                    // Re-check stopped state after async operation might have completed
-                    if (this._isStopped)
-                        return;
-                    // Send /compact command with optional prompt
-                    const compactCmd = this._autoCompactPrompt ? `/compact ${this._autoCompactPrompt}\r` : '/compact\r';
-                    await this.writeViaMux(compactCmd);
-                    this.emit('autoCompact', {
-                        tokens: totalTokens,
-                        threshold: this._autoCompactThreshold,
-                        prompt: this._autoCompactPrompt || undefined,
-                    });
-                    // Wait a moment then re-enable (longer than clear since compact takes time)
-                    if (!this._isStopped) {
-                        this._autoCompactTimer = setTimeout(() => {
-                            if (this._isStopped)
-                                return; // Check at callback start
-                            this._autoCompactTimer = null;
-                            this._isCompacting = false;
-                        }, 10000);
-                    }
-                }
-                else {
-                    // Check again after delay
-                    if (!this._isStopped) {
-                        this._autoCompactTimer = setTimeout(checkAndCompact, AUTO_RETRY_DELAY_MS);
-                    }
-                }
-            };
-            // Start checking after a short delay
-            if (!this._isStopped) {
-                this._autoCompactTimer = setTimeout(checkAndCompact, AUTO_INITIAL_DELAY_MS);
-            }
-        }
-    }
-    // Check if we should auto-clear based on token threshold
-    checkAutoClear() {
-        if (this._isStopped)
-            return; // Early exit check
-        if (!this._autoClearEnabled || this._isClearing || this._isCompacting)
-            return;
-        const totalTokens = this._totalInputTokens + this._totalOutputTokens;
-        if (totalTokens >= this._autoClearThreshold) {
-            this._isClearing = true;
-            console.log(`[Session] Auto-clear triggered: ${totalTokens} tokens >= ${this._autoClearThreshold} threshold`);
-            // Wait for Claude to be idle before clearing
-            const checkAndClear = async () => {
-                // Check if session is still valid (not stopped) - must be first check
-                if (this._isStopped)
-                    return;
-                if (!this._isClearing)
-                    return;
-                if (!this._isWorking) {
-                    // Re-check stopped state after async operation might have completed
-                    if (this._isStopped)
-                        return;
-                    // Send /clear command
-                    await this.writeViaMux('/clear\r');
-                    // Reset token counts
-                    this._totalInputTokens = 0;
-                    this._totalOutputTokens = 0;
-                    this.emit('autoClear', { tokens: totalTokens, threshold: this._autoClearThreshold });
-                    // Wait a moment then re-enable
-                    if (!this._isStopped) {
-                        this._autoClearTimer = setTimeout(() => {
-                            if (this._isStopped)
-                                return; // Check at callback start
-                            this._autoClearTimer = null;
-                            this._isClearing = false;
-                        }, 5000);
-                    }
-                }
-                else {
-                    // Check again after delay
-                    if (!this._isStopped) {
-                        this._autoClearTimer = setTimeout(checkAndClear, AUTO_RETRY_DELAY_MS);
-                    }
-                }
-            };
-            // Start checking after a short delay
-            if (!this._isStopped) {
-                this._autoClearTimer = setTimeout(checkAndClear, AUTO_INITIAL_DELAY_MS);
-            }
-        }
-    }
+    // Note: checkAutoCompact/checkAutoClear moved to SessionAutoOps (this._autoOps)
     /**
      * Sends input directly to the PTY process.
      *
@@ -1885,17 +1656,8 @@ export class Session extends EventEmitter {
             clearTimeout(this._lineBufferFlushTimer);
             this._lineBufferFlushTimer = null;
         }
-        // Clear auto-compact/auto-clear timers to prevent memory leaks
-        if (this._autoCompactTimer) {
-            clearTimeout(this._autoCompactTimer);
-            this._autoCompactTimer = null;
-        }
-        this._isCompacting = false;
-        if (this._autoClearTimer) {
-            clearTimeout(this._autoClearTimer);
-            this._autoClearTimer = null;
-        }
-        this._isClearing = false;
+        // Destroy auto-compact/auto-clear automation (clears its timers)
+        this._autoOps.destroy();
         // Clear prompt check timers
         if (this._promptCheckInterval) {
             clearInterval(this._promptCheckInterval);
@@ -1968,7 +1730,7 @@ export class Session extends EventEmitter {
         this._status = killMux ? 'stopped' : 'idle';
         this._currentTaskId = null;
         // Clear task description cache and agent tree to prevent memory leak
-        this._recentTaskDescriptions.clear();
+        this._taskCache.clear();
         this._childAgentIds = [];
         // Kill the associated mux session if requested
         if (killMux && this._mux) {
@@ -2019,7 +1781,7 @@ export class Session extends EventEmitter {
         this._messages = [];
         this._taskTracker.clear();
         this._ralphTracker.clear();
-        this._recentTaskDescriptions.clear();
+        this._taskCache.clear();
     }
 }
 //# sourceMappingURL=session.js.map