pm-orchestrator-runner 1.0.6 → 1.0.8

package/dist/repl/repl-interface.js

@@ -13,7 +13,8 @@
  * - Deterministic Exit Code: 0=COMPLETE, 1=ERROR, 2=INCOMPLETE
  *
  * Project Mode (per spec 10_REPL_UX.md, Property 32, 33):
- * - temp: Use temporary directory (default, cleaned up on exit)
+ * - cwd: Use current working directory (DEFAULT per spec)
+ * - temp: Use temporary directory (cleaned up on exit)
  * - fixed: Use specified directory (persists after exit)
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -66,7 +67,9 @@ const provider_1 = require("./commands/provider");
 const models_1 = require("./commands/models");
 const keys_1 = require("./commands/keys");
 const logs_1 = require("./commands/logs");
+const two_pane_renderer_1 = require("./two-pane-renderer");
 const global_config_1 = require("../config/global-config");
+const claude_code_executor_1 = require("../executor/claude-code-executor");
 /**
  * Exit codes for non-interactive mode - per spec 10_REPL_UX.md
  * These are deterministic based on session state
@@ -117,6 +120,9 @@ class REPLInterface extends events_1.EventEmitter {
     hasIncompleteTasks = false;
     // Session completion tracking (prevents double completion)
     sessionCompleted = false;
+    // Non-blocking task queue (allows input while tasks are running)
+    taskQueue = [];
+    isTaskWorkerRunning = false;
     // Project mode support (per spec 10_REPL_UX.md, Property 32, 33)
     projectMode;
     verificationRoot;
@@ -131,6 +137,8 @@ class REPLInterface extends events_1.EventEmitter {
     modelsCommand;
     keysCommand;
     logsCommand;
+    // Two-pane renderer per spec 18_CLI_TWO_PANE.md
+    renderer;
     constructor(config = {}) {
         super();
         // Validate fixed mode configuration (Property 32)
@@ -142,12 +150,18 @@ class REPLInterface extends events_1.EventEmitter {
                 throw new Error('project-root does not exist: ' + config.projectRoot);
             }
         }
-        // Determine project mode
-        this.projectMode = config.projectMode || 'temp';
+        // Determine project mode - per spec 10_REPL_UX.md: cwd is default
+        this.projectMode = config.projectMode || 'cwd';
         // Set verification root based on mode
         if (this.projectMode === 'fixed') {
             this.verificationRoot = config.projectRoot;
         }
+        else if (this.projectMode === 'cwd') {
+            // CWD mode: use current working directory (DEFAULT per spec 10_REPL_UX.md)
+            // Per spec lines 74-83: カレントディレクトリをそのまま使用
+            // But respect explicitly provided projectPath from --project flag
+            this.verificationRoot = config.projectPath || process.cwd();
+        }
         else {
             // Temp mode: create temporary directory immediately (synchronous)
             // This ensures getVerificationRoot() always returns a valid path
@@ -165,12 +179,15 @@ class REPLInterface extends events_1.EventEmitter {
             }, null, 2);
             fs.writeFileSync(path.join(claudeDir, 'settings.json'), settingsContent, 'utf-8');
         }
-        // CRITICAL: In temp mode, use verificationRoot for projectPath and evidenceDir
-        // This ensures files are created in the temp directory, not process.cwd()
-        // In fixed mode, use projectRoot (from --project-root) if provided
+        // CRITICAL: Resolve projectPath based on mode
+        // - cwd mode: use process.cwd() (already set in verificationRoot)
+        // - temp mode: use verificationRoot (temp directory)
+        // - fixed mode: use projectRoot (from --project-root)
         const resolvedProjectPath = this.projectMode === 'temp'
             ? this.verificationRoot
-            : (config.projectRoot || config.projectPath || process.cwd());
+            : this.projectMode === 'cwd'
+                ? this.verificationRoot // verificationRoot is process.cwd() in cwd mode
+                : (config.projectRoot || config.projectPath || process.cwd());
         this.config = {
             projectPath: resolvedProjectPath,
             evidenceDir: config.evidenceDir || path.join(resolvedProjectPath, '.claude', 'evidence'),
@@ -206,6 +223,10 @@ class REPLInterface extends events_1.EventEmitter {
         this.modelsCommand = new models_1.ModelsCommand();
         this.keysCommand = new keys_1.KeysCommand();
         this.logsCommand = new logs_1.LogsCommand();
+        // Initialize two-pane renderer per spec 18_CLI_TWO_PANE.md
+        this.renderer = new two_pane_renderer_1.TwoPaneRenderer({
+            prompt: this.config.prompt,
+        });
     }
     /**
      * Get project mode - per spec 10_REPL_UX.md
@@ -314,6 +335,19 @@ class REPLInterface extends events_1.EventEmitter {
         // The OS will clean it up eventually, and leaving it allows for debugging
         // In fixed mode, the directory persists as expected
     }
+    /**
+     * Check Claude Code CLI auth status
+     * Per spec/15_API_KEY_ENV_SANITIZE.md: Check at startup, exit on failure
+     *
+     * @returns AuthCheckResult with availability and login status
+     */
+    async checkClaudeCodeAuth() {
+        const executor = new claude_code_executor_1.ClaudeCodeExecutor({
+            projectPath: this.session.projectPath,
+            timeout: 30000,
+        });
+        return executor.checkAuthStatus();
+    }
     /**
      * Check API key status and show warning if not configured
      * API keys are stored in global config file (~/.pm-orchestrator-runner/config.json)
@@ -367,6 +401,29 @@ class REPLInterface extends events_1.EventEmitter {
     async start() {
         // Initialize project root
         await this.initialize();
+        // Per spec/15_API_KEY_ENV_SANITIZE.md lines 91-97: Startup checks
+        // Check Claude Code CLI availability and login status
+        if (this.config.authMode === 'claude-code') {
+            const authStatus = await this.checkClaudeCodeAuth();
+            if (!authStatus.available) {
+                console.error('');
+                console.error('ERROR: Claude Code CLI not available');
+                console.error('  ' + (authStatus.error || 'CLI not found'));
+                console.error('');
+                console.error('Please install Claude Code CLI and try again.');
+                console.error('');
+                process.exit(1);
+            }
+            if (!authStatus.loggedIn) {
+                console.error('');
+                console.error('ERROR: Claude Code CLI not logged in');
+                console.error('  ' + (authStatus.error || 'Login required'));
+                console.error('');
+                console.error('Please run: claude setup-token');
+                console.error('');
+                process.exit(1);
+            }
+        }
         // Check API keys for api-key mode
         if (this.config.authMode === 'api-key') {
             await this.checkApiKeyStatus();
@@ -423,6 +480,8 @@ class REPLInterface extends events_1.EventEmitter {
                 }
                 this.running = false;
                 // Ensure all output is flushed before cleanup
+                // Per spec 18_CLI_TWO_PANE.md: Flush renderer pending logs
+                this.renderer.flush();
                 await this.flushStdout();
                 await this.cleanup();
                 // In non-interactive mode, set process exit code
@@ -455,6 +514,8 @@ class REPLInterface extends events_1.EventEmitter {
      * - This allows long messages with newlines to be sent together
      */
     enqueueInput(line) {
+        // Per spec 18_CLI_TWO_PANE.md: Clear input state after line is committed
+        this.renderer.clearInput();
         const trimmed = line.trim();
         if (!trimmed) {
             // Empty line - submit accumulated multi-line buffer
@@ -526,6 +587,7 @@ class REPLInterface extends events_1.EventEmitter {
                 // In non-interactive mode, flush output after each command
                 // This ensures output is visible before processing next command
                 if (this.executionMode === 'non_interactive') {
+                    this.renderer.flush();
                     await this.flushStdout();
                 }
                 // Show prompt after each input if still running (interactive mode only)
@@ -626,10 +688,15 @@ class REPLInterface extends events_1.EventEmitter {
         return trimmed === 'exit';
     }
     /**
-     * Process natural language input
+     * Process natural language input - NON-BLOCKING
      * Per spec 10_REPL_UX.md L117-118: Model selection is REPL-local
      * Model is read from .claude/repl.json and passed to executor via runner
      *
+     * Non-blocking design:
+     * - Creates task and adds to queue immediately
+     * - Returns control to input prompt right away
+     * - Background worker processes tasks asynchronously
+     *
      * Auto-start: In non-interactive mode, automatically start a session if none exists
      * This improves CLI usability for piped input and scripting
      *
@@ -647,18 +714,15 @@ class REPLInterface extends events_1.EventEmitter {
             this.print('HINT: /exit');
             return;
         }
+        // Auto-start session for any natural language input (no /start required)
+        // Per redesign: natural language input = automatic task creation
         if (this.session.status !== 'running') {
-            // In non-interactive mode, auto-start a session for better UX
-            if (this.executionMode === 'non_interactive') {
-                console.log('[DEBUG processNaturalLanguage] auto-starting session for non-interactive mode');
-                const startResult = await this.handleStart([]);
-                if (!startResult.success) {
-                    this.print('Failed to auto-start session: ' + (startResult.error?.message || 'Unknown error'));
-                    return;
-                }
-            }
-            else {
-                this.print('No active session. Use /start to begin, or /init to set up a new project.');
+            console.log('[DEBUG processNaturalLanguage] auto-starting session');
+            this.print('');
+            this.print('[Auto-starting session...]');
+            const startResult = await this.handleStart([]);
+            if (!startResult.success) {
+                this.print('Failed to auto-start session: ' + (startResult.error?.message || 'Unknown error'));
                 return;
             }
         }
@@ -666,54 +730,150 @@ class REPLInterface extends events_1.EventEmitter {
             this.print('Runner not initialized. Use /start first.');
             return;
         }
-        // Generate task ID and set current_task_id
+        // Generate task ID
         // Per spec 05_DATA_MODELS.md Property 38
         const taskId = 'task-' + Date.now();
-        this.session.current_task_id = taskId;
-        this.print('Processing task: ' + input);
+        // Create queued task
+        const queuedTask = {
+            id: taskId,
+            description: input,
+            state: 'QUEUED',
+            queuedAt: Date.now(),
+            startedAt: null,
+            completedAt: null,
+        };
+        // Add to task queue
+        this.taskQueue.push(queuedTask);
+        // Display task queued info (per redesign: visibility)
+        // Per user requirement: Provider/Mode/Auth must be shown at task start
+        this.print('');
+        this.print('--- Task Queued ---');
         this.print('Task ID: ' + taskId);
+        this.print('State: QUEUED');
+        // Show LLM layer info (Provider/Mode/Auth) - per redesign requirement
+        if (this.config.authMode === 'claude-code') {
+            this.print('Provider: Claude Code CLI (uses your Claude subscription, no API key required)');
+        }
+        else if (this.config.authMode === 'api-key') {
+            this.print('Provider: Anthropic API (API key configured)');
+        }
+        else {
+            this.print('Provider: ' + this.config.authMode);
+        }
+        // Show prompt summary (first 100 chars)
+        const promptSummary = input.length > 100 ? input.substring(0, 100) + '...' : input;
+        this.print('Prompt: ' + promptSummary);
+        this.print('-------------------');
+        this.print('');
+        this.print('(Input is not blocked - you can submit more tasks with /tasks to view status)');
         this.print('');
+        // Start background worker if not running
+        // The worker runs asynchronously - we don't await it
+        if (!this.isTaskWorkerRunning) {
+            this.startTaskWorker();
+        }
+        console.log(`[DEBUG processNaturalLanguage] task queued, returning immediately`);
+    }
+    /**
+     * Background task worker - processes queued tasks asynchronously
+     * Runs in background, allowing input to continue while tasks execute
+     */
+    async startTaskWorker() {
+        if (this.isTaskWorkerRunning) {
+            return;
+        }
+        this.isTaskWorkerRunning = true;
+        console.log('[DEBUG startTaskWorker] worker started');
+        try {
+            while (this.running) {
+                // Find next QUEUED task
+                const nextTask = this.taskQueue.find(t => t.state === 'QUEUED');
+                if (!nextTask) {
+                    // No more queued tasks - worker exits
+                    break;
+                }
+                // Execute the task
+                await this.executeQueuedTask(nextTask);
+            }
+        }
+        finally {
+            this.isTaskWorkerRunning = false;
+            console.log('[DEBUG startTaskWorker] worker stopped');
+        }
+    }
+    /**
+     * Execute a single queued task
+     * Updates task state and prints results
+     */
+    async executeQueuedTask(task) {
+        console.log(`[DEBUG executeQueuedTask] starting task ${task.id}`);
+        // Update state to RUNNING
+        task.state = 'RUNNING';
+        task.startedAt = Date.now();
+        this.session.current_task_id = task.id;
+        // Print status update
+        this.print('');
+        this.print('--- Task Started ---');
+        this.print('Task ID: ' + task.id);
+        this.print('State: RUNNING');
+        this.print('--------------------');
         try {
             // Per spec 10_REPL_UX.md L117-118: Get selected model from REPL config
-            // Model is REPL-local, stored in .claude/repl.json
             let selectedModel;
             const modelResult = await this.modelCommand.getModel(this.session.projectPath);
             if (modelResult.success && modelResult.model && modelResult.model !== 'UNSET') {
                 selectedModel = modelResult.model;
             }
-            console.log(`[DEBUG processNaturalLanguage] calling runner.execute...`);
-            // Create task from natural language input
-            // CRITICAL: naturalLanguageTask must be set to trigger Claude Code execution
-            // Without this, the task would only use fallback file creation patterns
+            console.log(`[DEBUG executeQueuedTask] calling runner.execute...`);
             const result = await this.session.runner.execute({
                 tasks: [{
-                        id: taskId,
-                        description: input,
-                        naturalLanguageTask: input,
+                        id: task.id,
+                        description: task.description,
+                        naturalLanguageTask: task.description,
                     }],
                 selectedModel,
             });
-            console.log(`[DEBUG processNaturalLanguage] runner.execute returned, status=${result.overall_status}`);
-            // Handle INCOMPLETE with clarification interactively
+            console.log(`[DEBUG executeQueuedTask] runner.execute returned, status=${result.overall_status}`);
+            // Update task state based on result
+            task.completedAt = Date.now();
+            task.resultStatus = result.overall_status;
+            task.filesModified = result.files_modified;
+            task.responseSummary = result.executor_output_summary;
+            switch (result.overall_status) {
+                case enums_1.OverallStatus.COMPLETE:
+                    task.state = 'COMPLETE';
+                    break;
+                case enums_1.OverallStatus.INCOMPLETE:
+                    task.state = 'INCOMPLETE';
+                    break;
+                case enums_1.OverallStatus.ERROR:
+                    task.state = 'ERROR';
+                    task.errorMessage = result.error?.message;
+                    break;
+                default:
+                    task.state = 'COMPLETE';
+            }
+            // Handle INCOMPLETE with clarification (but don't block)
             if (result.overall_status === enums_1.OverallStatus.INCOMPLETE &&
                 result.incomplete_task_reasons &&
                 result.incomplete_task_reasons.length > 0) {
-                const clarificationNeeded = await this.handleClarificationNeeded(input, result.incomplete_task_reasons);
-                if (clarificationNeeded) {
-                    // User provided clarification, will be processed in next input
-                    return;
-                }
+                await this.handleClarificationNeeded(task.description, result.incomplete_task_reasons);
             }
             this.printExecutionResult(result);
         }
         catch (err) {
-            console.log(`[DEBUG processNaturalLanguage] error: ${err.message}`);
-            // Clear current_task_id on exception (fail-closed)
+            console.log(`[DEBUG executeQueuedTask] error: ${err.message}`);
+            task.state = 'ERROR';
+            task.completedAt = Date.now();
+            task.errorMessage = err.message;
+            this.printError(err);
+        }
+        finally {
+            // Clear current_task_id
             this.session.last_task_id = this.session.current_task_id;
             this.session.current_task_id = null;
-            this.printError(err);
         }
-        console.log(`[DEBUG processNaturalLanguage] done`);
+        console.log(`[DEBUG executeQueuedTask] task ${task.id} done, state=${task.state}`);
     }
     /**
      * Handle clarification needed - prompt user interactively
@@ -764,6 +924,7 @@ class REPLInterface extends events_1.EventEmitter {
     }
     /**
      * Print welcome message with clear auth status
+     * Per spec/15_API_KEY_ENV_SANITIZE.md: Show required startup display
      */
     printWelcome() {
         this.print('');
@@ -775,18 +936,18 @@ class REPLInterface extends events_1.EventEmitter {
             this.print('Verification Root: ' + this.verificationRoot);
         }
         this.print('');
-        // Clear auth status display
-        this.print('Authentication Status:');
+        // Per spec/15_API_KEY_ENV_SANITIZE.md lines 100-108: Required startup display
         if (this.config.authMode === 'claude-code') {
-            this.print('  Provider: Claude Code CLI');
-            this.print('  API Key: Not required (uses your Claude subscription)');
-            this.print('  Status: Ready');
+            // Spec-mandated display format - MUST be shown exactly as specified
+            this.print('Executor: Claude Code CLI');
+            this.print('Auth: Uses Claude subscription (no API key required)');
+            this.print('Env: ALLOWLIST mode (only PATH, HOME, etc. passed to subprocess)');
         }
         else {
             // Check for API keys when using API mode
             const anthropicKey = process.env.ANTHROPIC_API_KEY;
             const openaiKey = process.env.OPENAI_API_KEY;
-            this.print('  Provider: API Mode');
+            this.print('Executor: API Mode');
             this.print('  ANTHROPIC_API_KEY: ' + (anthropicKey ? 'SET' : 'NOT SET'));
             this.print('  OPENAI_API_KEY: ' + (openaiKey ? 'SET' : 'NOT SET'));
             if (!anthropicKey && !openaiKey) {
@@ -1063,7 +1224,8 @@ class REPLInterface extends events_1.EventEmitter {
             // /logs <task-id> [--full]
             const taskId = args[0];
             const full = args.includes('--full');
-            const result = await this.logsCommand.getTaskDetail(this.session.projectPath, taskId, full);
+            // Per redesign: Pass sessionId for visibility fields
+            const result = await this.logsCommand.getTaskDetail(this.session.projectPath, taskId, full, this.session.sessionId ?? undefined);
             if (result.success) {
                 this.print(result.output || 'No log detail found.');
                 return { success: true };
@@ -1076,10 +1238,78 @@ class REPLInterface extends events_1.EventEmitter {
     }
     /**
      * Handle /tasks command
+     * Shows task queue with RUNNING/QUEUED/COMPLETE/ERROR/INCOMPLETE states
+     * Per redesign: proves non-blocking by showing multiple tasks simultaneously
      */
     async handleTasks() {
-        const result = await this.statusCommands.getTasks();
-        this.print(result);
+        this.print('');
+        this.print('=== Task Queue ===');
+        this.print('');
+        if (this.taskQueue.length === 0) {
+            this.print('No tasks in queue.');
+            this.print('');
+            // Also show legacy tasks from statusCommands if available
+            const legacyResult = await this.statusCommands.getTasks();
+            if (legacyResult && legacyResult.trim()) {
+                this.print('--- Session Tasks ---');
+                this.print(legacyResult);
+            }
+            return;
+        }
+        // Count by state
+        const running = this.taskQueue.filter(t => t.state === 'RUNNING').length;
+        const queued = this.taskQueue.filter(t => t.state === 'QUEUED').length;
+        const complete = this.taskQueue.filter(t => t.state === 'COMPLETE').length;
+        const incomplete = this.taskQueue.filter(t => t.state === 'INCOMPLETE').length;
+        const error = this.taskQueue.filter(t => t.state === 'ERROR').length;
+        this.print('Summary: ' + running + ' RUNNING, ' + queued + ' QUEUED, ' + complete + ' COMPLETE, ' + incomplete + ' INCOMPLETE, ' + error + ' ERROR');
+        this.print('');
+        // List all tasks with state
+        for (const task of this.taskQueue) {
+            const promptSummary = task.description.length > 50
+                ? task.description.substring(0, 50) + '...'
+                : task.description;
+            let durationStr = '';
+            if (task.startedAt) {
+                const endTime = task.completedAt || Date.now();
+                const durationMs = endTime - task.startedAt;
+                durationStr = ' (' + (durationMs / 1000).toFixed(1) + 's)';
+            }
+            // State indicator with visual marker
+            let stateMarker = '';
+            switch (task.state) {
+                case 'RUNNING':
+                    stateMarker = '[*]';
+                    break;
+                case 'QUEUED':
+                    stateMarker = '[ ]';
+                    break;
+                case 'COMPLETE':
+                    stateMarker = '[v]';
+                    break;
+                case 'INCOMPLETE':
+                    stateMarker = '[!]';
+                    break;
+                case 'ERROR':
+                    stateMarker = '[X]';
+                    break;
+            }
+            this.print(stateMarker + ' ' + task.id + ' | ' + task.state + durationStr);
+            this.print('    ' + promptSummary);
+            // Show error message if error
+            if (task.state === 'ERROR' && task.errorMessage) {
+                this.print('    Error: ' + task.errorMessage);
+            }
+            // Show files modified if complete
+            if (task.state === 'COMPLETE' && task.filesModified && task.filesModified.length > 0) {
+                this.print('    Files: ' + task.filesModified.slice(0, 3).join(', ') +
+                    (task.filesModified.length > 3 ? ' (+' + (task.filesModified.length - 3) + ' more)' : ''));
+            }
+        }
+        this.print('');
+        this.print('Use /logs <task-id> for details.');
+        this.print('==================');
+        this.print('');
     }
     /**
      * Handle /status command
@@ -1090,13 +1320,18 @@ class REPLInterface extends events_1.EventEmitter {
     }
     /**
      * Handle /start command
-     * Per spec Property 32, 33: Use verification_root for file operations in temp mode
+     * Per spec Property 32, 33: Use verification_root for file operations
+     * - cwd mode: use process.cwd() (verificationRoot)
+     * - temp mode: use temp directory (verificationRoot)
+     * - fixed mode: use projectRoot
      */
     async handleStart(args) {
-        // In temp mode, use verificationRoot for file operations
+        // In cwd/temp mode, use verificationRoot for file operations
         // In fixed mode or with explicit args, use the provided/session path
         const projectPath = args[0] ||
-            (this.projectMode === 'temp' ? this.verificationRoot : this.session.projectPath);
+            (this.projectMode === 'cwd' || this.projectMode === 'temp'
+                ? this.verificationRoot
+                : this.session.projectPath);
         try {
             const result = await this.sessionCommands.start(projectPath);
             if (result.success) {
@@ -1210,6 +1445,7 @@ class REPLInterface extends events_1.EventEmitter {
      * Per spec 10_REPL_UX.md: Ensure clean exit with flushed output
      *
      * Guarantees:
+     * - Waits for running tasks to complete (task worker)
      * - Session state is persisted before exit
      * - All output is flushed before readline closes
      * - Double-completion is prevented via sessionCompleted flag
@@ -1223,6 +1459,18 @@ class REPLInterface extends events_1.EventEmitter {
             return;
         }
         this.sessionCompleted = true;
+        // Wait for task worker to complete any running tasks
+        if (this.isTaskWorkerRunning) {
+            const runningTasks = this.taskQueue.filter(t => t.state === 'RUNNING');
+            const queuedTasks = this.taskQueue.filter(t => t.state === 'QUEUED');
+            if (runningTasks.length > 0 || queuedTasks.length > 0) {
+                this.print('Waiting for ' + runningTasks.length + ' running and ' + queuedTasks.length + ' queued tasks to complete...');
+            }
+            while (this.isTaskWorkerRunning) {
+                await new Promise(r => setTimeout(r, 100));
+            }
+            this.print('All tasks completed.');
+        }
         this.print('Saving session state...');
         if (this.session.runner && this.session.sessionId) {
             try {
@@ -1246,6 +1494,7 @@ class REPLInterface extends events_1.EventEmitter {
         }
         this.print('Goodbye!');
         // Flush output before closing (critical for non-interactive mode)
+        this.renderer.flush();
         await this.flushStdout();
         this.running = false;
         this.rl?.close();
@@ -1337,6 +1586,15 @@ class REPLInterface extends events_1.EventEmitter {
         this.print('');
         this.print('--- Execution Result ---');
         this.print('Status: ' + result.overall_status);
+        // Display executor mode (per redesign: visibility)
+        if (result.executor_mode) {
+            this.print('Executor: ' + result.executor_mode);
+        }
+        // Display duration (per redesign: visibility)
+        if (result.duration_ms !== undefined && result.duration_ms > 0) {
+            const seconds = (result.duration_ms / 1000).toFixed(1);
+            this.print('Duration: ' + seconds + 's');
+        }
         if (result.tasks_completed !== undefined) {
             this.print('Tasks: ' + result.tasks_completed + '/' + result.tasks_total + ' completed');
             // Track incomplete tasks for exit code (non-interactive mode)
@@ -1345,8 +1603,23 @@ class REPLInterface extends events_1.EventEmitter {
                 this.updateExitCode();
             }
         }
+        // Display files modified (per redesign: visibility)
+        if (result.files_modified && result.files_modified.length > 0) {
+            this.print('');
+            this.print('Files Modified:');
+            for (const file of result.files_modified) {
+                this.print('  - ' + file);
+            }
+        }
+        // Display executor output summary (per redesign: visibility)
+        if (result.executor_output_summary) {
+            this.print('');
+            this.print('Response Summary:');
+            this.print('  ' + result.executor_output_summary);
+        }
         // Display error details when status is ERROR (critical for debugging fail-closed behavior)
         if (result.error) {
+            this.print('');
             this.print('Error: ' + result.error.message);
             if (result.error.code) {
                 this.print('Error Code: ' + result.error.code);
@@ -1357,6 +1630,7 @@ class REPLInterface extends events_1.EventEmitter {
         }
         // Display incomplete task reasons (helps identify why tasks failed)
         if (result.incomplete_task_reasons && result.incomplete_task_reasons.length > 0) {
+            this.print('');
             this.print('Incomplete Tasks:');
             for (const reason of result.incomplete_task_reasons) {
                 this.print('  - ' + reason.task_id + ': ' + reason.reason);
@@ -1374,6 +1648,16 @@ class REPLInterface extends events_1.EventEmitter {
             this.hasIncompleteTasks = true;
             this.updateExitCode();
         }
+        // NO_EVIDENCE handling: show next action hint (per redesign requirement)
+        // Per user requirement: NO_EVIDENCE should not complete silently
+        if (result.overall_status === enums_1.OverallStatus.NO_EVIDENCE) {
+            this.print('');
+            this.print('HINT: No file changes were verified for this task.');
+            this.print('  Possible next actions:');
+            this.print('    - Check /logs for execution details');
+            this.print('    - Retry with more specific instructions');
+            this.print('    - Use /status to see current session state');
+        }
         if (result.next_action !== undefined) {
             this.print('Next Action: ' + (result.next_action ? 'Yes' : 'No'));
             if (result.next_action_reason) {
@@ -1386,9 +1670,21 @@ class REPLInterface extends events_1.EventEmitter {
     /**
      * Print message with flush guarantee for non-interactive mode
      * Per spec 10_REPL_UX.md: Output Flush Guarantee
+     * Per spec 18_CLI_TWO_PANE.md: Use TwoPaneRenderer for TTY output
+     *
+     * Syncs readline input state to renderer before output,
+     * ensuring input line is preserved during log output.
      */
     print(message) {
-        console.log(message);
+        // Sync input state from readline to renderer
+        // Per spec 18_CLI_TWO_PANE.md: Input line must never be disrupted
+        if (this.rl && this.renderer.isEnabled()) {
+            const rlAny = this.rl;
+            const line = rlAny.line || '';
+            const cursor = rlAny.cursor ?? line.length;
+            this.renderer.updateInput(line, cursor);
+        }
+        this.renderer.writeLog(message);
     }
     /**
      * Flush stdout - ensures all output is written before continuing