ft-scout 6.0.5 → 6.0.9

package/bin/src/commands/agent.js

@@ -1,16 +1,18 @@
 import fs from 'fs';
 import path from 'path';
+import readline from 'readline';
 import { spinner, text, isCancel, select, confirm } from '@clack/prompts';
 import chalk from 'chalk';
 import { simpleGit } from 'simple-git';
-import { generateMultiCodeFix, identifyTargetFiles, analyzeCommandError, generateCodeScanReport, generateFeaturePlan, generateCodeFile, askRepoQuestion, } from '../engine/llm.js';
+import { generateMultiCodeFix, identifyTargetFiles, analyzeCommandError, generateCodeScanReport, generateFeaturePlan, generateCodeFile, askRepoQuestion, getActiveModelInfo, } from '../engine/llm.js';
 import { loadContext, recordHistoryAction, getDirectoryFiles } from '../utils/config.js';
 import { renderMarkdown, safeNote } from '../utils/markdown.js';
 import { normalizeLanguage } from '../utils/language.js';
 import { createPullRequest } from '../engine/git.js';
+import { consumeCredit, checkTierAccess } from '../utils/auth.js';
 import { handleUndo } from './undo.js';
-import { AgentExecutionLoop } from '../engine/agentEngine.js';
-import { verifyAndSelfHealFiles, executeSmartCommand } from '../engine/verifier.js';
+import { AgentExecutionLoop, buildDirectoryTree } from '../engine/agentEngine.js';
+import { verifyAndSelfHealFiles, executeSmartCommand, runProjectVerification } from '../engine/verifier.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
@@ -226,7 +228,78 @@ export function findTargetFilesFromPrompt(userPrompt, specifiedFile, filesList)
     }
     return [];
 }
