@mako10k/shell-server 0.2.3 → 0.3.0

package/dist/core/process-manager.js

@@ -12,63 +12,123 @@ export class ProcessManager {
     processes = new Map();
     maxConcurrentProcesses;
     outputDir;
-    terminalManager; // TerminalManager への参照
-    fileManager; // FileManager への参照
+    terminalManager; // Reference to TerminalManager
+    fileManager; // Reference to FileManager
     defaultWorkingDirectory;
     allowedWorkingDirectories;
-    backgroundProcessCallbacks = {}; // バックグラウンドプロセス終了コールバック
-    // Issue #13: PUB/SUB統合 - Feature Flag付きで段階的統合
+    backgroundProcessCallbacks = {}; // Background process completion callbacks
+    // Issue #13: PUB/SUB integration - phased rollout with feature flag
     streamPublisher;
     fileStorageSubscriber;
     realtimeStreamSubscriber;
     enableStreaming = false; // Feature Flag
-    constructor(maxConcurrentProcesses = 50, outputDir = '/tmp/mcp-shell-outputs', fileManager) {
-        this.maxConcurrentProcesses = maxConcurrentProcesses;
+    buildConcurrencyStopCandidates(limit = 5) {
+        const now = Date.now();
+        return Array.from(this.executions.values())
+            .filter((exec) => exec.status === 'running')
+            .sort((a, b) => {
+            const aStart = a.started_at ? new Date(a.started_at).getTime() : Number.MAX_SAFE_INTEGER;
+            const bStart = b.started_at ? new Date(b.started_at).getTime() : Number.MAX_SAFE_INTEGER;
+            return aStart - bStart;
+        })
+            .slice(0, limit)
+            .map((exec) => {
+            const startedAtMs = exec.started_at ? new Date(exec.started_at).getTime() : undefined;
+            const runtimeSeconds = startedAtMs && Number.isFinite(startedAtMs)
+                ? Math.max(0, Math.floor((now - startedAtMs) / 1000))
+                : undefined;
+            return {
+                execution_id: exec.execution_id,
+                ...(exec.process_id !== undefined ? { process_id: exec.process_id } : {}),
+                command: exec.command.length > 120 ? `${exec.command.slice(0, 117)}...` : exec.command,
+                ...(runtimeSeconds !== undefined ? { runtime_seconds: runtimeSeconds } : {}),
+                status: exec.status,
+                suggested_action: {
+                    tool: 'process_kill',
+                    parameters: {
+                        ...(exec.process_id !== undefined ? { process_id: exec.process_id } : {}),
+                        signal: 'TERM',
+                        force: false,
+                    },
+                },
+            };
+        });
+    }
+    getRunningExecutionCount() {
+        return Array.from(this.executions.values()).filter((exec) => exec.status === 'running').length;
+    }
+    async waitForExecutionSlot(maxWaitMs, pollIntervalMs = 100) {
+        if (this.getRunningExecutionCount() < this.maxConcurrentProcesses) {
+            return true;
+        }
+        if (maxWaitMs <= 0) {
+            return false;
+        }
+        const deadline = Date.now() + maxWaitMs;
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
+            });
+            if (this.getRunningExecutionCount() < this.maxConcurrentProcesses) {
+                return true;
+            }
+        }
+        return this.getRunningExecutionCount() < this.maxConcurrentProcesses;
+    }
+    constructor(maxConcurrentProcesses = 8, outputDir = '/tmp/mcp-shell-outputs', fileManager) {
+        const envMaxConcurrentRaw = process.env['SHELL_SERVER_MAX_CONCURRENT_PROCESSES'];
+        const envMaxConcurrentParsed = envMaxConcurrentRaw
+            ? Number.parseInt(envMaxConcurrentRaw, 10)
+            : NaN;
+        const resolvedMaxConcurrent = Number.isFinite(envMaxConcurrentParsed) && envMaxConcurrentParsed > 0
+            ? envMaxConcurrentParsed
+            : maxConcurrentProcesses;
+        this.maxConcurrentProcesses = resolvedMaxConcurrent;
         this.outputDir = outputDir;
         this.fileManager = fileManager;
         this.defaultWorkingDirectory = process.env['SHELL_SERVER_DEFAULT_WORKDIR'] || process.cwd();
         this.allowedWorkingDirectories = process.env['SHELL_SERVER_ALLOWED_WORKDIRS']
             ? process.env['SHELL_SERVER_ALLOWED_WORKDIRS'].split(',').map((dir) => dir.trim())
             : [process.cwd()];
-        // StreamPublisher初期化
+        // Initialize StreamPublisher
         this.streamPublisher = new StreamPublisher({
-            enableRealtimeStreaming: false, // 初期状態は無効
+            enableRealtimeStreaming: false, // disabled by default
             bufferSize: 8192,
             notificationInterval: 100,
         });
-        // 環境変数でStreaming機能を制御（段階的展開、デフォルト有効）
+        // Control streaming via environment variable (phased rollout, enabled by default)
         this.enableStreaming = process.env['SHELL_SERVER_ENABLE_STREAMING'] !== 'false';
         if (this.enableStreaming) {
             this.initializeStreamingComponents();
         }
         this.initializeOutputDirectory();
     }
-    // TerminalManager への参照を設定
+    // Set TerminalManager reference
     setTerminalManager(terminalManager) {
         this.terminalManager = terminalManager;
     }
-    // FileManager への参照を設定
+    // Set FileManager reference
     setFileManager(fileManager) {
         this.fileManager = fileManager;
-        // FileManagerが設定された時にStreaming機能を再初期化
+        // Reinitialize streaming when FileManager is set
         if (this.enableStreaming) {
             this.initializeStreamingComponents();
         }
     }
-    // バックグラウンドプロセス終了時のコールバックを設定
+    // Set callbacks for background process completion
     setBackgroundProcessCallbacks(callbacks) {
         this.backgroundProcessCallbacks = callbacks;
     }
