camo-cli 2.0.1

package/dist/tools/FileTools.js

@@ -0,0 +1,88 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createPatch } from 'diff';
+import { PermissionManager } from '../utils/PermissionManager.js';
+/**
+ * File operation tools
+ */
+export const FileTools = {
+    async readFile(args, callbacks) {
+        try {
+            // Smart path resolution
+            let p = args.path;
+            if (!path.isAbsolute(p)) {
+                // Remove project root prefix if present in relative path to avoid duplication
+                const cwdName = path.basename(process.cwd());
+                if (p.startsWith(cwdName + '/')) {
+                    p = p.substring(cwdName.length + 1);
+                }
+                p = path.resolve(process.cwd(), p);
+            }
+            const content = await fs.readFile(p, 'utf-8');
+            const lines = content.split('\n');
+            callbacks.onChunk(`\n[TOOL_STATUS]Read ${lines.length} lines from ${path.basename(p)}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ content: content.slice(0, 8000) });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_STATUS]Error: ${e.message}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ error: `Failed to read file: ${e.message}` });
+        }
+    },
+    async writeFile(args, callbacks) {
+        // Normalize path - remove leading slashes to make it relative
+        let targetPath = args.path;
+        // If path starts with /, treat it as relative from cwd
+        if (targetPath.startsWith('/')) {
+            targetPath = targetPath.substring(1);
+        }
+        const p = path.resolve(process.cwd(), targetPath);
+        let diff = '';
+        try {
+            const existingContent = await fs.readFile(p, 'utf-8');
+            diff = createPatch(targetPath, existingContent, args.content);
+        }
+        catch (e) {
+            diff = createPatch(targetPath, '', args.content);
+        }
+        // Permission Check
+        const allowed = await PermissionManager.getInstance().validate('FILE_WRITE', {
+            path: targetPath,
+            diff: diff
+        }, callbacks);
+        if (!allowed) {
+            return JSON.stringify({ error: 'User denied file write.' });
+        }
+        try {
+            // Create parent directory if it doesn't exist
+            const dir = path.dirname(p);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(p, args.content, 'utf-8');
+            callbacks.onChunk(`\n[TOOL_STATUS][ok] File written: ${targetPath}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ success: true, path: targetPath });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async listFiles(args, callbacks) {
+        try {
+            let p = args.path || '.';
+            if (!path.isAbsolute(p)) {
+                const cwdName = path.basename(process.cwd());
+                if (p.startsWith(cwdName + '/')) {
+                    p = p.substring(cwdName.length + 1);
+                }
+                p = path.resolve(process.cwd(), p);
+            }
+            const files = await fs.readdir(p);
+            const clean = files.filter(f => !['node_modules', '.git', '.DS_Store'].includes(f));
+            // Return concise list directly
+            return JSON.stringify({ files: clean });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_STATUS]Error: ${e.message}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ error: `Failed to list files: ${e.message}` });
+        }
+    }
+};

package/dist/tools/MemoryTools.js

