pm-orchestrator-runner 1.0.0

package/dist/repl/repl-interface.js

@@ -0,0 +1,1214 @@
+"use strict";
+/**
+ * REPL Interface for PM Orchestrator Runner
+ * Provides an interactive CLI experience with slash commands
+ *
+ * Supports two execution modes (per spec 10_REPL_UX.md):
+ * - Interactive mode: TTY connected, readline with prompt
+ * - Non-interactive mode: stdin script / heredoc / pipe
+ *
+ * Non-interactive mode guarantees:
+ * - Sequential Processing: Each command completes before next starts
+ * - Output Flush: All stdout is flushed before exit
+ * - 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)
+ * - fixed: Use specified directory (persists after exit)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPLInterface = exports.EXIT_CODES = void 0;
+const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const events_1 = require("events");
+const enums_1 = require("../models/enums");
+const executor_supervisor_1 = require("../supervisor/executor-supervisor");
+const init_1 = require("./commands/init");
+const model_1 = require("./commands/model");
+const session_1 = require("./commands/session");
+const status_1 = require("./commands/status");
+const provider_1 = require("./commands/provider");
+const models_1 = require("./commands/models");
+const keys_1 = require("./commands/keys");
+const logs_1 = require("./commands/logs");
+/**
+ * Exit codes for non-interactive mode - per spec 10_REPL_UX.md
+ * These are deterministic based on session state
+ */
+exports.EXIT_CODES = {
+    COMPLETE: 0, // All tasks completed successfully
+    ERROR: 1, // Error occurred during execution
+    INCOMPLETE: 2, // Session ended with incomplete tasks
+};
+/**
+ * Commands allowed in init-only mode
+ * When .claude is missing, only these commands are available
+ */
+const INIT_ONLY_ALLOWED_COMMANDS = ['help', 'init', 'exit'];
+/**
+ * All known commands (for unknown command detection)
+ * Updated per spec 10_REPL_UX.md to include new commands
+ */
+const KNOWN_COMMANDS = [
+    'help', 'init', 'model', 'start', 'continue',
+    'status', 'tasks', 'approve', 'exit',
+    // New commands per spec 10_REPL_UX.md
+    'provider', 'models', 'keys', 'logs'
+];
+/**
+ * Commands with slash prefix for tab completion
+ * Per spec 10_REPL_UX.md: Tab completion for slash commands
+ */
+const SLASH_COMMANDS = KNOWN_COMMANDS.map(cmd => '/' + cmd);
+/**
+ * REPL Interface class
+ */
+class REPLInterface extends events_1.EventEmitter {
+    config;
+    rl = null;
+    session;
+    running = false;
+    initOnlyMode = false;
+    // Sequential input processing (prevents race conditions with piped input)
+    inputQueue = [];
+    isProcessingInput = false;
+    // Non-interactive mode support (per spec 10_REPL_UX.md)
+    executionMode;
+    exitCode = exports.EXIT_CODES.COMPLETE;
+    hasError = false;
+    hasIncompleteTasks = false;
+    // Session completion tracking (prevents double completion)
+    sessionCompleted = false;
+    // Project mode support (per spec 10_REPL_UX.md, Property 32, 33)
+    projectMode;
+    verificationRoot;
+    tempVerificationRoot = null;
+    // Command handlers
+    initCommand;
+    modelCommand;
+    sessionCommands;
+    statusCommands;
+    // New command handlers per spec 10_REPL_UX.md
+    providerCommand;
+    modelsCommand;
+    keysCommand;
+    logsCommand;
+    constructor(config = {}) {
+        super();
+        // Validate fixed mode configuration (Property 32)
+        if (config.projectMode === 'fixed') {
+            if (!config.projectRoot) {
+                throw new Error('project-root is required when project-mode is fixed');
+            }
+            if (!fs.existsSync(config.projectRoot)) {
+                throw new Error('project-root does not exist: ' + config.projectRoot);
+            }
+        }
+        // Determine project mode
+        this.projectMode = config.projectMode || 'temp';
+        // Set verification root based on mode
+        if (this.projectMode === 'fixed') {
+            this.verificationRoot = config.projectRoot;
+        }
+        else {
+            // Temp mode: create temporary directory immediately (synchronous)
+            // This ensures getVerificationRoot() always returns a valid path
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-runner-'));
+            this.tempVerificationRoot = tempDir;
+            this.verificationRoot = tempDir;
+            // Create minimal .claude structure to avoid init-only mode
+            const claudeDir = path.join(tempDir, '.claude');
+            fs.mkdirSync(claudeDir, { recursive: true });
+            const claudeMdContent = '# Temporary Project\n\nCreated by pm-orchestrator-runner in temp mode.\n';
+            fs.writeFileSync(path.join(claudeDir, 'CLAUDE.md'), claudeMdContent, 'utf-8');
+            const settingsContent = JSON.stringify({
+                project: { name: 'temp-project', version: '1.0.0' },
+                pm: { autoStart: false },
+            }, 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
+        const resolvedProjectPath = this.projectMode === 'temp'
+            ? this.verificationRoot
+            : (config.projectRoot || config.projectPath || process.cwd());
+        this.config = {
+            projectPath: resolvedProjectPath,
+            evidenceDir: config.evidenceDir || path.join(resolvedProjectPath, '.claude', 'evidence'),
+            prompt: config.prompt || 'pm> ',
+            authMode: config.authMode || 'claude-code',
+            timeout: config.timeout || 120000,
+            forceNonInteractive: config.forceNonInteractive,
+            projectMode: config.projectMode,
+            projectRoot: config.projectRoot,
+            printProjectPath: config.printProjectPath,
+        };
+        // Detect execution mode (per spec 10_REPL_UX.md)
+        // Non-interactive when: stdin is not TTY, or forced via config/env
+        this.executionMode = this.detectExecutionMode();
+        this.session = {
+            sessionId: null,
+            projectPath: this.config.projectPath,
+            runner: null,
+            supervisor: null,
+            status: 'idle',
+        };
+        // Initialize command handlers
+        this.initCommand = new init_1.InitCommand();
+        this.modelCommand = new model_1.ModelCommand();
+        this.sessionCommands = new session_1.SessionCommands(this.session, this.config);
+        this.statusCommands = new status_1.StatusCommands(this.session);
+        // Initialize new command handlers
+        this.providerCommand = new provider_1.ProviderCommand();
+        this.modelsCommand = new models_1.ModelsCommand();
+        this.keysCommand = new keys_1.KeysCommand();
+        this.logsCommand = new logs_1.LogsCommand();
+    }
+    /**
+     * Get project mode - per spec 10_REPL_UX.md
+     * @returns Current project mode ('temp' or 'fixed')
+     */
+    getProjectMode() {
+        return this.projectMode;
+    }
+    /**
+     * Get verification root - per spec Property 32, 33
+     * @returns Absolute path to verification root directory
+     */
+    getVerificationRoot() {
+        return this.verificationRoot;
+    }
+    /**
+     * Initialize for use - called by start() or manually for testing
+     * Handles project path setup and PROJECT_PATH output
+     */
+    async initialize() {
+        // Initialize temp project root if in temp mode
+        if (this.projectMode === 'temp' && !this.verificationRoot) {
+            await this.initializeTempProjectRoot();
+        }
+        // Output PROJECT_PATH if requested (per spec 10_REPL_UX.md)
+        if (this.config.printProjectPath) {
+            console.log('PROJECT_PATH=' + this.verificationRoot);
+        }
+    }
+    /**
+     * Initialize temporary project root - per spec Property 32
+     * Creates a temporary directory for verification_root in temp mode
+     * Also creates minimal .claude structure to avoid init-only mode
+     */
+    async initializeTempProjectRoot() {
+        if (this.projectMode !== 'temp') {
+            return;
+        }
+        // Create temp directory
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-runner-'));
+        this.tempVerificationRoot = tempDir;
+        this.verificationRoot = tempDir;
+        // Create minimal .claude structure for temp mode
+        // This prevents init-only mode and allows /start to work immediately
+        const claudeDir = path.join(tempDir, '.claude');
+        fs.mkdirSync(claudeDir, { recursive: true });
+        // Create minimal CLAUDE.md
+        const claudeMdContent = '# Temporary Project\n\nCreated by pm-orchestrator-runner in temp mode.\n';
+        fs.writeFileSync(path.join(claudeDir, 'CLAUDE.md'), claudeMdContent, 'utf-8');
+        // Create minimal settings.json
+        const settingsContent = JSON.stringify({
+            project: { name: 'temp-project', version: '1.0.0' },
+            pm: { autoStart: false },
+        }, null, 2);
+        fs.writeFileSync(path.join(claudeDir, 'settings.json'), settingsContent, 'utf-8');
+        // Update config.projectPath to point to temp directory
+        // This ensures validateProjectStructure checks the right path
+        this.config.projectPath = tempDir;
+        this.session.projectPath = tempDir;
+    }
+    /**
+     * Verify files and return verification records - per spec Property 33
+     * @param absolutePaths - Array of absolute file paths to verify
+     * @returns Array of VerifiedFile records with relative paths
+     */
+    verifyFiles(absolutePaths) {
+        const now = new Date().toISOString();
+        return absolutePaths.map(absolutePath => {
+            // Convert to relative path from verification_root
+            const relativePath = path.relative(this.verificationRoot, absolutePath);
+            return {
+                path: relativePath,
+                exists: fs.existsSync(absolutePath),
+                detected_at: now,
+                detection_method: 'diff',
+            };
+        });
+    }
+    /**
+     * Create a TaskLog with verification info - per spec Property 33
+     * @param taskId - Task identifier
+     * @param description - Task description
+     * @returns TaskLog with verification_root populated
+     */
+    createTaskLog(taskId, description) {
+        return {
+            task_id: taskId,
+            description,
+            verification_root: this.verificationRoot,
+            created_at: new Date().toISOString(),
+        };
+    }
+    /**
+     * Cleanup resources - handles temp directory cleanup
+     * Per spec Property 32: temp mode directories may be cleaned up
+     */
+    async cleanup() {
+        if (this.session.supervisor) {
+            this.session.supervisor.stop();
+        }
+        // Note: In temp mode, we don't forcefully delete the temp directory
+        // The OS will clean it up eventually, and leaving it allows for debugging
+        // In fixed mode, the directory persists as expected
+    }
+    /**
+     * Start the REPL
+     * Per spec 10_REPL_UX.md L45: validate project structure on startup
+     *
+     * If .claude is missing, enter init-only mode instead of throwing.
+     * In init-only mode, only /help, /init, /exit are available.
+     */
+    async start() {
+        // Initialize project root
+        await this.initialize();
+        // Validate project structure per spec 10_REPL_UX.md L45
+        const validation = await this.validateProjectStructure();
+        if (!validation.valid) {
+            // Enter init-only mode instead of failing
+            this.initOnlyMode = true;
+            console.log('');
+            console.log('WARNING: Project not initialized');
+            for (const error of validation.errors) {
+                console.log('  - ' + error);
+            }
+            console.log('');
+            console.log('Entering init-only mode.');
+            console.log('Only /help, /init, and /exit are available.');
+            console.log('Run /init to initialize the project structure.');
+            console.log('');
+        }
+        else {
+            this.initOnlyMode = false;
+        }
+        this.running = true;
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: this.config.prompt,
+            completer: this.completer.bind(this),
+        });
+        // Print welcome message (or init-only mode reminder)
+        if (!this.initOnlyMode) {
+            this.printWelcome();
+        }
+        this.rl.prompt();
+        this.rl.on('line', (line) => {
+            // Queue-based sequential processing to prevent race conditions
+            // This ensures /start completes before subsequent commands are processed
+            this.enqueueInput(line);
+        });
+        // Return a promise that resolves when REPL exits
+        // CRITICAL: Single 'close' handler to avoid race conditions
+        // Previous bug: two handlers - one waiting for queue drain, one resolving immediately
+        return new Promise((resolve) => {
+            this.rl.on('close', async () => {
+                // In non-interactive mode, wait for all queued input to be processed
+                // This ensures all commands complete before EOF handling
+                if (this.executionMode === 'non_interactive') {
+                    // Wait for input queue to drain, OR exit immediately if running is false
+                    // running = false means /exit was called, so remaining queue items should be ignored
+                    while ((this.inputQueue.length > 0 || this.isProcessingInput) && this.running) {
+                        await new Promise(r => setTimeout(r, 10));
+                    }
+                }
+                this.running = false;
+                // Ensure all output is flushed before cleanup
+                await this.flushStdout();
+                await this.cleanup();
+                // In non-interactive mode, set process exit code
+                if (this.executionMode === 'non_interactive') {
+                    this.updateExitCode();
+                    process.exitCode = this.exitCode;
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Process input line
+     */
+    async processInput(input) {
+        if (input.startsWith('/')) {
+            await this.processCommand(input);
+        }
+        else {
+            await this.processNaturalLanguage(input);
+        }
+    }
+    /**
+     * Enqueue input for sequential processing
+     * This prevents race conditions when piped input arrives faster than processing
+     */
+    enqueueInput(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            // Empty line - just show prompt if not processing
+            if (!this.isProcessingInput && this.running) {
+                this.rl?.prompt();
+            }
+            return;
+        }
+        this.inputQueue.push(trimmed);
+        // Start processing if not already processing
+        this.processQueue();
+    }
+    /**
+     * Process queued inputs sequentially
+     * Ensures each input completes before the next one starts
+     * Per spec 10_REPL_UX.md: Sequential Processing Guarantee
+     */
+    async processQueue() {
+        // Already processing - let the current processor handle the queue
+        if (this.isProcessingInput) {
+            return;
+        }
+        this.isProcessingInput = true;
+        try {
+            while (this.inputQueue.length > 0 && this.running) {
+                const input = this.inputQueue.shift();
+                try {
+                    await this.processInput(input);
+                }
+                catch (err) {
+                    this.printError(err);
+                }
+                // In non-interactive mode, flush output after each command
+                // This ensures output is visible before processing next command
+                if (this.executionMode === 'non_interactive') {
+                    await this.flushStdout();
+                }
+                // Show prompt after each input if still running (interactive mode only)
+                if (this.running && this.inputQueue.length === 0) {
+                    if (this.executionMode === 'interactive') {
+                        this.rl?.prompt();
+                    }
+                }
+            }
+        }
+        finally {
+            this.isProcessingInput = false;
+        }
+    }
+    /**
+     * Process slash command
+     * Per spec 10_REPL_UX.md L66: All commands must return a status (fail-closed)
+     *
+     * In init-only mode, only /help, /init, /exit are allowed.
+     * Other commands return ERROR with instruction to run /init first.
+     */
+    async processCommand(input) {
+        const parts = input.slice(1).split(/\s+/);
+        const command = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        // First check if command is known (E201 for unknown takes precedence)
+        if (!KNOWN_COMMANDS.includes(command)) {
+            // Per spec 10_REPL_UX.md L66: Unknown commands must return ERROR
+            this.print('Unknown command: /' + command);
+            this.print('Type /help for available commands.');
+            return {
+                success: false,
+                error: {
+                    code: 'E201',
+                    message: 'Unknown command: /' + command + '. Type /help for available commands.',
+                },
+            };
+        }
+        // Check if in init-only mode
+        const isInitOnly = await this.isInitOnlyMode();
+        // In init-only mode, block commands that require .claude
+        if (isInitOnly && !INIT_ONLY_ALLOWED_COMMANDS.includes(command)) {
+            this.print('ERROR: Cannot run /' + command + ' - project not initialized.');
+            this.print('Run /init first to create .claude directory.');
+            return {
+                success: false,
+                error: {
+                    code: 'E301',
+                    message: 'Cannot run /' + command + ' in init-only mode. Run /init first to initialize the project.',
+                },
+            };
+        }
+        switch (command) {
+            case 'help':
+                this.printHelp();
+                return { success: true };
+            case 'init':
+                return await this.handleInit(args);
+            case 'model':
+                return await this.handleModel(args);
+            case 'tasks':
+                await this.handleTasks();
+                return { success: true };
+            case 'status':
+                await this.handleStatus();
+                return { success: true };
+            case 'start':
+                return await this.handleStart(args);
+            case 'continue':
+                return await this.handleContinue(args);
+            case 'approve':
+                return await this.handleApprove();
+            case 'exit':
+                await this.handleExit();
+                return { success: true };
+            // New commands per spec 10_REPL_UX.md
+            case 'provider':
+                return await this.handleProvider(args);
+            case 'models':
+                return await this.handleModels(args);
+            case 'keys':
+                return await this.handleKeys(args);
+            case 'logs':
+                return await this.handleLogs(args);
+            default:
+                // This should never be reached since unknown commands are handled above
+                // If we reach here, KNOWN_COMMANDS list is inconsistent with switch cases
+                throw new Error('Internal error: command "' + command + '" is in KNOWN_COMMANDS but not handled in switch');
+        }
+    }
+    /**
+     * Process natural language input
+     * 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
+     */
+    async processNaturalLanguage(input) {
+        console.log(`[DEBUG processNaturalLanguage] start, input="${input}"`);
+        if (this.session.status !== 'running') {
+            this.print('No active session. Use /start to begin, or /init to set up a new project.');
+            return;
+        }
+        if (!this.session.runner) {
+            this.print('Runner not initialized. Use /start first.');
+            return;
+        }
+        this.print('Processing task: ' + input);
+        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
+            const result = await this.session.runner.execute({
+                tasks: [{
+                        id: 'task-' + Date.now(),
+                        description: input,
+                        naturalLanguageTask: input,
+                    }],
+                selectedModel,
+            });
+            console.log(`[DEBUG processNaturalLanguage] runner.execute returned, status=${result.overall_status}`);
+            this.printExecutionResult(result);
+        }
+        catch (err) {
+            console.log(`[DEBUG processNaturalLanguage] error: ${err.message}`);
+            this.printError(err);
+        }
+        console.log(`[DEBUG processNaturalLanguage] done`);
+    }
+    /**
+     * Print welcome message
+     */
+    printWelcome() {
+        this.print('');
+        this.print('PM Orchestrator Runner - Interactive Mode');
+        this.print('=========================================');
+        this.print('Project: ' + this.session.projectPath);
+        this.print('Auth Mode: ' + this.config.authMode + ' (L1 uses Claude Code CLI)');
+        this.print('Project Mode: ' + this.projectMode);
+        if (this.projectMode === 'fixed') {
+            this.print('Verification Root: ' + this.verificationRoot);
+        }
+        this.print('');
+        this.print('Type /help for available commands, or just describe your task.');
+        this.print('');
+    }
+    /**
+     * Print help
+     */
+    printHelp() {
+        this.print('');
+        this.print('PM Orchestrator Runner - Commands');
+        this.print('=================================');
+        this.print('');
+        this.print('  /help                Show this help message');
+        this.print('  /init                Initialize .claude/ directory in current project');
+        this.print('');
+        this.print('Provider/Model Configuration:');
+        this.print('  /provider            Show current provider');
+        this.print('  /provider show       List all available providers');
+        this.print('  /provider <name>     Set provider (claude-code, openai, anthropic)');
+        this.print('  /models              List models for current provider');
+        this.print('  /models <provider>   List models for specific provider');
+        this.print('  /model               Show current model configuration');
+        this.print('  /model <name>        Set model (saves to .claude/repl.json)');
+        this.print('  /keys                Show API key status (SET/NOT SET)');
+        this.print('');
+        this.print('Session Management:');
+        this.print('  /start [path]        Start a new session (optional project path)');
+        this.print('  /continue [session]  Continue a paused session');
+        this.print('  /status              Show session status and phase');
+        this.print('  /tasks               Show tasks in current session');
+        this.print('  /approve             Approve continuation for INCOMPLETE session');
+        this.print('');
+        this.print('Logging:');
+        this.print('  /logs                List task logs for current session');
+        this.print('  /logs <task-id>      Show task details (summary view)');
+        this.print('  /logs <task-id> --full  Show task details with executor logs');
+        this.print('');
+        this.print('Other:');
+        this.print('  /exit                Exit REPL (saves state)');
+        this.print('');
+        this.print('Natural Language:');
+        this.print('  Just type your task description without a slash prefix.');
+        this.print('  Example: "Create an HTTP server with /health endpoint"');
+        this.print('');
+        this.print('Auth Mode: ' + this.config.authMode);
+        this.print('  L1 (read-only subagents) use Claude Code CLI - no API key needed.');
+        this.print('  L2 (executor) also uses Claude Code CLI integration.');
+        this.print('');
+    }
+    /**
+     * Handle /init command
+     */
+    async handleInit(args) {
+        const targetPath = args[0] || this.session.projectPath;
+        const result = await this.initCommand.execute(targetPath);
+        if (result.success) {
+            this.print(result.message);
+            this.print('');
+            this.print('Next: /start to begin a session');
+            return { success: true };
+        }
+        else {
+            this.print('Error: ' + result.message);
+            return {
+                success: false,
+                error: {
+                    code: 'E101',
+                    message: result.message,
+                },
+            };
+        }
+    }
+    /**
+     * Handle /model command
+     * Per spec 10_REPL_UX.md L113-143:
+     * - /model displays current model or "UNSET"
+     * - /model <name> sets model and generates Evidence
+     * - .claude/ missing -> E101 ERROR
+     * - JSON parse error -> E105 ERROR
+     */
+    async handleModel(args) {
+        if (args.length === 0) {
+            const result = await this.modelCommand.getModel(this.session.projectPath);
+            if (result.success) {
+                // Per spec 10_REPL_UX.md L133: Display "UNSET" if not configured
+                this.print('Current model: ' + result.model);
+                if (result.configPath) {
+                    this.print('Config file: ' + result.configPath);
+                }
+                return { success: true };
+            }
+            else {
+                // Per spec 10_REPL_UX.md L137-138: E101 or E105
+                this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+                return {
+                    success: false,
+                    error: result.error || { code: 'E105', message: result.message || 'Unknown error' },
+                };
+            }
+        }
+        else {
+            const result = await this.modelCommand.setModel(this.session.projectPath, args[0]);
+            if (result.success) {
+                this.print('Model set to: ' + args[0]);
+                this.print('Saved to: ' + result.configPath);
+                if (result.evidencePath) {
+                    this.print('Evidence: ' + result.evidencePath);
+                }
+                return { success: true };
+            }
+            else {
+                // Per spec 10_REPL_UX.md L137: E101 if .claude/ missing
+                const errorCode = result.error?.code || 'E102';
+                const errorMessage = result.error?.message || result.message || 'Failed to set model';
+                this.print('Error [' + errorCode + ']: ' + errorMessage);
+                return {
+                    success: false,
+                    error: { code: errorCode, message: errorMessage },
+                };
+            }
+        }
+    }
+    /**
+     * Handle /provider command
+     * Per spec 10_REPL_UX.md Section 2.1
+     */
+    async handleProvider(args) {
+        if (args.length === 0) {
+            // /provider - show current
+            const result = await this.providerCommand.getProvider(this.session.projectPath);
+            if (result.success) {
+                const output = this.providerCommand.formatCurrentProvider(result.provider || 'UNSET');
+                this.print(output);
+                return { success: true };
+            }
+            else {
+                this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+                return { success: false, error: result.error };
+            }
+        }
+        else if (args[0] === 'show') {
+            // /provider show - list all
+            const result = await this.providerCommand.listProviders();
+            const currentResult = await this.providerCommand.getProvider(this.session.projectPath);
+            const currentProvider = currentResult.success ? currentResult.provider : undefined;
+            const output = this.providerCommand.formatProviderList(result.providers || [], currentProvider);
+            this.print(output);
+            return { success: true };
+        }
+        else {
+            // /provider <name> - set provider
+            const result = await this.providerCommand.setProvider(this.session.projectPath, args[0]);
+            if (result.success) {
+                this.print('Provider set to: ' + args[0]);
+                this.print('Saved to: ' + result.configPath);
+                this.print('Note: Model selection has been reset. Use /models to see available models.');
+                if (result.evidencePath) {
+                    this.print('Evidence: ' + result.evidencePath);
+                }
+                return { success: true };
+            }
+            else {
+                this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+                return { success: false, error: result.error };
+            }
+        }
+    }
+    /**
+     * Handle /models command
+     * Per spec 10_REPL_UX.md Section 2.2
+     */
+    async handleModels(args) {
+        const providerId = args.length > 0 ? args[0] : undefined;
+        const result = await this.modelsCommand.listModels(this.session.projectPath, providerId);
+        if (result.success) {
+            const output = this.modelsCommand.formatModelList(result.models || [], result.currentModel, result.provider);
+            this.print(output);
+            return { success: true };
+        }
+        else {
+            this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+            return { success: false, error: result.error };
+        }
+    }
+    /**
+     * Handle /keys command
+     * Per spec 10_REPL_UX.md Section 2.3
+     */
+    async handleKeys(args) {
+        let result;
+        if (args.length > 0) {
+            result = await this.keysCommand.checkProviderKey(args[0]);
+        }
+        else {
+            result = await this.keysCommand.getKeyStatus();
+        }
+        if (result.success) {
+            const output = this.keysCommand.formatKeyStatus(result.keys || []);
+            this.print(output);
+            return { success: true };
+        }
+        else {
+            this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+            return { success: false, error: result.error };
+        }
+    }
+    /**
+     * Handle /logs command
+     * Per spec 10_REPL_UX.md Section 2.4
+     */
+    async handleLogs(args) {
+        if (args.length === 0) {
+            // /logs - list all logs for current session
+            if (!this.session.sessionId) {
+                this.print('No active session. Use /start to begin a session.');
+                return {
+                    success: false,
+                    error: { code: 'E104', message: 'No active session' },
+                };
+            }
+            const result = await this.logsCommand.listLogs(this.session.projectPath, this.session.sessionId);
+            if (result.success) {
+                this.print(result.output || 'No logs found.');
+                return { success: true };
+            }
+            else {
+                this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+                return { success: false, error: result.error };
+            }
+        }
+        else {
+            // /logs <task-id> [--full]
+            const taskId = args[0];
+            const full = args.includes('--full');
+            const result = await this.logsCommand.getTaskDetail(this.session.projectPath, taskId, full);
+            if (result.success) {
+                this.print(result.output || 'No log detail found.');
+                return { success: true };
+            }
+            else {
+                this.print('Error [' + result.error?.code + ']: ' + (result.error?.message || result.message));
+                return { success: false, error: result.error };
+            }
+        }
+    }
+    /**
+     * Handle /tasks command
+     */
+    async handleTasks() {
+        const result = await this.statusCommands.getTasks();
+        this.print(result);
+    }
+    /**
+     * Handle /status command
+     */
+    async handleStatus() {
+        const result = await this.statusCommands.getStatus();
+        this.print(result);
+    }
+    /**
+     * Handle /start command
+     * Per spec Property 32, 33: Use verification_root for file operations in temp mode
+     */
+    async handleStart(args) {
+        // In 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);
+        try {
+            const result = await this.sessionCommands.start(projectPath);
+            if (result.success) {
+                this.session.sessionId = result.sessionId;
+                this.session.runner = result.runner;
+                this.session.status = 'running';
+                // Keep session.projectPath as verificationRoot in temp mode
+                this.session.projectPath = projectPath;
+                // Initialize supervisor
+                const supervisorConfig = {
+                    checkIntervalMs: 5000,
+                    maxRetries: 3,
+                    timeoutMs: this.config.evidenceDir ? 300000 : 300000,
+                };
+                this.session.supervisor = new executor_supervisor_1.ExecutorSupervisor(this.session.runner, supervisorConfig);
+                this.print('Session started: ' + result.sessionId);
+                this.print('Project: ' + projectPath);
+                this.print('');
+                this.print('You can now describe tasks in natural language.');
+                return { success: true };
+            }
+            else {
+                this.print('Error: ' + result.message);
+                return {
+                    success: false,
+                    error: { code: 'E103', message: result.message || 'Failed to start session' },
+                };
+            }
+        }
+        catch (err) {
+            this.printError(err);
+            return {
+                success: false,
+                error: { code: 'E103', message: err.message },
+            };
+        }
+    }
+    /**
+     * Handle /continue command
+     */
+    async handleContinue(args) {
+        const sessionId = args[0] || this.session.sessionId;
+        if (!sessionId) {
+            this.print('No session to continue. Provide a session ID or start a new session.');
+            return {
+                success: false,
+                error: { code: 'E104', message: 'No session to continue' },
+            };
+        }
+        try {
+            const result = await this.sessionCommands.continueSession(sessionId);
+            if (result.success) {
+                this.session.sessionId = sessionId;
+                this.session.runner = result.runner;
+                this.session.status = 'running';
+                this.print('Session resumed: ' + sessionId);
+                return { success: true };
+            }
+            else {
+                this.print('Error: ' + result.message);
+                return {
+                    success: false,
+                    error: { code: 'E104', message: result.message || 'Failed to continue session' },
+                };
+            }
+        }
+        catch (err) {
+            this.printError(err);
+            return {
+                success: false,
+                error: { code: 'E104', message: err.message },
+            };
+        }
+    }
+    /**
+     * Handle /approve command
+     */
+    async handleApprove() {
+        if (!this.session.sessionId) {
+            this.print('No active session to approve.');
+            return {
+                success: false,
+                error: { code: 'E106', message: 'No active session to approve' },
+            };
+        }
+        try {
+            const result = await this.sessionCommands.approve(this.session.sessionId);
+            if (result.success) {
+                this.print('Continuation approved.');
+                this.print('Use /continue to resume execution.');
+                return { success: true };
+            }
+            else {
+                this.print('Error: ' + result.message);
+                return {
+                    success: false,
+                    error: { code: 'E106', message: result.message || 'Failed to approve' },
+                };
+            }
+        }
+        catch (err) {
+            this.printError(err);
+            return {
+                success: false,
+                error: { code: 'E106', message: err.message },
+            };
+        }
+    }
+    /**
+     * Handle /exit command
+     * Per spec 10_REPL_UX.md: Ensure clean exit with flushed output
+     *
+     * Guarantees:
+     * - Session state is persisted before exit
+     * - All output is flushed before readline closes
+     * - Double-completion is prevented via sessionCompleted flag
+     */
+    async handleExit() {
+        // Prevent double completion (e.g., if /exit is called multiple times)
+        if (this.sessionCompleted) {
+            this.print('Session already completed, closing...');
+            this.running = false;
+            this.rl?.close();
+            return;
+        }
+        this.sessionCompleted = true;
+        this.print('Saving session state...');
+        if (this.session.runner && this.session.sessionId) {
+            try {
+                // Complete the session first (updates status from RUNNING to COMPLETED/FAILED)
+                const failed = this.hasError || this.hasIncompleteTasks;
+                await this.session.runner.completeSession(failed);
+                await this.session.runner.saveState();
+                this.print('Session saved: ' + this.session.sessionId);
+            }
+            catch (err) {
+                // Log error but ensure status is updated for exit code calculation
+                const errorMessage = err.message || String(err);
+                this.print('Warning: Could not save session state: ' + errorMessage);
+                // Mark as error so exit code reflects persistence failure
+                this.hasError = true;
+                this.updateExitCode();
+            }
+        }
+        if (this.session.supervisor) {
+            this.session.supervisor.stop();
+        }
+        this.print('Goodbye!');
+        // Flush output before closing (critical for non-interactive mode)
+        await this.flushStdout();
+        this.running = false;
+        this.rl?.close();
+    }
+    /**
+     * Print execution result
+     * Per spec 10_REPL_UX.md: Error details must be visible for fail-closed debugging
+     */
+    printExecutionResult(result) {
+        this.print('');
+        this.print('--- Execution Result ---');
+        this.print('Status: ' + result.overall_status);
+        if (result.tasks_completed !== undefined) {
+            this.print('Tasks: ' + result.tasks_completed + '/' + result.tasks_total + ' completed');
+            // Track incomplete tasks for exit code (non-interactive mode)
+            if (result.tasks_completed < (result.tasks_total || 0)) {
+                this.hasIncompleteTasks = true;
+                this.updateExitCode();
+            }
+        }
+        // Display error details when status is ERROR (critical for debugging fail-closed behavior)
+        if (result.error) {
+            this.print('Error: ' + result.error.message);
+            if (result.error.code) {
+                this.print('Error Code: ' + result.error.code);
+            }
+            // Track error for exit code
+            this.hasError = true;
+            this.updateExitCode();
+        }
+        // Display incomplete task reasons (helps identify why tasks failed)
+        if (result.incomplete_task_reasons && result.incomplete_task_reasons.length > 0) {
+            this.print('Incomplete Tasks:');
+            for (const reason of result.incomplete_task_reasons) {
+                this.print('  - ' + reason.task_id + ': ' + reason.reason);
+            }
+            this.hasIncompleteTasks = true;
+            this.updateExitCode();
+        }
+        // Track ERROR status
+        if (result.overall_status === enums_1.OverallStatus.ERROR) {
+            this.hasError = true;
+            this.updateExitCode();
+        }
+        // Track INCOMPLETE status
+        if (result.overall_status === enums_1.OverallStatus.INCOMPLETE) {
+            this.hasIncompleteTasks = true;
+            this.updateExitCode();
+        }
+        if (result.next_action !== undefined) {
+            this.print('Next Action: ' + (result.next_action ? 'Yes' : 'No'));
+            if (result.next_action_reason) {
+                this.print('Reason: ' + result.next_action_reason);
+            }
+        }
+        this.print('------------------------');
+        this.print('');
+    }
+    /**
+     * Print message with flush guarantee for non-interactive mode
+     * Per spec 10_REPL_UX.md: Output Flush Guarantee
+     */
+    print(message) {
+        console.log(message);
+    }
+    /**
+     * Flush stdout - ensures all output is written before continuing
+     * Critical for non-interactive mode where process may exit immediately after
+     */
+    async flushStdout() {
+        return new Promise((resolve) => {
+            // If stdout is already drained, resolve immediately
+            if (process.stdout.write('')) {
+                resolve();
+            }
+            else {
+                // Wait for drain event
+                process.stdout.once('drain', () => {
+                    resolve();
+                });
+            }
+        });
+    }
+    /**
+     * Print error
+     */
+    printError(err) {
+        console.error('Error: ' + err.message);
+        this.hasError = true;
+        this.updateExitCode();
+    }
+    /**
+     * Validate project structure - per spec 10_REPL_UX.md L45
+     * "REPL の起動時点で validate 相当の検証を行い、必須構造がなければ即 ERROR とする。"
+     *
+     * @returns Validation result with valid flag and errors array
+     */
+    async validateProjectStructure() {
+        const errors = [];
+        const projectPath = this.config.projectPath;
+        // Check .claude directory exists
+        const claudeDir = path.join(projectPath, '.claude');
+        if (!fs.existsSync(claudeDir)) {
+            errors.push('.claude directory not found at ' + claudeDir);
+        }
+        else {
+            // Check for required files/directories within .claude
+            const requiredItems = [
+                { path: path.join(claudeDir, 'CLAUDE.md'), type: 'file', name: 'CLAUDE.md' },
+                { path: path.join(claudeDir, 'settings.json'), type: 'file', name: 'settings.json' },
+            ];
+            for (const item of requiredItems) {
+                if (!fs.existsSync(item.path)) {
+                    errors.push('Required ' + item.type + ' not found: ' + item.name);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Check if REPL is in init-only mode
+     * Init-only mode is active when .claude directory is missing
+     * In this mode, only /help, /init, /exit are allowed
+     *
+     * @returns true if in init-only mode (rechecks file system)
+     */
+    async isInitOnlyMode() {
+        const validation = await this.validateProjectStructure();
+        this.initOnlyMode = !validation.valid;
+        return this.initOnlyMode;
+    }
+    /**
+     * Tab completion for slash commands
+     * Per spec 10_REPL_UX.md: Tab completion support
+     *
+     * @param line - Current input line
+     * @returns Tuple of [completions, original line]
+     */
+    completer(line) {
+        // Only complete if line starts with /
+        if (!line.startsWith('/')) {
+            return [[], line];
+        }
+        // Find matching commands (prefix match)
+        const hits = SLASH_COMMANDS.filter(cmd => cmd.startsWith(line));
+        // Return only matching commands (empty if no match)
+        return [hits, line];
+    }
+    /**
+     * Detect execution mode based on TTY, environment, or config
+     * Per spec 10_REPL_UX.md: Non-interactive mode detection
+     */
+    detectExecutionMode() {
+        // Check config override first
+        if (this.config.forceNonInteractive) {
+            return 'non_interactive';
+        }
+        // Check environment variable (for testing)
+        if (process.env.PM_RUNNER_NON_INTERACTIVE === '1') {
+            return 'non_interactive';
+        }
+        // Primary detection: stdin TTY check
+        // stdin.isTTY is undefined when piped or from heredoc
+        if (!process.stdin.isTTY) {
+            return 'non_interactive';
+        }
+        return 'interactive';
+    }
+    /**
+     * Check if running in non-interactive mode
+     */
+    isNonInteractiveMode() {
+        return this.executionMode === 'non_interactive';
+    }
+    /**
+     * Get the current execution mode
+     */
+    getExecutionMode() {
+        return this.executionMode;
+    }
+    /**
+     * Set exit code based on current state
+     * Per spec 10_REPL_UX.md: Deterministic exit codes
+     */
+    updateExitCode() {
+        if (this.hasError) {
+            this.exitCode = exports.EXIT_CODES.ERROR;
+        }
+        else if (this.hasIncompleteTasks) {
+            this.exitCode = exports.EXIT_CODES.INCOMPLETE;
+        }
+        else {
+            this.exitCode = exports.EXIT_CODES.COMPLETE;
+        }
+    }
+    /**
+     * Get the exit code (for non-interactive mode)
+     */
+    getExitCode() {
+        return this.exitCode;
+    }
+    /**
+     * Get session state (for testing)
+     */
+    getSessionState() {
+        return { ...this.session };
+    }
+    /**
+     * Check if running (for testing)
+     */
+    isRunning() {
+        return this.running;
+    }
+}
+exports.REPLInterface = REPLInterface;
+//# sourceMappingURL=repl-interface.js.map