-import { consumeCredit, checkTierAccess } from '../utils/auth.js';
+export async function getAgentGoalInput(placeholderStr) {
+    if (!process.stdin.isTTY) {
+        return await text({
+            message: chalk.bold('Agent Prompt:'),
+            placeholder: placeholderStr,
+            validate: (val) => (!val || !val.trim() ? 'Please enter a prompt or /exit to quit' : undefined),
+        });
+    }
+    return new Promise((resolve) => {
+        let buffer = '';
+        let isDone = false;
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        readline.emitKeypressEvents(process.stdin, rl);
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdout.write(`\n${chalk.cyan('◇')}  ${chalk.bold('Agent Prompt:')}\n${chalk.cyan('│')}  `);
+        const cleanup = () => {
+            process.stdin.removeListener('keypress', onKeypress);
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+            }
+            rl.close();
+        };
+        const onKeypress = (str, key) => {
+            if (isDone)
+                return;
+            if (str === '\u0003' || (key && key.ctrl && key.name === 'c')) {
+                isDone = true;
+                cleanup();
+                process.stdout.write('\n');
+                resolve(Symbol.for('clack:cancel'));
+                return;
+            }
+            // Immediately catch '/' keypress as the very first typed character without requiring Enter!
+            if (buffer.length === 0 && str === '/') {
+                isDone = true;
+                cleanup();
+                readline.cursorTo(process.stdout, 0);
+                readline.clearLine(process.stdout, 0);
+                process.stdout.write(`${chalk.cyan('│')}  /\n`);
+                resolve('/');
+                return;
+            }
+            if (key && (key.name === 'return' || key.name === 'enter')) {
+                isDone = true;
+                cleanup();
+                process.stdout.write('\n');
+                resolve(buffer.trim());
+                return;
+            }
+            if (key && key.name === 'backspace') {
+                if (buffer.length > 0) {
+                    buffer = buffer.slice(0, -1);
+                    readline.cursorTo(process.stdout, 0);
+                    readline.clearLine(process.stdout, 0);
+                    process.stdout.write(`${chalk.cyan('│')}  ${buffer}`);
+                }
+                return;
+            }
+            if (str && !key.ctrl && !key.meta && key.name !== 'escape') {
+                buffer += str;
+                process.stdout.write(str);
+            }
+        };
+        process.stdin.on('keypress', onKeypress);
+    });
+}
 export async function handleAgent(goalInput, options) {
     const tierCheck = checkTierAccess('agent');
     if (!tierCheck.allowed) {
@@ -267,17 +340,26 @@ export async function handleAgent(goalInput, options) {
         language: targetLang,
         projectName,
     });
+    const modelInfo = getActiveModelInfo();
+    const fallbackPipeline = modelInfo.fallbackChain.slice(1).join(' ➔ ');
     const welcomeBanner = `
 ${chalk.bold.cyan('Scout Autonomous AI Agent')} ${targetLang ? `(${targetLang})` : ''}
+${chalk.bold('Active Model:')} ${chalk.bold.green(modelInfo.currentActiveModel)}
+${chalk.bold('Fallback Pipeline:')} ${chalk.dim(fallbackPipeline)}
+
 ${chalk.dim('Type your goal, or use slash commands:')}
-${chalk.cyan('/help')} - Show agent tools & commands.
-${chalk.cyan('/diff')} - Show git diff for uncommited changes. 
-${chalk.cyan('/clear')} - Reset conversation context.
- ${chalk.cyan('/undo')} - Revert last file modifications.
- ${chalk.cyan('/scan')} - Run vulnerability scan.
- ${chalk.cyan('/plan')} - Generate implementation roadmap.
- ${chalk.cyan('/exit')} - Exit session.
- `.trim();
+${chalk.cyan('/help')}    - Show agent tools & commands (14 tools)
+${chalk.cyan('/tree')}    - View workspace directory tree
+${chalk.cyan('/stats')}   - View real-time session & model telemetry
+${chalk.cyan('/test')}    - Run automated project test suite
+${chalk.cyan('/diff')}    - Show git diff of uncommitted changes
+${chalk.cyan('/export')}  - Save session report to .ft/
+${chalk.cyan('/undo')}    - Revert last file modifications
+${chalk.cyan('/clear')}   - Reset conversation context
+${chalk.cyan('/scan')}    - Run vulnerability scan
+${chalk.cyan('/plan')}    - Generate implementation roadmap
+${chalk.cyan('/exit')}    - Exit session
+`.trim();
     safeNote(welcomeBanner, 'Scout Agent Active Session');
     while (true) {
         let rawGoal = undefined;
@@ -288,43 +370,258 @@ ${chalk.cyan('/clear')} - Reset conversation context.
         else {
             isFirstRun = false;
             options = {};
-            const userGoalInput = await text({
-                message: chalk.bold('Agent Prompt:'),
-                placeholder: 'Ask question, fix bug, run command, scan issues, create file... (/help /exit)',
-                validate: (val) => (!val || !val.trim() ? 'Please enter a prompt or /exit to quit' : undefined),
-            });
-            if (isCancel(userGoalInput)) {
+            const userGoalInput = await getAgentGoalInput('Ask question, fix bug, run command, scan issues, create file... (/help /exit)');
+            if (isCancel(userGoalInput) || typeof userGoalInput !== 'string') {
                 safeNote(chalk.yellow('Exiting Scout Agent session. see you soon!'), 'Scout Agent Ended');
                 break;
             }
-            const trimmedInput = userGoalInput.trim();
+            let trimmedInput = userGoalInput.trim();
+            const KNOWN_SLASH_COMMANDS = [
+                '/help', '/tree', '/status', '/stats', '/test', '/explain',
+                '/export', '/save-session', '/diff', '/clear', '/compact',
+                '/undo', '/history', '/scan', '/plan', '/exit', '/quit'
+            ];
+            if (trimmedInput.startsWith('/')) {
+                const cmdName = trimmedInput.split(/\s+/)[0].toLowerCase();
+                if (!KNOWN_SLASH_COMMANDS.includes(cmdName)) {
+                    const filterStr = trimmedInput.toLowerCase();
+                    let availableOptions = [
+                        { value: '/help', label: '/help', hint: 'Show agent tools & commands guide' },
+                        { value: '/tree', label: '/tree', hint: 'Display workspace directory tree' },
+                        { value: '/stats', label: '/stats', hint: 'Show session telemetry & model statistics' },
+                        { value: '/test', label: '/test', hint: 'Run project verification test suite' },
+                        { value: '/diff', label: '/diff', hint: 'Display git diff of uncommitted changes' },
+                        { value: '/scan', label: '/scan', hint: 'Run read-only vulnerability scan' },
+                        { value: '/plan', label: '/plan', hint: 'Generate feature roadmap & plan' },
+                        { value: '/explain', label: '/explain', hint: 'Architectural breakdown of a file' },
+                        { value: '/export', label: '/export', hint: 'Save session report to .ft/' },
+                        { value: '/undo', label: '/undo', hint: 'Revert last file modifications' },
+                        { value: '/history', label: '/history', hint: 'View recent action history logs' },
+                        { value: '/clear', label: '/clear', hint: 'Reset conversation context' },
+                        { value: '/exit', label: '/exit', hint: 'Exit Scout Agent session' },
+                    ];
+                    if (filterStr !== '/') {
+                        const filtered = availableOptions.filter(o => o.value.startsWith(filterStr));
+                        if (filtered.length > 0) {
+                            availableOptions = filtered;
+                        }
+                    }
+                    const pickedCmd = await select({
+                        message: chalk.bold('Select a Slash Command:'),
+                        options: availableOptions,
+                    });
+                    if (isCancel(pickedCmd)) {
+                        continue;
+                    }
+                    let chosen = pickedCmd;
+                    if (chosen === '/explain') {
+                        const filePath = await text({
+                            message: chalk.bold('Enter file path to explain (e.g. bin/src/index.ts):'),
+                            placeholder: 'bin/src/index.ts',
+                            validate: (val) => (!val || !val.trim() ? 'File path is required' : undefined),
+                        });
+                        if (isCancel(filePath))
+                            continue;
+                        chosen = `/explain ${filePath.trim()}`;
+                    }
+                    else if (chosen === '/plan') {
+                        const idea = await text({
+                            message: chalk.bold('Enter feature idea or goal for the plan:'),
+                            placeholder: 'Add authentication middleware...',
+                            validate: (val) => (!val || !val.trim() ? 'Goal description is required' : undefined),
+                        });
+                        if (isCancel(idea))
+                            continue;
+                        chosen = `/plan ${idea.trim()}`;
+                    }
+                    else if (chosen === '/tree') {
+                        const dirInput = await text({
+                            message: chalk.bold('Enter directory path & optional depth (default "." 4):'),
+                            placeholder: '. 4',
+                        });
+                        if (!isCancel(dirInput) && typeof dirInput === 'string' && dirInput.trim()) {
+                            chosen = `/tree ${dirInput.trim()}`;
+                        }
+                    }
+                    else if (chosen === '/test') {
+                        const testCmd = await text({
+                            message: chalk.bold('Enter custom test command (press Enter for default):'),
+                            placeholder: 'npm test',
+                        });
+                        if (!isCancel(testCmd) && typeof testCmd === 'string' && testCmd.trim()) {
+                            chosen = `/test ${testCmd.trim()}`;
+                        }
+                    }
+                    trimmedInput = chosen;
+                }
+            }
             if (['exit', 'quit', 'q', ':q', '/exit', '/quit'].includes(trimmedInput.toLowerCase())) {
                 safeNote(chalk.yellow('Exiting Scout Agent session. see you soon!'), 'Scout Agent Ended');
                 break;
             }
             if (trimmedInput.toLowerCase() === '/help') {
                 const helpText = `
-### ️ Scout Agent Tools
-- **read_file**: Read content & line ranges of codebase files.
-- **write_file**: Create new files or overwrite existing code.
-- **edit_file**: Search-and-replace exact code snippets.
-- **run_command**: Execute shell commands live (\`npm test\`, \`build\`).
-- **grep_search**: Regex/string search across all files.
-- **glob_search**: Pattern search for workspace files.
+### 🛠️ Scout Autonomous Agent Tools (14 Available)
+- **read_file**: Read content & line ranges of workspace files.
+- **write_file**: Create new files or overwrite code directly.
+- **edit_file**: Search & replace exact target code snippets.
+- **multi_edit_file**: Apply batch snippet replacements in a single step.
+- **run_command**: Execute live terminal commands (\`npm test\`, \`build\`).
+- **tree_view**: Generate visual ASCII directory tree structures.
+- **file_info**: Get file statistics, size, lines, & modification time.
+- **grep_search**: String/regex pattern search across codebase.
+- **glob_search**: Filter workspace files by file pattern.
+- **fetch_url**: Fetch web API documentation or URL content.
+- **git_diff**: Retrieve uncommitted workspace git diff.
+- **ask_user**: Request missing secret credentials or API keys.
+- **task_completed**: Conclude autonomous goal execution with teardown.
 
-### Slash Commands
-- \`/help\`: View this assistance screen.
-- \`/diff\`: Display colorized git diff of uncommitted workspace changes.
-- \`/clear\` or \`/compact\`: Clear session context window.
-- \`/undo\`: Revert last changes applied by Scout Agent.
-- \`/scan\`: Perform read-only security & bug scan.
-- \`/plan <idea>\`: Generate feature feasibility roadmap.
-- \`/history\`: View recent Scout actions.
-- \`/exit\`: Quit Scout Agent session.
+### 🚀 Interactive Slash Commands
+- \`/help\`: Show this tools & commands guide.
+- \`/tree [dir]\`: Display workspace directory tree structure.
+- \`/status\` or \`/stats\`: Show session telemetry & statistics.
+- \`/test [cmd]\`: Run project verification test suite.
+- \`/explain <file>\`: Get deep architectural breakdown of a file.
+- \`/export\` or \`/save-session\`: Save session report to \`.ft/session-<timestamp>.md\`.
+- \`/diff\`: Display colorized git diff of uncommitted changes.
+- \`/clear\` or \`/compact\`: Reset agent conversation context.
+- \`/undo\`: Revert last file modifications.
+- \`/history\`: View recent Scout action logs.
+- \`/exit\`: End Scout Agent session.
  `.trim();
                 safeNote(renderMarkdown(helpText), ' Scout Slash Commands & Tools');
                 continue;
             }
+            if (trimmedInput.toLowerCase().startsWith('/tree')) {
+                const parts = trimmedInput.split(/\s+/).slice(1);
+                let targetDir = '.';
+                let maxDepth = 4;
+                if (parts.length === 1) {
+                    if (/^\d+$/.test(parts[0])) {
+                        maxDepth = parseInt(parts[0], 10);
+                    }
+                    else {
+                        targetDir = parts[0];
+                    }
+                }
+                else if (parts.length >= 2) {
+                    if (/^\d+$/.test(parts[0])) {
+                        maxDepth = parseInt(parts[0], 10);
+                        targetDir = parts[1];
+                    }
+                    else {
+                        targetDir = parts[0];
+                        if (/^\d+$/.test(parts[1])) {
+                            maxDepth = parseInt(parts[1], 10);
+                        }
+                    }
+                }
+                const fullDir = path.resolve(process.cwd(), targetDir);
+                if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) {
+                    safeNote(chalk.yellow(`Directory not found: "${targetDir}"`), '️ Directory Tree Error');
+                }
+                else {
+                    const treeStr = buildDirectoryTree(fullDir, '', 0, maxDepth);
+                    safeNote(`Directory Tree for "${targetDir}" (depth ${maxDepth}):\n${targetDir}/\n${treeStr}`, ' Workspace Directory Tree');
+                }
+                continue;
+            }
+            if (['/status', '/stats'].includes(trimmedInput.toLowerCase())) {
+                const stats = agentLoop.getStats();
+                const modifiedFiles = agentLoop.getModifiedFiles();
+                const backups = agentLoop.getBackups();
+                const git = simpleGit();
+                let currentBranch = 'main';
+                try {
+                    const branchSummary = await git.branch();
+                    currentBranch = branchSummary.current || 'main';
+                }
+                catch { }
+                const elapsedSec = Math.round(stats.elapsedMs / 1000);
+                const activeModel = getActiveModelInfo();
+                const fallbackStatus = activeModel.lastFallbackInfo
+                    ? `Switched from \`${activeModel.lastFallbackInfo.previousModel}\` ➔ \`${activeModel.lastFallbackInfo.fallbackModel}\` (${activeModel.lastFallbackInfo.reason})`
+                    : 'None (Primary model actively responding)';
+                const statsMd = `
+### 📊 Scout Session & AI Model Telemetry
+- **Active AI Model**: \`${activeModel.currentActiveModel}\`
+- **Primary AI Model**: \`${activeModel.primaryModel}\`
+- **Fallback Chain**: \`${activeModel.fallbackChain.join(' ➔ ')}\`
+- **Last Fallback Event**: ${fallbackStatus}
+- **Active Branch**: \`${currentBranch}\`
+- **Elapsed Session Time**: \`${elapsedSec}s\`
+- **Steps Executed**: \`${stats.totalSteps}\`
+- **Total Tool Calls**: \`${stats.totalToolCalls}\`
+- **Modified Files**: \`${modifiedFiles.length}\` (${modifiedFiles.map(f => `\`${f}\``).join(', ') || 'None'})
+- **Stored File Backups**: \`${backups.length}\`
+`.trim();
+                safeNote(renderMarkdown(statsMd), ' Scout Session & Model Telemetry');
+                continue;
+            }
+            if (trimmedInput.toLowerCase().startsWith('/test')) {
+                const parts = trimmedInput.split(/\s+/);
+                const customCmd = parts.slice(1).join(' ') || options?.verifyCmd;
+                const testSpin = spinner();
+                testSpin.start(`Running project verification test suite ${customCmd ? `(\`${customCmd}\`)` : ''}...`);
+                const testRes = await runProjectVerification(process.cwd(), customCmd);
+                if (testRes.valid) {
+                    testSpin.stop(chalk.green('Project verification tests passed cleanly!'));
+                    safeNote(`${chalk.green(' Verification Passed:')}\n\`\`\`\n${testRes.output.slice(0, 3000)}\n\`\`\``, ' Test Suite Clean');
+                }
+                else {
+                    testSpin.stop(chalk.red('Project verification test suite failed.'));
+                    safeNote(`${chalk.red('️ Verification Failed:')}\n${testRes.errors.join('\n')}\n\`\`\`\n${testRes.output.slice(0, 3000)}\n\`\`\``, ' Test Failure Warning');
+                }
+                continue;
+            }
+            if (trimmedInput.toLowerCase().startsWith('/explain')) {
+                const parts = trimmedInput.split(/\s+/);
+                const targetPath = parts[1];
+                if (!targetPath) {
+                    safeNote(chalk.yellow('Usage: /explain <filePath> (e.g. /explain bin/src/index.ts)'), ' Explain Command');
+                    continue;
+                }
+                const fullP = path.resolve(process.cwd(), targetPath);
+                if (!fs.existsSync(fullP)) {
+                    safeNote(chalk.yellow(`File not found: ${targetPath}`), ' Explain Error');
+                    continue;
+                }
+                const explainSpin = spinner();
+                explainSpin.start(`Analyzing architecture and structure of ${targetPath}...`);
+                const content = fs.readFileSync(fullP, 'utf-8');
+                const explanation = await askRepoQuestion(`Provide a deep architectural breakdown, primary purpose, component breakdown, and code explanation for file "${targetPath}":\n\`\`\`\n${content.slice(0, 6000)}\n\`\`\``, projectName, filesList, '', [], { language: targetLang });
+                explainSpin.stop('Analysis complete.');
+                safeNote(renderMarkdown(explanation), ` Architectural Breakdown: ${targetPath}`);
+                continue;
+            }
+            if (['/export', '/save-session'].includes(trimmedInput.toLowerCase())) {
+                const ftDir = path.join(process.cwd(), '.ft');
+                if (!fs.existsSync(ftDir))
+                    fs.mkdirSync(ftDir, { recursive: true });
+                const timeStamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const sessionPath = path.join(ftDir, `session-${timeStamp}.md`);
+                const stats = agentLoop.getStats();
+                const modifiedFiles = agentLoop.getModifiedFiles();
+                const history = (await import('../utils/config.js')).loadHistory();
+                const exportContent = `# Scout Agent Session Report
+Date: ${new Date().toLocaleString()}
+Project: ${projectName}
+
+## Session Statistics
+- Total Steps: ${stats.totalSteps}
+- Tool Calls: ${stats.totalToolCalls}
+- Modified Files Count: ${modifiedFiles.length}
+
+## Modified Files
+${modifiedFiles.map(f => `- ${f}`).join('\n') || 'None'}
+
+## Action History
+${history.slice(0, 15).map(h => `- [${h.timestamp}] ${h.command}: ${h.description}`).join('\n')}
+`;
+                fs.writeFileSync(sessionPath, exportContent, 'utf-8');
+                safeNote(chalk.green(`Session report saved to: ${chalk.bold.cyan(path.relative(process.cwd(), sessionPath))}`), ' Session Exported');
+                continue;
+            }
             if (trimmedInput.toLowerCase() === '/diff') {
                 try {
                     const { execSync } = await import('child_process');
@@ -619,14 +916,74 @@ ${filePreviews}
             safeNote(chalk.yellow('No active goal specified.'), ' Scout Agent');
             continue;
         }
+        const git = simpleGit();
+        const isRepo = await git.checkIsRepo();
+        let currentBranch = 'main';
+        if (isRepo) {
+            try {
+                const branchSummary = await git.branch();
+                currentBranch = branchSummary.current || 'main';
+            }
+            catch { }
+        }
+        // Fast Multi-File Fix path via generateMultiCodeFix if --issue is set
+        if (options?.issue) {
+            const idSpinner = spinner();
+            idSpinner.start('Scout AI: Identifying affected target files...');
+            const targetFiles = await identifyTargetFiles(finalGoal, projectName, filesList, targetLang, options?.native);
+            idSpinner.stop(targetFiles.length > 0 ? `Identified ${targetFiles.length} target file(s): ${targetFiles.join(', ')}` : 'Target identification complete.');
+            if (targetFiles.length > 0) {
+                const targetMap = {};
+                for (const tf of targetFiles) {
+                    const absP = path.resolve(cwd, tf);
+                    if (fs.existsSync(absP)) {
+                        targetMap[tf] = fs.readFileSync(absP, 'utf-8');
+                    }
+                }
+                if (Object.keys(targetMap).length > 0) {
+                    const fixSpinner = spinner();
+                    fixSpinner.start(`Scout AI: Generating multi-file fixes for ${Object.keys(targetMap).join(', ')}...`);
+                    const multiFixRes = await generateMultiCodeFix(finalGoal, projectName, filesList, targetMap, targetLang, options?.native, (done, total, curFile) => {
+                        fixSpinner.message(`Generating fix for ${curFile} (${done}/${total})...`);
+                    });
+                    fixSpinner.stop('Multi-file fixes generated.');
+                    const backups = [];
+                    const affectedFiles = [];
+                    for (const item of multiFixRes.files) {
+                        const absPath = path.resolve(cwd, item.targetFile);
+                        if (fs.existsSync(absPath)) {
+                            backups.push({
+                                filePath: item.targetFile,
+                                originalContent: fs.readFileSync(absPath, 'utf-8'),
+                            });
+                        }
+                        fs.mkdirSync(path.dirname(absPath), { recursive: true });
+                        fs.writeFileSync(absPath, item.fixedCode, 'utf-8');
+                        affectedFiles.push(item.targetFile);
+                    }
+                    recordHistoryAction({
+                        command: `scout agent --issue ${options.issue}`,
+                        description: `Auto-fixed issue on ${affectedFiles.length} file(s)`,
+                        previousBranch: currentBranch,
+                        affectedFiles,
+                        backups,
+                    });
+                    safeNote(`### Fixed Issue\n${multiFixRes.problem}\n\n### Fix Applied\n${multiFixRes.howFixed}\n\n### Modified Files\n${affectedFiles.map(f => ` • \`${f}\``).join('\n')}`, ' Scout Multi-File Auto-Fix Complete');
+                    continue;
+                }
+            }
+        }
+        // Standard Agent Goal Execution: Pre-scan & identify target files
+        const idSpinner = spinner();
+        idSpinner.start('Scout AI: Analyzing codebase file tree & resolving target files...');
+        const targetFiles = await identifyTargetFiles(finalGoal, projectName, filesList, targetLang, options?.native);
+        idSpinner.stop(targetFiles.length > 0 ? `Target files resolved: ${targetFiles.map(f => `\`${f}\``).join(', ')}` : 'Analysis complete.');
         safeNote(`${chalk.bold.cyan(' Scout Autonomous Execution Initialized')}\n` +
-            `${chalk.dim('Goal:')} ${finalGoal}`, ' Scout Agent Execution');
+            `${chalk.dim('Goal:')} ${finalGoal}` +
+            (targetFiles.length > 0 ? `\n${chalk.dim('Target Files:')} ${targetFiles.map(f => `\`${f}\``).join(', ')}` : ''), ' Scout Agent Execution');
         const execResult = await agentLoop.executeGoal(finalGoal);
         const modifiedFiles = agentLoop.getModifiedFiles();
         const backups = agentLoop.getBackups();
-        const git = simpleGit();
-        const isRepo = await git.checkIsRepo();
-        let currentBranch = 'main';
         if (isRepo) {
             try {
                 const branchSummary = await git.branch();
@@ -665,7 +1022,9 @@ ${execResult.summary}
             message: chalk.bold('Review Scout Agent result. What would you like to do?'),
             options: [
                 { value: 'keep', label: ' Keep Changes', hint: `Retain agent changes on current branch (${currentBranch})` },
+                { value: 'test', label: ' Run Verification Tests', hint: 'Execute test suite to confirm zero regressions' },
                 { value: 'pr', label: ' Create Pull Request', hint: 'Push fix to a new branch & open a Pull Request' },
+                { value: 'export', label: ' Export Session Report', hint: 'Save detailed session teardown report to .ft/' },
                 { value: 'revert', label: '️ Revert Changes', hint: 'Restore original code immediately' },
             ],
         });
@@ -676,6 +1035,47 @@ ${execResult.summary}
             revSpinner.stop('Changes reverted successfully.');
             continue;
         }
+        if (actionChoice === 'test') {
+            const testSpin = spinner();
+            testSpin.start('Running project verification test suite...');
+            const testRes = await runProjectVerification(process.cwd(), options?.verifyCmd);
+            if (testRes.valid) {
+                testSpin.stop(chalk.green('Project verification tests passed cleanly!'));
+                safeNote(`${chalk.green(' Verification Passed:')}\n\`\`\`\n${testRes.output.slice(0, 3000)}\n\`\`\``, ' Test Suite Clean');
+            }
+            else {
+                testSpin.stop(chalk.red('Project verification test suite failed.'));
+                safeNote(`${chalk.red('️ Verification Failed:')}\n${testRes.errors.join('\n')}\n\`\`\`\n${testRes.output.slice(0, 3000)}\n\`\`\``, ' Test Failure Warning');
+            }
+            continue;
+        }
+        if (actionChoice === 'export') {
+            const ftDir = path.join(process.cwd(), '.ft');
+            if (!fs.existsSync(ftDir))
+                fs.mkdirSync(ftDir, { recursive: true });
+            const timeStamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const sessionPath = path.join(ftDir, `session-${timeStamp}.md`);
+            const stats = agentLoop.getStats();
+            const exportContent = `# Scout Agent Session Report
+Date: ${new Date().toLocaleString()}
+Project: ${projectName}
+Goal: ${finalGoal}
+
+## Session Statistics
+- Total Steps: ${stats.totalSteps}
+- Tool Calls: ${stats.totalToolCalls}
+- Modified Files Count: ${modifiedFiles.length}
+
+## Modified Files
+${modifiedFiles.map(f => `- ${f}`).join('\n') || 'None'}
+
+## Execution Summary
+${execResult.summary}
+`;
+            fs.writeFileSync(sessionPath, exportContent, 'utf-8');
+            safeNote(chalk.green(`Session report saved to: ${chalk.bold.cyan(path.relative(process.cwd(), sessionPath))}`), ' Session Exported');
+            continue;
+        }
         if (actionChoice === 'pr') {
             const prSpinner = spinner();
             prSpinner.start('Creating Pull Request...');