@@ -0,0 +1,53 @@
+import { MemoryManager } from '../memory/MemoryManager.js';
+/**
+ * Memory Tools - Persistent working memory operations
+ */
+export const MemoryTools = {
+    /**
+     * Store learned facts in context.md
+     */
+    async updateMemory(args, callbacks) {
+        try {
+            const memory = MemoryManager.getInstance();
+            await memory.updateContext(args.category, args.content);
+            callbacks.onChunk(`\n[TOOL_STATUS]Saved to memory: ${args.category}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ success: true, category: args.category });
+        }
+        catch (e) {
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    /**
+     * Update task status in plan.md
+     */
+    async syncPlan(args, callbacks) {
+        try {
+            const memory = MemoryManager.getInstance();
+            await memory.updateTaskStatus(args.taskId, args.status);
+            const statusText = args.status === 'complete' ? 'completed' : args.status === 'in_progress' ? 'started' : 'pending';
+            callbacks.onChunk(`\n[TOOL_STATUS]Plan updated: ${args.taskId} → ${statusText}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ success: true, taskId: args.taskId, status: args.status });
+        }
+        catch (e) {
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    /**
+     * Retrieve context from memory
+     */
+    async recallContext(args, callbacks) {
+        try {
+            const memory = MemoryManager.getInstance();
+            const context = await memory.loadContext();
+            if (args.query) {
+                // Simple filtering by query
+                const lines = context.split('\n').filter(line => line.toLowerCase().includes(args.query.toLowerCase()));
+                return JSON.stringify({ context: lines.join('\n') });
+            }
+            return JSON.stringify({ context });
+        }
+        catch (e) {
+            return JSON.stringify({ error: e.message });
+        }
+    }
+};

package/dist/tools/SearchTools.js

@@ -0,0 +1,45 @@
+import { execAsync } from '../utils/execAsync.js';
+import { PermissionManager } from '../utils/PermissionManager.js';
+export const SearchTools = {
+    /**
+     * Search for a pattern in files
+     */
+    grep: async (args, callbacks) => {
+        const pattern = args.pattern || args.query;
+        const path = args.path || '.';
+        if (!pattern)
+            return "Error: 'pattern' argument is required";
+        // Permission check
+        const allowed = await PermissionManager.getInstance().validate('SHELL', { command: `grep ${pattern} ${path}` }, callbacks);
+        if (!allowed)
+            return "Error: Permission denied for grep";
+        callbacks.onChunk(`\n[Running grep search for "${pattern}" in "${path}"]\n`);
+        try {
+            // Use git grep if available as it respects .gitignore, otherwise fallback to grep
+            // But for simplicity/robustness, standard grep -r is good.
+            // Let's try git grep first if in a git repo, else standard grep.
+            // Actually, let's just use grep -rn for now to be safe and standard.
+            // -r: recursive, -n: line numbers, -I: ignore binary
+            // exclude .git, node_modules, dist
+            const exclude = "--exclude-dir={.git,node_modules,dist,.next,build,.camo}";
+            // Use execAsync helper
+            const { stdout, stderr } = await execAsync(`grep -rnI ${exclude} "${pattern}" "${path}"`);
+            if (!stdout && !stderr)
+                return "No matches found.";
+            if (stderr && !stdout)
+                return `Error: ${stderr}`;
+            // Limit output to prevent overflow
+            const lines = stdout.split('\n');
+            if (lines.length > 50) {
+                return lines.slice(0, 50).join('\n') + `\n... and ${lines.length - 50} more matches.`;
+            }
+            return stdout;
+        }
+        catch (error) {
+            // grep returns exit code 1 if no matches found, which execAsync throws as error
+            if (error.code === 1)
+                return "No matches found.";
+            return `Error executing grep: ${error.message}`;
+        }
+    }
+};

package/dist/tools/ShellTools.js

@@ -0,0 +1,40 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { PermissionManager } from '../utils/PermissionManager.js';
+const execAsync = promisify(exec);
+const SHELL_TIMEOUT_MS = 30000;
+/**
+ * Shell command execution tool
+ */
+export const ShellTools = {
+    async executeShellCommand(args, callbacks) {
+        // Permission Check
+        const allowed = await PermissionManager.getInstance().validate('SHELL', {
+            command: args.command
+        }, callbacks);
+        if (!allowed) {
+            return JSON.stringify({ error: 'User denied command execution.' });
+        }
+        // Execute with output display
+        try {
+            const { stdout, stderr } = await execAsync(args.command, {
+                cwd: process.cwd(),
+                timeout: SHELL_TIMEOUT_MS
+            });
+            const output = stdout + (stderr ? '\n' + stderr : '');
+            const preview = output.trim().slice(0, 200);
+            if (preview.length > 0) {
+                callbacks.onChunk(`\n[TOOL_STATUS]${preview}${output.length > 200 ? '...' : ''}[/TOOL_STATUS]\n`);
+            }
+            else {
+                callbacks.onChunk(`\n[TOOL_STATUS][ok] Command executed[/TOOL_STATUS]\n`);
+            }
+            return JSON.stringify({ exitCode: 0, output: output.slice(0, 2000) });
+        }
+        catch (e) {
+            const errorMsg = e.stderr || e.message;
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${errorMsg.slice(0, 200)}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ exitCode: e.code || 1, error: errorMsg });
+        }
+    }
+};