-    // Issue #13: Streaming コンポーネントの初期化
+    // Issue #13: Initialize streaming components
     initializeStreamingComponents() {
         if (!this.fileManager) {
             console.error('ProcessManager: FileManager is required for streaming components');
             return;
         }
-        // FileStorageSubscriber初期化（既存FileManager機能を代替）
+        // Initialize FileStorageSubscriber (replacing part of existing FileManager handling)
         this.fileStorageSubscriber = new FileStorageSubscriber(this.fileManager, this.outputDir);
         this.streamPublisher.subscribe(this.fileStorageSubscriber);
-        // RealtimeStreamSubscriber初期化
+        // Initialize RealtimeStreamSubscriber
         this.realtimeStreamSubscriber = new RealtimeStreamSubscriber({
             bufferSize: 8192,
             notificationInterval: 100,
@@ -78,14 +138,14 @@ export class ProcessManager {
         this.streamPublisher.subscribe(this.realtimeStreamSubscriber);
         console.error('ProcessManager: Streaming components initialized');
     }
-    // Issue #13: Streaming機能の有効/無効切り替え
+    // Issue #13: Enable/disable streaming
     enableStreamingFeature(enable = true) {
         this.enableStreaming = enable;
         if (enable && this.fileManager) {
             this.initializeStreamingComponents();
         }
         else if (!enable) {
-            // Streaming無効化時のクリーンアップ
+            // Cleanup when streaming is disabled
             if (this.realtimeStreamSubscriber) {
                 this.streamPublisher.unsubscribe(this.realtimeStreamSubscriber.id);
                 this.realtimeStreamSubscriber.destroy();
@@ -97,12 +157,12 @@ export class ProcessManager {
             }
         }
     }
-    // Issue #13: RealtimeStreamSubscriber への参照を取得（新しいMCPツール用）
+    // Issue #13: Get RealtimeStreamSubscriber reference (for new MCP tools)
     getRealtimeStreamSubscriber() {
         return this.realtimeStreamSubscriber;
     }
     /**
-     * Issue #13: output_idから実行IDを取得
+    * Issue #13: Get execution ID from output_id
      */
     findExecutionIdByOutputId(outputId) {
         return this.fileManager?.getExecutionIdByOutputId(outputId);
@@ -111,41 +171,70 @@ export class ProcessManager {
         await ensureDirectory(this.outputDir);
     }
     async executeCommand(options) {
-        // 同時実行数のチェック
-        const runningProcesses = Array.from(this.executions.values()).filter((exec) => exec.status === 'running').length;
+        let effectiveOptions = { ...options };
+        // For adaptive mode, when all slots are occupied, wait for a free slot
+        // using the same foreground wait budget requested by the caller.
+        const runningProcesses = this.getRunningExecutionCount();
         if (runningProcesses >= this.maxConcurrentProcesses) {
-            throw new ResourceLimitError('concurrent processes', this.maxConcurrentProcesses);
+            const queueWaitBudgetSeconds = effectiveOptions.executionMode === 'adaptive'
+                ? (effectiveOptions.foregroundTimeoutSeconds ?? 10)
+                : 0;
+            const queueWaitBudgetMs = Math.max(0, Math.floor(queueWaitBudgetSeconds * 1000));
+            const waitStartedAt = Date.now();
+            const acquired = await this.waitForExecutionSlot(queueWaitBudgetMs);
+            const waitedMs = Date.now() - waitStartedAt;
+            if (!acquired) {
+                const currentRunning = this.getRunningExecutionCount();
+                const stopCandidates = this.buildConcurrencyStopCandidates();
+                throw new ResourceLimitError('concurrent processes', this.maxConcurrentProcesses, undefined, {
+                    code: 'CONCURRENCY_LIMIT_EXCEEDED',
+                    reason: `Concurrent execution limit reached (${currentRunning}/${this.maxConcurrentProcesses}) and no slot became available within ${Math.floor(waitedMs / 1000)}s queue wait budget.`,
+                    running_count: currentRunning,
+                    limit: this.maxConcurrentProcesses,
+                    queue_wait_budget_seconds: queueWaitBudgetSeconds,
+                    waited_seconds: Math.floor(waitedMs / 1000),
+                    stop_candidates: stopCandidates,
+                    next_steps: [
+                        'Call process_list with status_filter="running" to inspect active executions.',
+                        'Stop one or more long-running commands via process_kill, then retry shell_execute.',
+                    ],
+                });
+            }
+            if (effectiveOptions.executionMode === 'adaptive') {
+                const originalForegroundWaitSeconds = effectiveOptions.foregroundTimeoutSeconds ?? 10;
+                const remainingForegroundWaitSeconds = Math.max(1, Math.floor((originalForegroundWaitSeconds * 1000 - waitedMs) / 1000));
+                effectiveOptions = {
+                    ...effectiveOptions,
+                    foregroundTimeoutSeconds: remainingForegroundWaitSeconds,
+                };
+            }
         }
-        // 入力データの準備 - input_output_idが指定された場合の処理
-        let resolvedInputData = options.inputData;
+        // Prepare input data when input_output_id is specified
+        let resolvedInputData = effectiveOptions.inputData;
         let inputStream = undefined;
-        if (options.inputOutputId) {
+        if (effectiveOptions.inputOutputId) {
             if (!this.fileManager) {
                 throw new ExecutionError('FileManager is not available for input_output_id processing', {
-                    inputOutputId: options.inputOutputId,
+                    inputOutputId: effectiveOptions.inputOutputId,
                 });
             }
-            // output_idから実行IDを特定
-            const sourceExecutionId = this.findExecutionIdByOutputId(options.inputOutputId);
+            const sourceExecutionId = this.findExecutionIdByOutputId(effectiveOptions.inputOutputId);
             if (sourceExecutionId && this.realtimeStreamSubscriber) {
-                // 実行中プロセスの場合: StreamingPipelineReaderを使用
                 const streamState = this.realtimeStreamSubscriber.getStreamState(sourceExecutionId);
                 if (streamState && streamState.isActive) {
                     console.error(`ProcessManager: Using streaming pipeline for active process ${sourceExecutionId}`);
-                    inputStream = new StreamingPipelineReader(this.fileManager, this.realtimeStreamSubscriber, options.inputOutputId, sourceExecutionId);
+                    inputStream = new StreamingPipelineReader(this.fileManager, this.realtimeStreamSubscriber, effectiveOptions.inputOutputId, sourceExecutionId);
                 }
             }
-            // 実行中プロセスでない場合、または失敗した場合: 従来のファイル読み取り
             if (!inputStream) {
                 try {
-                    console.error(`ProcessManager: Using traditional file read for ${options.inputOutputId}`);
-                    const result = await this.fileManager.readFile(options.inputOutputId, 0, 100 * 1024 * 1024, // 100MB まで読み取り
-                    'utf-8');
+                    console.error(`ProcessManager: Using traditional file read for ${effectiveOptions.inputOutputId}`);
+                    const result = await this.fileManager.readFile(effectiveOptions.inputOutputId, 0, 100 * 1024 * 1024, 'utf-8');
                     resolvedInputData = result.content;
                 }
                 catch (error) {
-                    throw new ExecutionError(`Failed to read input from output_id: ${options.inputOutputId}`, {
-                        inputOutputId: options.inputOutputId,
+                    throw new ExecutionError(`Failed to read input from output_id: ${effectiveOptions.inputOutputId}`, {
+                        inputOutputId: effectiveOptions.inputOutputId,
                         originalError: String(error),
                     });
                 }
@@ -153,11 +242,10 @@ export class ProcessManager {
         }
         const executionId = generateId();
         const startTime = getCurrentTimestamp();
-        // 実行情報の初期化
-        const resolvedWorkingDirectory = this.resolveWorkingDirectory(options.workingDirectory);
+        const resolvedWorkingDirectory = this.resolveWorkingDirectory(effectiveOptions.workingDirectory);
         const executionInfo = {
             execution_id: executionId,
-            command: options.command,
+            command: effectiveOptions.command,
             status: 'running',
             working_directory: resolvedWorkingDirectory,
             default_working_directory: this.defaultWorkingDirectory,
@@ -165,30 +253,27 @@ export class ProcessManager {
             created_at: startTime,
             started_at: startTime,
         };
-        if (options.environmentVariables) {
-            executionInfo.environment_variables = options.environmentVariables;
+        if (effectiveOptions.environmentVariables) {
+            executionInfo.environment_variables = effectiveOptions.environmentVariables;
         }
         this.executions.set(executionId, executionInfo);
-        // 新規ターミナル作成オプションがある場合
-        if (options.createTerminal && this.terminalManager) {
+        if (effectiveOptions.createTerminal && this.terminalManager) {
             try {
                 const terminalOptions = {
                     sessionName: `exec-${executionId}`,
-                    shellType: options.terminalShell || 'bash',
-                    dimensions: options.terminalDimensions || { width: 80, height: 24 },
+                    shellType: effectiveOptions.terminalShell || 'bash',
+                    dimensions: effectiveOptions.terminalDimensions || { width: 80, height: 24 },
                     autoSaveHistory: true,
                 };
-                if (options.workingDirectory) {
-                    terminalOptions.workingDirectory = options.workingDirectory;
+                if (effectiveOptions.workingDirectory) {
+                    terminalOptions.workingDirectory = effectiveOptions.workingDirectory;
                 }
-                if (options.environmentVariables) {
-                    terminalOptions.environmentVariables = options.environmentVariables;
+                if (effectiveOptions.environmentVariables) {
+                    terminalOptions.environmentVariables = effectiveOptions.environmentVariables;
                 }
                 const terminalInfo = await this.terminalManager.createTerminal(terminalOptions);
                 executionInfo.terminal_id = terminalInfo.terminal_id;
-                // ターミナルにコマンドを送信
-                this.terminalManager.sendInput(terminalInfo.terminal_id, options.command, true);
-                // 実行情報を更新
+                this.terminalManager.sendInput(terminalInfo.terminal_id, effectiveOptions.command, true);
                 executionInfo.status = 'completed';
                 executionInfo.completed_at = getCurrentTimestamp();
                 this.executions.set(executionId, executionInfo);
@@ -204,17 +289,15 @@ export class ProcessManager {
             }
         }
         try {
-            // 実行オプションを準備
-            const { inputOutputId: _inputOutputId, ...baseOptions } = options;
+            const { inputOutputId: _inputOutputId, ...baseOptions } = effectiveOptions;
             const updatedOptions = {
                 ...baseOptions,
                 ...(resolvedInputData !== undefined && { inputData: resolvedInputData }),
             };
-            // StreamingPipelineReaderがある場合は特別処理
             if (inputStream) {
                 return await this.executeCommandWithInputStream(executionId, updatedOptions, inputStream);
             }
-            switch (options.executionMode) {
+            switch (effectiveOptions.executionMode) {
                 case 'foreground':
                     return await this.executeForegroundCommand(executionId, updatedOptions);
                 case 'adaptive':
@@ -224,11 +307,10 @@ export class ProcessManager {
                 case 'detached':
                     return await this.executeDetachedCommand(executionId, updatedOptions);
                 default:
-                    throw new ExecutionError('Unsupported execution mode', { mode: options.executionMode });
+                    throw new ExecutionError('Unsupported execution mode', { mode: effectiveOptions.executionMode });
             }
         }
         catch (error) {
-            // エラー時の実行情報更新
             const updatedInfo = this.executions.get(executionId);
             if (updatedInfo) {
                 updatedInfo.status = 'failed';
@@ -239,7 +321,7 @@ export class ProcessManager {
         }
     }
     /**
-     * Issue #13: StreamingPipelineReaderを使用したコマンド実行
+    * Issue #13: Execute command using StreamingPipelineReader
      */
     async executeCommandWithInputStream(executionId, options, inputStream) {
         console.error(`ProcessManager: Executing command with input stream for ${executionId}`);
@@ -248,15 +330,15 @@ export class ProcessManager {
             let stdout = '';
             let stderr = '';
             let outputTruncated = false;
-            // 環境変数の準備
+            // Prepare environment variables
             const env = getSafeEnvironment(process.env, options.environmentVariables);
-            // プロセスの起動
+            // Start process
             const child = spawn('sh', ['-c', options.command], {
                 cwd: this.resolveWorkingDirectory(options.workingDirectory),
                 env,
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
-            // StreamingPipelineReaderをSTDINに接続
+            // Connect StreamingPipelineReader to STDIN
             if (child.stdin) {
                 inputStream.pipe(child.stdin);
             }
@@ -264,11 +346,11 @@ export class ProcessManager {
                 console.error(`StreamingPipelineReader error for ${executionId}: ${error.message}`);
                 child.kill('SIGTERM');
             });
-            // StreamPublisher通知
+            // Notify StreamPublisher
             if (this.streamPublisher) {
                 this.streamPublisher.notifyProcessStart(executionId, options.command);
             }
-            // STDOUT処理
+            // Handle STDOUT
             if (child.stdout) {
                 child.stdout.on('data', (data) => {
                     const chunk = data.toString();
@@ -278,13 +360,13 @@ export class ProcessManager {
                     else {
                         outputTruncated = true;
                     }
-                    // StreamPublisher通知
+                    // Notify StreamPublisher
                     if (this.streamPublisher) {
                         this.streamPublisher.notifyOutputData(executionId, chunk, false);
                     }
                 });
             }
-            // STDERR処理
+            // Handle STDERR
             if (options.captureStderr && child.stderr) {
                 child.stderr.on('data', (data) => {
                     const chunk = data.toString();
@@ -294,29 +376,29 @@ export class ProcessManager {
                     else {
                         outputTruncated = true;
                     }
-                    // StreamPublisher通知
+                    // Notify StreamPublisher
                     if (this.streamPublisher) {
                         this.streamPublisher.notifyOutputData(executionId, chunk, true);
                     }
                 });
             }
-            // プロセス終了処理
+            // Handle process completion
             child.on('close', async (code) => {
                 const executionInfo = this.executions.get(executionId);
                 if (!executionInfo) {
                     reject(new ExecutionError('Execution info not found', { executionId }));
                     return;
                 }
-                // 実行時間の計算
+                // Calculate execution time
                 const executionTime = Date.now() - startTime;
-                // 実行情報の更新
+                // Update execution info
                 executionInfo.status = code === 0 ? 'completed' : 'failed';
                 executionInfo.completed_at = getCurrentTimestamp();
                 if (code !== null) {
                     executionInfo.exit_code = code;
                 }
                 executionInfo.execution_time_ms = executionTime;
-                // 出力の保存
+                // Save output
                 if (this.fileManager) {
                     try {
                         const combinedOutput = stdout + (options.captureStderr ? stderr : '');
@@ -331,7 +413,7 @@ export class ProcessManager {
                     }
                 }
                 this.executions.set(executionId, executionInfo);
-                // StreamPublisher通知
+                // Notify StreamPublisher
                 if (this.streamPublisher) {
                     this.streamPublisher.notifyProcessEnd(executionId, code);
                 }
@@ -340,24 +422,28 @@ export class ProcessManager {
             });
             child.on('error', (error) => {
                 console.error(`Process error for ${executionId}: ${error.message}`);
-                // StreamPublisher通知
+                // Notify StreamPublisher
                 if (this.streamPublisher) {
                     this.streamPublisher.notifyError(executionId, error);
                 }
                 reject(new ExecutionError(`Process error: ${error.message}`, { originalError: String(error) }));
             });
-            // タイムアウト処理
-            const timeout = setTimeout(() => {
-                console.error(`Process timeout for ${executionId}`);
-                child.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill('SIGKILL');
-                    }
-                }, 5000);
-            }, options.timeoutSeconds * 1000);
+            // Timeout handling
+            const timeout = options.timeoutSeconds !== undefined
+                ? setTimeout(() => {
+                    console.error(`Process timeout for ${executionId}`);
+                    child.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!child.killed) {
+                            child.kill('SIGKILL');
+                        }
+                    }, 5000);
+                }, options.timeoutSeconds * 1000)
+                : undefined;
             child.on('close', () => {
-                clearTimeout(timeout);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
             });
         });
     }
@@ -367,9 +453,9 @@ export class ProcessManager {
             let stdout = '';
             let stderr = '';
             let outputTruncated = false;
-            // 環境変数の準備
+            // Prepare environment variables
             const env = getSafeEnvironment(process.env, options.environmentVariables);
-            // プロセスの起動
+            // Start process
             const childProcess = spawn('/bin/bash', ['-c', options.command], {
                 cwd: this.resolveWorkingDirectory(options.workingDirectory),
                 env,
@@ -378,48 +464,50 @@ export class ProcessManager {
             if (childProcess.pid) {
                 this.processes.set(childProcess.pid, childProcess);
             }
-            // タイムアウトの設定
-            const timeout = setTimeout(async () => {
-                childProcess.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!childProcess.killed) {
-                        childProcess.kill('SIGKILL');
-                    }
-                }, 5000);
-                const executionTime = Date.now() - startTime;
-                const executionInfo = this.executions.get(executionId);
-                if (executionInfo) {
-                    executionInfo.status = 'timeout';
-                    executionInfo.stdout = sanitizeString(stdout);
-                    executionInfo.stderr = sanitizeString(stderr);
-                    executionInfo.completed_at = getCurrentTimestamp();
-                    executionInfo.execution_time_ms = executionTime;
-                    if (childProcess.pid !== undefined) {
-                        executionInfo.process_id = childProcess.pid;
-                    }
-                    // 出力をFileManagerに保存（サイズに関係なく）
-                    let outputFileId;
-                    try {
-                        outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                        executionInfo.output_id = outputFileId;
-                    }
-                    catch (error) {
-                        // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
-                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                    }
-                    // 出力状態の詳細情報を設定
-                    this.setOutputStatus(executionInfo, outputTruncated, 'timeout', outputFileId);
-                    this.executions.set(executionId, executionInfo);
-                    // return_partial_on_timeout が true の場合は部分結果を返す
-                    if (options.returnPartialOnTimeout) {
-                        resolve(executionInfo);
-                        return;
+            // Set timeout
+            const timeout = options.timeoutSeconds !== undefined
+                ? setTimeout(async () => {
+                    childProcess.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!childProcess.killed) {
+                            childProcess.kill('SIGKILL');
+                        }
+                    }, 5000);
+                    const executionTime = Date.now() - startTime;
+                    const executionInfo = this.executions.get(executionId);
+                    if (executionInfo) {
+                        executionInfo.status = 'timeout';
+                        executionInfo.stdout = sanitizeString(stdout);
+                        executionInfo.stderr = sanitizeString(stderr);
+                        executionInfo.completed_at = getCurrentTimestamp();
+                        executionInfo.execution_time_ms = executionTime;
+                        if (childProcess.pid !== undefined) {
+                            executionInfo.process_id = childProcess.pid;
+                        }
+                        // Save output to FileManager (regardless of size)
+                        let outputFileId;
+                        try {
+                            outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                            executionInfo.output_id = outputFileId;
+                        }
+                        catch (error) {
+                            // Record file-save failures as critical errors and include them in execution info
+                            console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                            executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        // Set detailed output status
+                        this.setOutputStatus(executionInfo, outputTruncated, 'timeout', outputFileId);
+                        this.executions.set(executionId, executionInfo);
+                        // Return partial result when return_partial_on_timeout is true
+                        if (options.returnPartialOnTimeout) {
+                            resolve(executionInfo);
+                            return;
+                        }
                     }
-                }
-                reject(new TimeoutError(options.timeoutSeconds));
-            }, options.timeoutSeconds * 1000);
-            // 標準入力の送信
+                    reject(new TimeoutError(options.timeoutSeconds ?? 0));
+                }, options.timeoutSeconds * 1000)
+                : undefined;
+            // Send stdin
             if (options.inputData) {
                 childProcess.stdin?.write(options.inputData);
                 childProcess.stdin?.end();
@@ -427,7 +515,7 @@ export class ProcessManager {
             else {
                 childProcess.stdin?.end();
             }
-            // 標準出力の処理
+            // Handle stdout
             childProcess.stdout?.on('data', (data) => {
                 const output = data.toString();
                 if (stdout.length + output.length <= options.maxOutputSize) {
@@ -438,7 +526,7 @@ export class ProcessManager {
                     outputTruncated = true;
                 }
             });
-            // 標準エラー出力の処理
+            // Handle stderr
             if (options.captureStderr) {
                 childProcess.stderr?.on('data', (data) => {
                     const output = data.toString();
@@ -451,9 +539,11 @@ export class ProcessManager {
                     }
                 });
             }
-            // プロセス終了時の処理
+            // Handle process close
             childProcess.on('close', async (code) => {
-                clearTimeout(timeout);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
@@ -469,30 +559,30 @@ export class ProcessManager {
                         executionInfo.process_id = childProcess.pid;
                     }
                     executionInfo.completed_at = getCurrentTimestamp();
-                    // 出力をFileManagerに保存（サイズに関係なく）
+                    // Save output to FileManager (regardless of size)
                     let outputFileId;
                     try {
                         outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
                         executionInfo.output_id = outputFileId;
                     }
                     catch (error) {
-                        // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
+                        // Record file-save failures as critical errors and include them in execution info
                         console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
                         executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
                     }
-                    // 出力状態の詳細情報を設定
+                    // Set detailed output status
                     if (outputTruncated) {
                         this.setOutputStatus(executionInfo, true, 'size_limit', outputFileId);
                     }
                     else {
-                        // 通常完了時 - actuallyTruncated=false, 適当なreasonで完了時ガイダンスを表示
+                        // Normal completion: actuallyTruncated=false, use a valid reason to show completion guidance
                         this.setOutputStatus(executionInfo, false, 'size_limit', outputFileId);
                     }
                     this.executions.set(executionId, executionInfo);
                     resolve(executionInfo);
                 }
             });
-            // エラー処理
+            // Error handling
             childProcess.on('error', (error) => {
                 clearTimeout(timeout);
                 if (childProcess.pid) {
@@ -512,9 +602,9 @@ export class ProcessManager {
         });
     }
     async executeAdaptiveCommand(executionId, options) {
-        // adaptiveモード: 1つのプロセスを起動し、以下の条件でバックグラウンドに移行
-        // 1. フォアグラウンドタイムアウトに達した場合
-        // 2. 出力サイズ制限に達した場合
+        // Adaptive mode: start one process and transition to background when:
+        // 1. Foreground timeout is reached
+        // 2. Output size limit is reached
         const returnPartialOnTimeout = options.returnPartialOnTimeout ?? true;
         const foregroundTimeout = options.foregroundTimeoutSeconds ?? 10;
         return new Promise((resolve, reject) => {
@@ -523,9 +613,9 @@ export class ProcessManager {
             let stderr = '';
             let outputTruncated = false;
             let backgroundTransitionReason = null;
-            // 環境変数の準備
+            // Prepare environment variables
             const env = getSafeEnvironment(process.env, options.environmentVariables);
-            // プロセスの起動（バックグラウンド対応）
+            // Start process (supports background transition)
             const childProcess = spawn('/bin/bash', ['-c', options.command], {
                 cwd: this.resolveWorkingDirectory(options.workingDirectory),
                 env,
@@ -534,48 +624,50 @@ export class ProcessManager {
             if (childProcess.pid) {
                 this.processes.set(childProcess.pid, childProcess);
             }
-            // フォアグラウンドタイムアウトの設定
+            // Set foreground timeout
             const foregroundTimeoutHandle = setTimeout(() => {
                 if (!backgroundTransitionReason) {
                     backgroundTransitionReason = 'timeout';
                     transitionToBackground();
                 }
             }, foregroundTimeout * 1000);
-            // 最終タイムアウトの設定
-            const finalTimeoutHandle = setTimeout(async () => {
-                childProcess.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!childProcess.killed) {
-                        childProcess.kill('SIGKILL');
-                    }
-                }, 5000);
-                const executionInfo = this.executions.get(executionId);
-                if (executionInfo) {
-                    executionInfo.status = 'timeout';
-                    executionInfo.stdout = sanitizeString(stdout);
-                    executionInfo.stderr = sanitizeString(stderr);
-                    executionInfo.output_truncated = outputTruncated;
-                    executionInfo.completed_at = getCurrentTimestamp();
-                    executionInfo.execution_time_ms = Date.now() - startTime;
-                    // 出力をFileManagerに保存
-                    try {
-                        const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                        executionInfo.output_id = outputFileId;
-                    }
-                    catch (error) {
-                        // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
-                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                    }
-                    this.executions.set(executionId, executionInfo);
-                    if (returnPartialOnTimeout) {
-                        resolve(executionInfo);
-                        return;
+            // Set final timeout
+            const finalTimeoutHandle = options.timeoutSeconds !== undefined
+                ? setTimeout(async () => {
+                    childProcess.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!childProcess.killed) {
+                            childProcess.kill('SIGKILL');
+                        }
+                    }, 5000);
+                    const executionInfo = this.executions.get(executionId);
+                    if (executionInfo) {
+                        executionInfo.status = 'timeout';
+                        executionInfo.stdout = sanitizeString(stdout);
+                        executionInfo.stderr = sanitizeString(stderr);
+                        executionInfo.output_truncated = outputTruncated;
+                        executionInfo.completed_at = getCurrentTimestamp();
+                        executionInfo.execution_time_ms = Date.now() - startTime;
+                        // Save output to FileManager
+                        try {
+                            const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                            executionInfo.output_id = outputFileId;
+                        }
+                        catch (error) {
+                            // Record file-save failures as critical errors and include them in execution info
+                            console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                            executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        this.executions.set(executionId, executionInfo);
+                        if (returnPartialOnTimeout) {
+                            resolve(executionInfo);
+                            return;
+                        }
                     }
-                }
-                reject(new TimeoutError(options.timeoutSeconds));
-            }, options.timeoutSeconds * 1000);
-            // バックグラウンドに移行する関数
+                    reject(new TimeoutError(options.timeoutSeconds ?? 0));
+                }, options.timeoutSeconds * 1000)
+                : undefined;
+            // Function to transition to background mode
             const transitionToBackground = async () => {
                 clearTimeout(foregroundTimeoutHandle);
                 const executionInfo = this.executions.get(executionId);
@@ -583,7 +675,7 @@ export class ProcessManager {
                     executionInfo.status = 'running';
                     executionInfo.stdout = sanitizeString(stdout);
                     executionInfo.stderr = sanitizeString(stderr);
-                    // 移行理由を記録
+                    // Record transition reason
                     if (backgroundTransitionReason === 'timeout') {
                         executionInfo.transition_reason = 'foreground_timeout';
                     }
@@ -593,29 +685,34 @@ export class ProcessManager {
                     if (childProcess.pid !== undefined) {
                         executionInfo.process_id = childProcess.pid;
                     }
-                    // 出力をFileManagerに保存
+                    // Save output to FileManager
                     let outputFileId;
                     try {
                         outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
                         executionInfo.output_id = outputFileId;
                     }
                     catch (error) {
-                        // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
+                        // Record file-save failures as critical errors and include them in execution info
                         console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
                         executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
                     }
-                    // 出力状態の詳細情報を設定（バックグラウンド移行）
+                    // Set detailed output status (background transition)
                     this.setOutputStatus(executionInfo, outputTruncated, 'background_transition', outputFileId);
                     this.executions.set(executionId, executionInfo);
-                    // バックグラウンド処理の継続設定（adaptive mode専用）
+                    // Configure continued background handling (adaptive mode only)
+                    const remainingTimeoutSeconds = options.timeoutSeconds !== undefined
+                        ? Math.max(1, options.timeoutSeconds - Math.floor((Date.now() - startTime) / 1000))
+                        : undefined;
                     this.handleAdaptiveBackgroundTransition(executionId, childProcess, {
                         ...options,
-                        timeoutSeconds: Math.max(1, options.timeoutSeconds - Math.floor((Date.now() - startTime) / 1000)),
+                        ...(remainingTimeoutSeconds !== undefined
+                            ? { timeoutSeconds: remainingTimeoutSeconds }
+                            : {}),
                     });
                     resolve(executionInfo);
                 }
             };
-            // 標準入力の送信
+            // Send stdin
             if (options.inputData) {
                 childProcess.stdin?.write(options.inputData);
                 childProcess.stdin?.end();
@@ -623,7 +720,7 @@ export class ProcessManager {
             else {
                 childProcess.stdin?.end();
             }
-            // 標準出力の処理
+            // Handle stdout
             childProcess.stdout?.on('data', (data) => {
                 const output = data.toString();
                 if (stdout.length + output.length <= options.maxOutputSize) {
@@ -632,14 +729,14 @@ export class ProcessManager {
                 else {
                     stdout += output.substring(0, options.maxOutputSize - stdout.length);
                     outputTruncated = true;
-                    // 出力サイズ制限に達した場合、バックグラウンドに移行
+                    // Transition to background when output size limit is reached
                     if (!backgroundTransitionReason) {
                         backgroundTransitionReason = 'output_size_limit';
                         transitionToBackground();
                     }
                 }
             });
-            // 標準エラー出力の処理
+            // Handle stderr
             if (options.captureStderr) {
                 childProcess.stderr?.on('data', (data) => {
                     const output = data.toString();
@@ -649,7 +746,7 @@ export class ProcessManager {
                     else {
                         stderr += output.substring(0, options.maxOutputSize - stderr.length);
                         outputTruncated = true;
-                        // 出力サイズ制限に達した場合、バックグラウンドに移行
+                        // Transition to background when output size limit is reached
                         if (!backgroundTransitionReason) {
                             backgroundTransitionReason = 'output_size_limit';
                             transitionToBackground();
@@ -657,14 +754,16 @@ export class ProcessManager {
                     }
                 });
             }
-            // プロセス終了時の処理
+            // Handle process close
             childProcess.on('close', async (code) => {
                 clearTimeout(foregroundTimeoutHandle);
-                clearTimeout(finalTimeoutHandle);
+                if (finalTimeoutHandle) {
+                    clearTimeout(finalTimeoutHandle);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
-                // バックグラウンドに移行していない場合のみ処理
+                // Handle only when no background transition occurred
                 if (!backgroundTransitionReason) {
                     const executionTime = Date.now() - startTime;
                     const executionInfo = this.executions.get(executionId);
@@ -679,13 +778,13 @@ export class ProcessManager {
                             executionInfo.process_id = childProcess.pid;
                         }
                         executionInfo.completed_at = getCurrentTimestamp();
-                        // 出力をFileManagerに保存
+                        // Save output to FileManager
                         try {
                             const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
                             executionInfo.output_id = outputFileId;
                         }
                         catch (error) {
-                            // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
+                            // Record file-save failures as critical errors and include them in execution info
                             console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
                             executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
                         }
@@ -694,10 +793,12 @@ export class ProcessManager {
                     }
                 }
             });
-            // エラー処理
+            // Error handling
             childProcess.on('error', (error) => {
                 clearTimeout(foregroundTimeoutHandle);
-                clearTimeout(finalTimeoutHandle);
+                if (finalTimeoutHandle) {
+                    clearTimeout(finalTimeoutHandle);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
@@ -732,7 +833,7 @@ export class ProcessManager {
             executionInfo.process_id = childProcess.pid;
             this.executions.set(executionId, executionInfo);
         }
-        // バックグラウンドプロセスの場合、出力を非同期で処理
+        // For background processes, handle output asynchronously
         if (options.executionMode === 'background') {
             this.handleBackgroundProcess(executionId, childProcess, options);
         }
@@ -746,54 +847,56 @@ export class ProcessManager {
         const startTime = Date.now();
         let stdout = '';
         let stderr = '';
-        // タイムアウトの設定（backgroundプロセス用）
-        const timeout = setTimeout(async () => {
-            childProcess.kill('SIGTERM');
-            setTimeout(() => {
-                if (!childProcess.killed) {
-                    childProcess.kill('SIGKILL');
-                }
-            }, 5000);
-            const executionInfo = this.executions.get(executionId);
-            if (executionInfo) {
-                executionInfo.status = 'timeout';
-                executionInfo.stdout = stdout;
-                executionInfo.stderr = stderr;
-                executionInfo.output_truncated = true;
-                executionInfo.completed_at = getCurrentTimestamp();
-                executionInfo.execution_time_ms = Date.now() - startTime;
-                // 出力をFileManagerに保存
-                try {
-                    const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                    executionInfo.output_id = outputFileId;
-                }
-                catch (error) {
-                    // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
-                    console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                    executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                }
-                this.executions.set(executionId, executionInfo);
-                // バックグラウンドプロセスタイムアウトのコールバック呼び出し
-                if (this.backgroundProcessCallbacks.onTimeout) {
-                    setImmediate(async () => {
-                        try {
-                            const callback = this.backgroundProcessCallbacks.onTimeout;
-                            if (callback) {
-                                const result = callback(executionId, executionInfo);
-                                if (result instanceof Promise) {
-                                    await result;
+        // Set timeout (for background processes)
+        const timeout = options.timeoutSeconds !== undefined
+            ? setTimeout(async () => {
+                childProcess.kill('SIGTERM');
+                setTimeout(() => {
+                    if (!childProcess.killed) {
+                        childProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+                const executionInfo = this.executions.get(executionId);
+                if (executionInfo) {
+                    executionInfo.status = 'timeout';
+                    executionInfo.stdout = stdout;
+                    executionInfo.stderr = stderr;
+                    executionInfo.output_truncated = true;
+                    executionInfo.completed_at = getCurrentTimestamp();
+                    executionInfo.execution_time_ms = Date.now() - startTime;
+                    // Save output to FileManager
+                    try {
+                        const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                        executionInfo.output_id = outputFileId;
+                    }
+                    catch (error) {
+                        // Record file-save failures as critical errors and include them in execution info
+                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                    this.executions.set(executionId, executionInfo);
+                    // Invoke timeout callback for background process
+                    if (this.backgroundProcessCallbacks.onTimeout) {
+                        setImmediate(async () => {
+                            try {
+                                const callback = this.backgroundProcessCallbacks.onTimeout;
+                                if (callback) {
+                                    const result = callback(executionId, executionInfo);
+                                    if (result instanceof Promise) {
+                                        await result;
+                                    }
                                 }
                             }
-                        }
-                        catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
-                            // console.error('Background process timeout callback error:', callbackError);
-                        }
-                    });
+                            catch (callbackError) {
+                                // Record callback errors in internal logs only
+                                // console.error('Background process timeout callback error:', callbackError);
+                            }
+                        });
+                    }
                 }
-            }
-        }, options.timeoutSeconds * 1000);
-        // 出力の収集
+            }, options.timeoutSeconds * 1000)
+            : undefined;
+        // Collect output
         childProcess.stdout?.on('data', (data) => {
             stdout += data.toString();
         });
@@ -802,9 +905,11 @@ export class ProcessManager {
                 stderr += data.toString();
             });
         }
-        // プロセス終了時の処理
+        // Handle process close
         childProcess.on('close', async (code) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -814,18 +919,18 @@ export class ProcessManager {
                 executionInfo.exit_code = code || 0;
                 executionInfo.execution_time_ms = Date.now() - startTime;
                 executionInfo.completed_at = getCurrentTimestamp();
-                // 出力をファイルに保存
+                // Save output to file
                 try {
                     const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
                     executionInfo.output_id = outputFileId;
                 }
                 catch (error) {
-                    // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
+                    // Record file-save failures as critical errors and include them in execution info
                     console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
                     executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
                 }
                 this.executions.set(executionId, executionInfo);
-                // バックグラウンドプロセス正常終了のコールバック呼び出し
+                // Invoke completion callback for background process
                 if (this.backgroundProcessCallbacks.onComplete) {
                     setImmediate(async () => {
                         try {
@@ -838,7 +943,7 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Background process completion callback error:', callbackError);
                         }
                     });
@@ -846,7 +951,9 @@ export class ProcessManager {
             }
         });
         childProcess.on('error', (error) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -856,7 +963,7 @@ export class ProcessManager {
                 executionInfo.execution_time_ms = Date.now() - startTime;
                 executionInfo.completed_at = getCurrentTimestamp();
                 this.executions.set(executionId, executionInfo);
-                // バックグラウンドプロセスエラーのコールバック呼び出し
+                // Invoke error callback for background process
                 if (this.backgroundProcessCallbacks.onError) {
                     setImmediate(async () => {
                         try {
@@ -869,7 +976,7 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Background process error callback error:', callbackError);
                         }
                     });
@@ -877,27 +984,31 @@ export class ProcessManager {
             }
         });
     }
-    // adaptive modeでバックグラウンドに移行したプロセスの処理
+    // Handle processes transitioned to background in adaptive mode
     handleAdaptiveBackgroundTransition(executionId, childProcess, options) {
-        // タイムアウトの設定（最終タイムアウト）
-        const timeout = setTimeout(async () => {
-            childProcess.kill('SIGTERM');
-            setTimeout(() => {
-                if (!childProcess.killed) {
-                    childProcess.kill('SIGKILL');
+        // Set timeout (final timeout)
+        const timeout = options.timeoutSeconds !== undefined
+            ? setTimeout(async () => {
+                childProcess.kill('SIGTERM');
+                setTimeout(() => {
+                    if (!childProcess.killed) {
+                        childProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+                const executionInfo = this.executions.get(executionId);
+                if (executionInfo) {
+                    executionInfo.status = 'timeout';
+                    executionInfo.completed_at = getCurrentTimestamp();
+                    // Keep existing output (already captured in adaptive mode)
+                    this.executions.set(executionId, executionInfo);
                 }
-            }, 5000);
-            const executionInfo = this.executions.get(executionId);
-            if (executionInfo) {
-                executionInfo.status = 'timeout';
-                executionInfo.completed_at = getCurrentTimestamp();
-                // 既存の出力は保持（adaptive modeで既にキャプチャ済み）
-                this.executions.set(executionId, executionInfo);
-            }
-        }, options.timeoutSeconds * 1000);
-        // プロセス終了時の処理
+            }, options.timeoutSeconds * 1000)
+            : undefined;
+        // Handle process close
         childProcess.on('close', async (code) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -906,13 +1017,13 @@ export class ProcessManager {
                 executionInfo.status = 'completed';
                 executionInfo.exit_code = code || 0;
                 executionInfo.completed_at = getCurrentTimestamp();
-                // 実行時間は全体（フォアグラウンド + バックグラウンド）で計算
+                // Calculate total execution time (foreground + background)
                 if (executionInfo.started_at) {
                     const startTime = new Date(executionInfo.started_at).getTime();
                     executionInfo.execution_time_ms = Date.now() - startTime;
                 }
                 this.executions.set(executionId, executionInfo);
-                // adaptive modeバックグラウンドプロセス正常終了のコールバック呼び出し
+                // Invoke completion callback for adaptive-mode background process
                 if (this.backgroundProcessCallbacks.onComplete) {
                     setImmediate(async () => {
                         try {
@@ -925,7 +1036,7 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Adaptive background process completion callback error:', callbackError);
                         }
                     });
@@ -933,7 +1044,9 @@ export class ProcessManager {
             }
         });
         childProcess.on('error', (error) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -946,7 +1059,7 @@ export class ProcessManager {
                     executionInfo.execution_time_ms = Date.now() - startTime;
                 }
                 this.executions.set(executionId, executionInfo);
-                // adaptive modeバックグラウンドプロセスエラーのコールバック呼び出し
+                // Invoke error callback for adaptive-mode background process
                 if (this.backgroundProcessCallbacks.onError) {
                     setImmediate(async () => {
                         try {
@@ -959,7 +1072,7 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Adaptive background process error callback error:', callbackError);
                         }
                     });
@@ -968,23 +1081,23 @@ export class ProcessManager {
         });
     }
     async executeDetachedCommand(executionId, options) {
-        // detachedモード: 完全にバックグラウンドで実行し、親プロセスとの接続を切断
+        // Detached mode: run fully in background and detach from parent process
         const env = getSafeEnvironment(process.env, options.environmentVariables);
         const childProcess = spawn('/bin/bash', ['-c', options.command], {
             cwd: this.resolveWorkingDirectory(options.workingDirectory),
             env,
-            stdio: ['ignore', 'pipe', 'pipe'], // stdin は無視
-            detached: true, // 完全にデタッチ
+            stdio: ['ignore', 'pipe', 'pipe'], // ignore stdin
+            detached: true, // fully detached
         });
-        // デタッチされたプロセスのPIDは記録するが、プロセス管理からは除外
+        // Record detached process PID but exclude it from process management
         const executionInfo = this.executions.get(executionId);
         if (executionInfo && childProcess.pid !== undefined) {
             executionInfo.process_id = childProcess.pid;
             executionInfo.status = 'running';
             this.executions.set(executionId, executionInfo);
         }
-        // デタッチされたプロセスは親プロセスの終了後も継続実行されるため、
-        // 出力の収集は限定的
+        // Detached processes continue after parent exits,
+        // so output collection is limited
         const startTime = Date.now();
         let stdout = '';
         let stderr = '';
@@ -998,7 +1111,7 @@ export class ProcessManager {
                 stderr += data.toString();
             });
         }
-        // プロセスの終了を監視（デタッチされているため必ずしも捕捉されない）
+        // Monitor process exit (not always capturable when detached)
         childProcess.on('close', async (code) => {
             const executionInfo = this.executions.get(executionId);
             if (executionInfo) {
@@ -1011,12 +1124,12 @@ export class ProcessManager {
                     executionInfo.output_id = outputFileId;
                 }
                 catch (error) {
-                    // ファイル保存失敗は重要なエラーとしてログに記録し、実行情報に含める
+                    // Record file-save failures as critical errors and include them in execution info
                     console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
                     executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
                 }
                 this.executions.set(executionId, executionInfo);
-                // detachedプロセス正常終了のコールバック呼び出し
+                // Invoke completion callback for detached process
                 if (this.backgroundProcessCallbacks.onComplete) {
                     setImmediate(async () => {
                         try {
@@ -1029,7 +1142,7 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Detached process completion callback error:', callbackError);
                         }
                     });
@@ -1043,7 +1156,7 @@ export class ProcessManager {
                 executionInfo.execution_time_ms = Date.now() - startTime;
                 executionInfo.completed_at = getCurrentTimestamp();
                 this.executions.set(executionId, executionInfo);
-                // detachedプロセスエラーのコールバック呼び出し
+                // Invoke error callback for detached process
                 if (this.backgroundProcessCallbacks.onError) {
                     setImmediate(async () => {
                         try {
@@ -1056,14 +1169,14 @@ export class ProcessManager {
                             }
                         }
                         catch (callbackError) {
-                            // コールバックエラーは内部ログに記録のみ
+                            // Record callback errors in internal logs only
                             // console.error('Detached process error callback error:', callbackError);
                         }
                     });
                 }
             }
         });
-        // プロセスをデタッチ
+        // Detach process
         childProcess.unref();
         const resultExecutionInfo = this.executions.get(executionId);
         if (!resultExecutionInfo) {
@@ -1073,7 +1186,7 @@ export class ProcessManager {
     }
     async saveOutputToFile(executionId, stdout, stderr) {
         if (!this.fileManager) {
-            // FileManagerが利用できない場合は、従来の方法でファイルを保存
+            // If FileManager is unavailable, save file using legacy method
             const outputFileId = generateId();
             const filePath = path.join(this.outputDir, `${outputFileId}.json`);
             const outputData = {
@@ -1085,27 +1198,27 @@ export class ProcessManager {
             await fs.writeFile(filePath, JSON.stringify(outputData, null, 2), 'utf-8');
             return outputFileId;
         }
-        // FileManagerを使用して出力ファイルを作成
+        // Create output file using FileManager
         const combinedOutput = stdout + (stderr ? '\n--- STDERR ---\n' + stderr : '');
         return await this.fileManager.createOutputFile(combinedOutput, executionId);
     }
     /**
-     * 出力状態の詳細情報を設定するヘルパー関数
+    * Helper to set detailed output status information
      * Issue #14: Enhanced guidance messages for adaptive mode transitions
-     * 改善: outputTruncated の代わりに reason ベースで状態を判定
+    * Improvement: determine status by reason instead of outputTruncated
      */
-    setOutputStatus(executionInfo, actuallyTruncated, // 実際に出力が切り捨てられたか
+    setOutputStatus(executionInfo, actuallyTruncated, // whether output was actually truncated
     reason, outputId) {
-        // reasonに基づいて出力状態を設定
-        const needsGuidance = !!outputId; // output_idがあれば常にガイダンスを提供
-        // 後方互換性のため outputTruncated を設定
+        // Set output status based on reason
+        const needsGuidance = !!outputId; // always provide guidance when output_id exists
+        // Set outputTruncated for backward compatibility
         executionInfo.output_truncated =
             actuallyTruncated || reason === 'timeout' || reason === 'background_transition';
-        // Issue #14: バックグラウンド移行とタイムアウトは特別扱い
+        // Issue #14: Handle background transitions and timeouts specially
         if (reason === 'background_transition') {
             executionInfo.truncation_reason = reason;
             executionInfo.output_status = {
-                complete: false, // バックグラウンド実行中は未完了
+                complete: false, // incomplete while running in background
                 reason: reason,
                 available_via_output_id: !!outputId,
                 recommended_action: outputId ? 'use_read_execution_output' : undefined,
@@ -1136,7 +1249,7 @@ export class ProcessManager {
         if (reason === 'timeout') {
             executionInfo.truncation_reason = reason;
             executionInfo.output_status = {
-                complete: false, // タイムアウトは未完了
+                complete: false, // timeout means incomplete
                 reason: reason,
                 available_via_output_id: !!outputId,
                 recommended_action: outputId ? 'use_read_execution_output' : undefined,
@@ -1158,7 +1271,7 @@ export class ProcessManager {
             }
             return;
         }
-        // 実際に出力が切り捨てられた場合
+        // When output was actually truncated
         if (actuallyTruncated) {
             executionInfo.truncation_reason = reason;
             executionInfo.output_status = {
@@ -1167,7 +1280,7 @@ export class ProcessManager {
                 available_via_output_id: !!outputId,
                 recommended_action: outputId ? 'use_read_execution_output' : undefined,
             };
-            // 状況に応じたメッセージとアクションの設定
+            // Set message and actions based on situation
             switch (reason) {
                 case 'size_limit':
                     executionInfo.message = `Output exceeded size limit. ${outputId ? 'Complete output available via output_id.' : 'Output was truncated.'}`;
@@ -1205,7 +1318,7 @@ export class ProcessManager {
             }
         }
         else {
-            // 完了した場合（切り捨てなし）
+            // Completed case (no truncation)
             executionInfo.output_status = {
                 complete: true,
                 available_via_output_id: !!outputId,
@@ -1228,7 +1341,7 @@ export class ProcessManager {
     }
     listExecutions(filter) {
         let executions = Array.from(this.executions.values());
-        // フィルタリング
+        // Filtering
         if (filter) {
             if (filter.status) {
                 executions = executions.filter((exec) => exec.status === filter.status);
@@ -1238,11 +1351,11 @@ export class ProcessManager {
                 executions = executions.filter((exec) => pattern.test(exec.command));
             }
             if (filter.sessionId) {
-                // セッション管理は今後実装
+                // Session management will be implemented later
             }
         }
         const total = executions.length;
-        // ページネーション
+        // Pagination
         if (filter?.offset || filter?.limit) {
             const offset = filter.offset || 0;
             const limit = filter.limit || 50;
@@ -1256,17 +1369,17 @@ export class ProcessManager {
             throw new ResourceNotFoundError('process', processId.toString());
         }
         try {
-            // プロセスを終了
+            // Terminate process
             const signalName = signal === 'KILL' ? 'SIGKILL' : `SIG${signal}`;
             const killed = childProcess.kill(signalName);
             if (!killed && force && signal !== 'KILL') {
-                // 強制終了
+                // Force kill
                 childProcess.kill('SIGKILL');
             }
-            // プロセスが終了するまで待機
+            // Wait until process exits
             await new Promise((resolve) => {
                 childProcess.on('close', () => resolve());
-                setTimeout(() => resolve(), 5000); // 5秒でタイムアウト
+                setTimeout(() => resolve(), 5000); // timeout after 5 seconds
             });
             this.processes.delete(processId);
             return {
@@ -1287,7 +1400,7 @@ export class ProcessManager {
     listProcesses() {
         const processes = [];
         for (const [pid] of this.processes) {
-            // 対応する実行情報を検索
+            // Find corresponding execution info
             const execution = Array.from(this.executions.values()).find((exec) => exec.process_id === pid);
             if (execution) {
                 const processInfo = {
@@ -1315,7 +1428,7 @@ export class ProcessManager {
         return processes;
     }
     cleanup() {
-        // 実行中のプロセスを全て終了
+        // Terminate all running processes
         for (const [, childProcess] of this.processes) {
             try {
                 childProcess.kill('SIGTERM');
@@ -1326,17 +1439,17 @@ export class ProcessManager {
                 }, 5000);
             }
             catch (error) {
-                // エラーログを内部ログに記録（標準出力を避ける）
+                // Record error in internal log (avoid stdout)
                 // console.error(`Failed to cleanup process ${pid}:`, error);
             }
         }
         this.processes.clear();
         this.executions.clear();
     }
-    // ワーキングディレクトリ管理
+    // Working directory management
     setDefaultWorkingDirectory(workingDirectory) {
         const previousWorkdir = this.defaultWorkingDirectory;
-        // ディレクトリの検証
+        // Validate directory
         if (!this.isAllowedWorkingDirectory(workingDirectory)) {
             throw new Error(`Working directory not allowed: ${workingDirectory}`);
         }
@@ -1355,7 +1468,7 @@ export class ProcessManager {
         return [...this.allowedWorkingDirectories];
     }
     isAllowedWorkingDirectory(workingDirectory) {
-        // パスの正規化を行って比較
+        // Compare using normalized paths
         const normalizedPath = path.resolve(workingDirectory);
         return this.allowedWorkingDirectories.some((allowedDir) => {
             const normalizedAllowed = path.resolve(allowedDir);