package/dist/tools/TaskTools.js

@@ -0,0 +1,52 @@
+// Simple in-memory task store for the session
+// In a real app, this might persist to .camo/tasks.json
+let sessionTasks = [];
+export const TaskTools = {
+    /**
+     * Add a new task
+     */
+    addTask: async (args, callbacks) => {
+        const description = args.description || args.task;
+        if (!description)
+            return "Error: 'description' is required";
+        const id = (sessionTasks.length + 1).toString();
+        const newTask = {
+            id,
+            description,
+            status: 'pending'
+        };
+        sessionTasks.push(newTask);
+        callbacks.onChunk(`\n[Task Added] #${id}: ${description}\n`);
+        return JSON.stringify({ id, status: 'pending' });
+    },
+    /**
+     * Update a task status
+     */
+    updateTask: async (args, callbacks) => {
+        const id = args.id;
+        const status = args.status;
+        if (!id || !status)
+            return "Error: 'id' and 'status' are required";
+        if (!['pending', 'in_progress', 'completed', 'failed'].includes(status)) {
+            return "Error: Invalid status. Use pending, in_progress, completed, or failed";
+        }
+        const task = sessionTasks.find(t => t.id === id);
+        if (!task)
+            return `Error: Task #${id} not found`;
+        task.status = status;
+        callbacks.onChunk(`\n[Task Updated] #${id} -> ${status}\n`);
+        return JSON.stringify({ id, status });
+    },
+    /**
+     * List all tasks
+     */
+    listTasks: async (args, callbacks) => {
+        if (sessionTasks.length === 0)
+            return "No active tasks.";
+        const list = sessionTasks.map(t => {
+            const symbol = t.status === 'completed' ? '[x]' : t.status === 'in_progress' ? '[/]' : t.status === 'failed' ? '[!]' : '[ ]';
+            return `${symbol} #${t.id} ${t.description}`;
+        }).join('\n');
+        return list;
+    }
+};

package/dist/tools/ToolDefinitions.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+/**
+ * Tool Definitions for Vercel AI SDK (Zod)
+ */
+export const tools = {
+    writeFile: {
+        description: 'Create or overwrite a file with new content. Returns the path of the created file.',
+        parameters: z.object({
+            path: z.string().describe('The absolute or relative path of the file to write'),
+            content: z.string().describe('The full text content to write to the file')
+        })
+    },
+    readFile: {
+        description: 'Read the contents of a file. Returns the file content or an error if not found.',
+        parameters: z.object({
+            path: z.string().describe('The absolute or relative path of the file to read')
+        })
+    },
+    editFile: {
+        description: 'Apply a unified diff to a file. Used for modifying existing files surgically. Returns success status.',
+        parameters: z.object({
+            path: z.string().describe('The file to edit'),
+            unifiedDiff: z.string().describe('The unified diff content to apply')
+        })
+    },
+    executeShellCommand: {
+        description: 'Execute a shell command. Returns stdout/stderr. Use for running tests, installing deps, etc.',
+        parameters: z.object({
+            command: z.string().describe('The shell command to execute')
+        })
+    },
+    listFiles: {
+        description: 'List files in a directory recursively. Returns a list of file paths. Limits depth and breadth.',
+        parameters: z.object({
+            path: z.string().describe('The directory path to list (default: .)')
+        })
+    },
+    grep: {
+        description: 'Search for a string pattern in files using grep. Returns matching lines and filenames.',
+        parameters: z.object({
+            pattern: z.string().describe('regex or string pattern to search for'),
+            path: z.string().describe('directory/file to search (default: .)')
+        })
+    },
+    webFetch: {
+        description: 'Fetch content from a URL. Useful for reading docs or external resources. Returns text content.',
+        parameters: z.object({
+            url: z.string().describe('The URL to fetch')
+        })
+    },
+    internal_thought: {
+        description: 'Log a private thought or plan. Not visible to user. Use for complex reasoning.',
+        parameters: z.object({
+            thought: z.string().describe('The thought content')
+        })
+    },
+    ToDoWrite: {
+        description: 'Manage the task plan. Add, update, or complete tasks.',
+        parameters: z.object({
+            action: z.enum(['add', 'update', 'complete', 'list']).describe('add | update | complete | list'),
+            task: z.string().optional().describe('Task description or ID'),
+            status: z.enum(['pending', 'in_progress', 'completed', 'failed']).optional().describe('For update: pending | in_progress | completed | failed')
+        })
+    },
+    readCodeContext: {
+        description: 'Analyze code complexity and structure using AST. Returns functions, classes, and imports.',
+        parameters: z.object({
+            path: z.string().describe('File to analyze'),
+            filter: z.string().optional().describe('Filter: "all", "functions", "classes", "interfaces", "types" (default: all)')
+        })
+    },
+    verifyChange: {
+        description: 'Search for tests related to a modified file and execute them. Returns test results.',
+        parameters: z.object({
+            changedFile: z.string().describe('The file that was changed'),
+            testPattern: z.string().optional().describe('Custom test file pattern (optional)')
+        })
+    },
+    // Memory tools
+    updateMemory: {
+        description: 'Store learned facts about the project in persistent memory. Use when you discover important information.',
+        parameters: z.object({
+            category: z.string().describe('Category for the fact (e.g., "Architecture", "Key Files", "Decisions")'),
+            content: z.string().describe('The fact to store (e.g., "Database uses PostgreSQL")')
+        })
+    },
+    syncPlan: {
+        description: 'Update task status in the persistent plan. Call after completing or starting a sub-task.',
+        parameters: z.object({
+            taskId: z.string().describe('The task ID to update'),
+            status: z.enum(['pending', 'in_progress', 'complete']).describe('New status for the task')
+        })
+    },
+    recallContext: {
+        description: 'Retrieve stored project knowledge from memory. Use to avoid redundant searches.',
+        parameters: z.object({
+            query: z.string().optional().describe('Optional filter to search for specific knowledge')
+        })
+    }
+};
+// Legacy Export for Google Native (optional, but keeping for safety if needed, mapped from Zod if complex, but manual here is fine for now if we fully switch)
+// Actually AgentLoop refactor will remove usage of googleToolDefinitions, so we can deprecate it.

package/dist/tools/ToolRegistry.js

@@ -0,0 +1,30 @@
+import { FileTools } from './FileTools.js';
+import { ShellTools } from './ShellTools.js';
+import { SearchTools } from './SearchTools.js';
+import { TaskTools } from './TaskTools.js';
+import { MemoryTools } from './MemoryTools.js';
+export const ToolRegistry = {
+    // File operations
+    readFile: FileTools.readFile,
+    writeFile: FileTools.writeFile,
+    listFiles: FileTools.listFiles,
+    // Shell operations
+    executeShellCommand: ShellTools.executeShellCommand,
+    // Search operations
+    grep: SearchTools.grep,
+    // Task operations
+    addTask: TaskTools.addTask,
+    updateTask: TaskTools.updateTask,
+    listTasks: TaskTools.listTasks,
+    // Memory operations
+    updateMemory: MemoryTools.updateMemory,
+    syncPlan: MemoryTools.syncPlan,
+    recallContext: MemoryTools.recallContext,
+    // Note: Other tools (webFetch, etc.) will be migrated later
+};
+export function getToolImplementation(name) {
+    return ToolRegistry[name];
+}
+export function getAllToolNames() {
+    return Object.keys(ToolRegistry);
+}

package/dist/types/Agent.js

@@ -0,0 +1,6 @@
+/**
+ * CAMO Agent - Type Definitions
+ *
+ * This file contains shared types used across the agent system.
+ */
+export {};

package/dist/types/ink.js

@@ -0,0 +1 @@
+export {};

package/dist/types/message.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ui.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/CriticAgent.js

@@ -0,0 +1,88 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+export class CriticAgent {
+    constructor(apiKey) {
+        this.client = new GoogleGenerativeAI(apiKey);
+        this.model = this.client.getGenerativeModel({
+            model: 'gemini-2.0-flash'
+        });
+    }
+    async validate(userRequest, agentResponse, toolsUsed) {
+        const prompt = `You are a critic reviewing an AI agent's work.
+
+**USER REQUEST:**
+${userRequest}
+
+**AGENT RESPONSE:**
+${agentResponse}
+
+**TOOLS USED:**
+${toolsUsed.join(', ')}
+
+**YOUR TASK:**
+Critically evaluate if the agent's response fulfills the user's request.
+
+Check for:
+1. Did the agent actually solve the problem?
+2. Are there logical errors?
+3. Did the agent use the right tools?
+4. Is the solution complete or half-baked?
+5. Are there any security issues?
+
+**OUTPUT FORMAT:**
+VALID: yes/no
+REASONING: [explain your verdict in 1-2 sentences]
+SUGGESTIONS: [if invalid, what should be fixed?]`;
+        try {
+            const response = await this.model.generateContent(prompt);
+            const text = response.response.text();
+            // Parse response
+            const validMatch = text.match(/VALID:\s*(yes|no)/i);
+            const reasoningMatch = text.match(/REASONING:\s*(.+?)(?=SUGGESTIONS:|$)/s);
+            const suggestionsMatch = text.match(/SUGGESTIONS:\s*(.+?)$/s);
+            const isValid = validMatch?.[1].toLowerCase() === 'yes';
+            const reasoning = reasoningMatch?.[1].trim() || 'No reasoning provided';
+            const suggestions = suggestionsMatch?.[1]
+                ? suggestionsMatch[1].split('\n').map((s) => s.trim()).filter(Boolean)
+                : [];
+            return {
+                isValid,
+                reasoning,
+                suggestions: suggestions.length > 0 ? suggestions : undefined
+            };
+        }
+        catch (e) {
+            // If critic fails, assume valid to not block the agent
+            return {
+                isValid: true,
+                reasoning: `Critic failed: ${e.message}`,
+            };
+        }
+    }
+    async validateToolChoice(userRequest, availableTools, chosenTool, toolArgs) {
+        const prompt = `You are a tool-choice critic.
+
+**USER REQUEST:** ${userRequest}
+**AVAILABLE TOOLS:** ${availableTools.join(', ')}
+**CHOSEN TOOL:** ${chosenTool}
+**ARGS:** ${JSON.stringify(toolArgs)}
+
+Is this the right tool for the job?
+
+OUTPUT FORMAT:
+CORRECT: yes/no
+BETTER_TOOL: [if no, suggest better tool]`;
+        try {
+            const response = await this.model.generateContent(prompt);
+            const text = response.response.text();
+            const correctMatch = text.match(/CORRECT:\s*(yes|no)/i);
+            const betterToolMatch = text.match(/BETTER_TOOL:\s*(\w+)/);
+            return {
+                isCorrect: correctMatch?.[1].toLowerCase() === 'yes',
+                betterTool: betterToolMatch?.[1] || undefined
+            };
+        }
+        catch {
+            return { isCorrect: true }; // Default to accepting on error
+        }
+    }
+}

package/dist/utils/DecisionLogger.js

@@ -0,0 +1,156 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class DecisionLogger {
+    constructor() {
+        this.decisions = [];
+        const logDir = path.join(process.cwd(), '.camo', 'logs');
+        this.logPath = path.join(logDir, 'decisions.jsonl');
+        this.humanLogPath = path.join(logDir, 'decisions-human.log');
+        this.ensureLogDir();
+    }
+    static getInstance() {
+        if (!DecisionLogger.instance) {
+            DecisionLogger.instance = new DecisionLogger();
+        }
+        return DecisionLogger.instance;
+    }
+    async ensureLogDir() {
+        try {
+            await fs.mkdir(path.dirname(this.logPath), { recursive: true });
+        }
+        catch (e) { /* ignore */ }
+    }
+    /**
+     * Log a decision (machine-readable)
+     */
+    async logDecision(decision) {
+        this.decisions.push(decision);
+        try {
+            // Append to JSONL file
+            const jsonLine = JSON.stringify(decision) + '\n';
+            await fs.appendFile(this.logPath, jsonLine, 'utf-8');
+            // Also write human-readable format
+            await this.logHumanReadable(decision);
+        }
+        catch (e) {
+            console.error('Failed to log decision:', e);
+        }
+    }
+    /**
+     * Log in human-readable format
+     */
+    async logHumanReadable(decision) {
+        const timestamp = new Date(decision.timestamp).toISOString();
+        const humanLog = `
+[${timestamp}] [${decision.type.toUpperCase()}]
+  Context: ${decision.context}
+  Reasoning: ${decision.reasoning}
+  Action: ${decision.action}
+  ${decision.alternatives ? `Alternatives: ${decision.alternatives.join(', ')}` : ''}
+  ${decision.result ? `Result: ${decision.result}` : ''}
+---
+`;
+        try {
+            await fs.appendFile(this.humanLogPath, humanLog, 'utf-8');
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    /**
+     * Log tool choice decision
+     */
+    async logToolChoice(sessionId, context, chosenTool, reasoning, alternatives) {
+        await this.logDecision({
+            timestamp: Date.now(),
+            sessionId,
+            type: 'tool_choice',
+            context,
+            reasoning,
+            action: `Chose tool: ${chosenTool}`,
+            alternatives
+        });
+    }
+    /**
+     * Log strategy decision
+     */
+    async logStrategy(sessionId, context, strategy, reasoning) {
+        await this.logDecision({
+            timestamp: Date.now(),
+            sessionId,
+            type: 'strategy',
+            context,
+            reasoning,
+            action: strategy
+        });
+    }
+    /**
+     * Log verification step
+     */
+    async logVerification(sessionId, context, checkPerformed, result) {
+        await this.logDecision({
+            timestamp: Date.now(),
+            sessionId,
+            type: 'verification',
+            context,
+            reasoning: `Verifying: ${checkPerformed}`,
+            action: checkPerformed,
+            result
+        });
+    }
+    /**
+     * Log error recovery
+     */
+    async logErrorRecovery(sessionId, error, recoveryAction, reasoning) {
+        await this.logDecision({
+            timestamp: Date.now(),
+            sessionId,
+            type: 'error_recovery',
+            context: `Error: ${error}`,
+            reasoning,
+            action: recoveryAction
+        });
+    }
+    /**
+     * Get recent decisions
+     */
+    getRecentDecisions(count = 10) {
+        return this.decisions.slice(-count);
+    }
+    /**
+     * Generate a summary report
+     */
+    async generateReport(sessionId) {
+        const sessionDecisions = this.decisions.filter(d => d.sessionId === sessionId);
+        if (sessionDecisions.length === 0) {
+            return 'No decisions logged for this session.';
+        }
+        let report = `DECISION REPORT - Session: ${sessionId}\n`;
+        report += `Total Decisions: ${sessionDecisions.length}\n\n`;
+        const byType = sessionDecisions.reduce((acc, d) => {
+            acc[d.type] = (acc[d.type] || 0) + 1;
+            return acc;
+        }, {});
+        report += 'Decisions by Type:\n';
+        Object.entries(byType).forEach(([type, count]) => {
+            report += `  ${type}: ${count}\n`;
+        });
+        report += '\n\nRecent Decisions:\n';
+        sessionDecisions.slice(-5).forEach((d, i) => {
+            const time = new Date(d.timestamp).toLocaleTimeString();
+            report += `\n[${time}] ${d.type}\n`;
+            report += `  Context: ${d.context}\n`;
+            report += `  Action: ${d.action}\n`;
+            if (d.reasoning) {
+                report += `  Reasoning: ${d.reasoning}\n`;
+            }
+        });
+        return report;
+    }
+    /**
+     * Clear decisions (for new session)
+     */
+    clearDecisions() {
+        this.decisions = [];
+    }
+}