orquesta-cli 0.2.45 → 0.2.46

package/dist/prompts/system/plan-execute.js

@@ -1,83 +1,76 @@
 import { LANGUAGE_PRIORITY_RULE } from '../shared/language-rules.js';
-import { AVAILABLE_TOOLS_WITH_TODO, TOOL_REASON_GUIDE } from '../shared/tool-usage.js';
 import { CODEBASE_FIRST_RULE } from '../shared/codebase-rules.js';
-export const PLAN_EXECUTE_SYSTEM_PROMPT = `You are an AI assistant executing a TODO-based plan.
+export const PLAN_EXECUTE_SYSTEM_PROMPT = `You are Orquesta, an expert AI coding assistant working in the user's terminal. You write correct, production-quality code and help with any development task.
 
 ${LANGUAGE_PRIORITY_RULE}
 
-## TODO Workflow
+## How You Work
 
-1. Work through TODOs systematically
-2. Update status using \`write_todos\` (include ALL todos with current status)
-3. **DONE when ALL TODOs are "completed"**
+1. **Understand first** — Read relevant code before modifying it. Never guess file contents.
+2. **Act, don't describe** — Use tools to do the work. Don't say "I would do X", just do X.
+3. **Verify your changes** — After edits, run the build/tests if available to confirm nothing broke.
+4. **Be concise** — Short answers for simple questions. Thorough work for complex tasks.
+5. **Match the user's intent** — Do what was asked, no more. Don't add unrequested features or refactors.
 
-**CRITICAL: Keep TODO status in sync with your actual progress!**
-- When starting a task → mark it "in_progress" IMMEDIATELY
-- When finishing a task → mark it "completed" IMMEDIATELY
-- The user sees the TODO list in real-time - mismatched status is confusing
-- Call \`write_todos\` FREQUENTLY, not just at the end
+## Decision Framework
 
-${AVAILABLE_TOOLS_WITH_TODO}
+- **Simple questions** (what is X, explain Y): Respond directly with knowledge.
+- **Code tasks** (fix, add, edit, refactor): Read → Edit → Verify. Use tools.
+- **Investigation** (why is this failing, what does X do): Read code, search, then explain.
+- **Ambiguous requests**: Infer the most useful action and proceed. Only ask if truly blocked.
 
-${TOOL_REASON_GUIDE}
+## Tool Usage
 
-## Execution Rules
+Use tools for all file operations, commands, and code changes. Your available tools:
+- **read_file**: Always read before editing
+- **edit_file**: Modify existing files (match exact content for old_string)
+- **create_file**: Create new files
+- **list_files** / **find_files** / **search_content**: Navigate the codebase
+- **bash**: Run commands (build, test, git, etc.)
+- **tell_to_user**: Show progress updates
+- **write_todos**: Track task progress (for multi-step work)
 
-1. **Read before modify** - Always read existing code first
-2. **Use tools** - Perform actual work, don't just describe
-3. **Retry on error** - Up to 3 attempts before marking "failed"
-4. **Stay focused** - Only work on TODOs, no unrelated features
+Every tool has a "reason" parameter shown to the user. Write it naturally in the user's language.
 
-${CODEBASE_FIRST_RULE}
-
-## CRITICAL: Tool Error Handling
-
-**If a tool returns an error, you MUST retry the same tool with corrected parameters.**
+## Code Quality Rules
 
-1. STOP - Read the error message carefully
-2. Investigate - Use \`read_file\` to check actual file content
-3. **RETRY THE SAME TOOL** with corrected parameters (DO NOT skip or move on)
-4. Repeat until success or 3 failures
+- Write minimal, correct code that solves the problem
+- Follow existing project conventions (style, naming, patterns)
+- Use secure coding practices by default
+- Don't introduce new dependencies unless necessary
+- Include error handling where appropriate
 
-**You are NOT allowed to:**
-- Skip the failed tool and move to next task
-- Say "I'll try a different approach" without actually retrying
-- Mark TODO as complete if the tool failed
+## Error Handling
 
-Example flow:
-1. \`edit_file\` fails: "Line 77 content does not match"
-2. Call \`read_file\` to see actual content
-3. **Call \`edit_file\` again** with correct \`old_string\`
-4. Only proceed after edit succeeds
+If a tool fails:
+1. Read the error carefully
+2. Investigate (read_file to check actual content)
+3. Retry with corrected parameters
+4. Only give up after 3 failed attempts
 
-## CRITICAL: When to Respond
+Common edit_file failures: wrong old_string → re-read file, copy exact text, retry.
 
-**ONLY respond when ALL TODOs are "completed" or "failed".**
-
-- Responding early = execution ends prematurely
-- Use \`tell_to_user\` to communicate progress during execution
-- \`write_todos\` only updates internal state
-
-**Before final response, verify:**
-- All TODOs completed?
-- All tool calls successful?
-- User's request fulfilled?
+${CODEBASE_FIRST_RULE}
 
-## CRITICAL: Final Response
+## Response Style
 
-Your final response MUST contain the **actual answer or result**:
-- Question → Answer with information found
-- Task → Summarize what was done
+- Direct and concise. No filler phrases.
+- Code in markdown blocks with language tags.
+- When summarizing completed work: state what was done in 1-3 sentences.
+- Match the user's language (if they write in Spanish, respond in Spanish).
 
-**DO NOT** just say "Task complete" or give task statistics.
+## TODO Workflow (for multi-step tasks)
 
-Example:
-- User: "What's the project name?" → "This project is **LOCAL-CLI**."
-- User: "Add a debug function" → "Added debug function to logger.ts."
+When working on a plan with TODOs:
+- Update status via write_todos as you progress
+- Mark "in_progress" when starting, "completed" when done
+- Stay focused on the current task
 
-## Loop Detection
+## IMPORTANT
 
-If TODO context keeps repeating but work is done → IMMEDIATELY mark all as "completed".
+- You can respond directly without using any tool — do so for simple questions or when you're done working.
+- After completing all requested work, give a brief summary of what was done.
+- Never fabricate file contents, paths, or command outputs. If unsure, investigate first.
 `;
 export default PLAN_EXECUTE_SYSTEM_PROMPT;
 //# sourceMappingURL=plan-execute.js.map

package/dist/tools/llm/simple/file-tools.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { logger } from '../../../utils/logger.js';
+import { shouldIgnore } from '../../../core/ignore-filter.js';
 const EXCLUDED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -451,6 +452,9 @@ async function getFilesRecursively(dirPath, baseDir = dirPath, depth = 0, fileCo
         }
         const fullPath = path.join(dirPath, entry.name);
         const relativePath = path.relative(baseDir, fullPath);
+        if (shouldIgnore(fullPath)) {
+            continue;
+        }
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name)) {
                 continue;
@@ -491,7 +495,9 @@ async function _executeListFilesInternal(args) {
         }
         else {
             const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
-            const files = entries.map((entry) => ({
+            const files = entries
+                .filter(entry => !shouldIgnore(path.join(resolvedPath, entry.name)))
+                .map((entry) => ({
                 name: entry.name,
                 type: entry.isDirectory() ? 'directory' : 'file',
                 path: path.join(directoryPath, entry.name),
@@ -580,6 +586,9 @@ async function findFilesRecursively(dirPath, regex, baseDir, depth = 0, fileCoun
             continue;
         }
         const fullPath = path.join(dirPath, entry.name);
+        if (shouldIgnore(fullPath)) {
+            continue;
+        }
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name)) {
                 continue;
@@ -700,6 +709,8 @@ async function searchContentRecursively(dirPath, searchRegex, baseDir, fileRegex
         if (entry.name.startsWith('.'))
             continue;
         const fullPath = path.join(dirPath, entry.name);
+        if (shouldIgnore(fullPath))
+            continue;
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name))
                 continue;

package/dist/tools/llm/simple/final-response-tool.js

@@ -1,4 +1,5 @@
 import { logger } from '../../../utils/logger.js';
+import { eventBus, Events } from '../../../core/event-bus.js';
 let getTodosCallback = null;
 let finalResponseCallback = null;
 let markTodosCompletedCallback = null;
@@ -28,23 +29,16 @@ const FINAL_RESPONSE_DEFINITION = {
     type: 'function',
     function: {
         name: 'final_response',
-        description: `Use this tool to deliver your final response to the user after completing all tasks.
+        description: `Deliver a final summary to the user after completing work. Optional — you can also respond directly without this tool.
 
-IMPORTANT:
-- You MUST complete all TODOs before calling this tool
-- If any TODO is not completed, this tool will return an error
-- After all tasks are done, use this tool to summarize what was accomplished
-
-Example:
-{
-  "message": "I've completed all the requested tasks:\\n\\n1. Fixed the bug in the login form\\n2. Added input validation\\n3. Updated the tests\\n\\nAll changes have been committed."
-}`,
+Use this when you want to explicitly signal task completion with a summary.
+Any incomplete TODOs will be auto-marked as done.`,
         parameters: {
             type: 'object',
             properties: {
                 message: {
                     type: 'string',
-                    description: 'Your final response message to the user. Summarize what was accomplished.',
+                    description: 'Your final response message to the user.',
                 },
             },
             required: ['message'],
@@ -138,6 +132,7 @@ async function executeFinalResponse(args) {
         if (finalResponseCallback) {
             finalResponseCallback(message);
         }
+        eventBus.emit(Events.FINAL_RESPONSE, message);
         return {
             success: true,
             result: message,
@@ -163,6 +158,7 @@ async function executeFinalResponse(args) {
     if (finalResponseCallback) {
         finalResponseCallback(message);
     }
+    eventBus.emit(Events.FINAL_RESPONSE, message);
     return {
         success: true,
         result: message,

package/dist/tools/registry.js

@@ -9,10 +9,33 @@ import { PLANNING_TOOLS } from './llm/simple/planning-tools.js';
 import { FinalResponseTool } from './llm/simple/final-response-tool.js';
 import { RemotePhoneTool } from './llm/simple/remote-phone-tool.js';
 import { getShellTools } from './llm/simple/index.js';
-import { BROWSER_TOOLS, startBrowserServer, shutdownBrowserServer } from './browser/index.js';
-import { WORD_TOOLS, EXCEL_TOOLS, POWERPOINT_TOOLS } from './office/index.js';
+let _browserTools = null;
+let _startBrowserServer = null;
+let _shutdownBrowserServer = null;
+async function getBrowserModule() {
+    if (!_browserTools) {
+        const mod = await import('./browser/index.js');
+        _browserTools = mod.BROWSER_TOOLS;
+        _startBrowserServer = mod.startBrowserServer;
+        _shutdownBrowserServer = mod.shutdownBrowserServer;
+    }
+    return { BROWSER_TOOLS: _browserTools, startBrowserServer: _startBrowserServer, shutdownBrowserServer: _shutdownBrowserServer };
+}
+let _wordTools = null;
+let _excelTools = null;
+let _powerpointTools = null;
+async function getOfficeModule() {
+    if (!_wordTools) {
+        const mod = await import('./office/index.js');
+        _wordTools = mod.WORD_TOOLS;
+        _excelTools = mod.EXCEL_TOOLS;
+        _powerpointTools = mod.POWERPOINT_TOOLS;
+    }
+    return { WORD_TOOLS: _wordTools, EXCEL_TOOLS: _excelTools, POWERPOINT_TOOLS: _powerpointTools };
+}
 async function validateBrowserTools() {
     try {
+        const { startBrowserServer } = await getBrowserModule();
         await startBrowserServer();
         return { success: true };
     }
@@ -29,10 +52,19 @@ function getOptionalToolGroupsConfig() {
             id: 'browser',
             name: 'Browser Automation',
             description: 'Control Chrome/Edge browser for web testing (navigate, click, screenshot, etc.)',
-            tools: BROWSER_TOOLS,
+            tools: [],
             enabled: false,
-            onEnable: validateBrowserTools,
-            onDisable: shutdownBrowserServer,
+            onEnable: async () => {
+                const { BROWSER_TOOLS } = await getBrowserModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'browser');
+                if (group)
+                    group.tools = BROWSER_TOOLS;
+                return validateBrowserTools();
+            },
+            onDisable: async () => {
+                const { shutdownBrowserServer } = await getBrowserModule();
+                await shutdownBrowserServer();
+            },
         },
     ];
     if (hasWindowsAccess()) {
@@ -40,20 +72,41 @@ function getOptionalToolGroupsConfig() {
             id: 'word',
             name: 'Microsoft Word',
             description: 'Control Word for document editing (write, read, save, export PDF, header/footer)',
-            tools: WORD_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { WORD_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'word');
+                if (group)
+                    group.tools = WORD_TOOLS;
+                return { success: true };
+            },
         }, {
             id: 'excel',
             name: 'Microsoft Excel',
             description: 'Control Excel for spreadsheet editing (cells, ranges, formulas, charts)',
-            tools: EXCEL_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { EXCEL_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'excel');
+                if (group)
+                    group.tools = EXCEL_TOOLS;
+                return { success: true };
+            },
         }, {
             id: 'powerpoint',
             name: 'Microsoft PowerPoint',
             description: 'Control PowerPoint for presentations (slides, shapes, transitions, PDF export)',
-            tools: POWERPOINT_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { POWERPOINT_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'powerpoint');
+                if (group)
+                    group.tools = POWERPOINT_TOOLS;
+                return { success: true };
+            },
         });
     }
     return groups;
@@ -138,9 +191,9 @@ class ToolRegistry {
             logger.error('Tool group not found', { groupId });
             return { success: false, error: `Tool group '${groupId}' not found` };
         }
-        if (!skipValidation && group.onEnable) {
+        if (group.onEnable) {
             const result = await group.onEnable();
-            if (!result.success) {
+            if (!skipValidation && !result.success) {
                 return result;
             }
         }

package/dist/ui/components/PlanExecuteApp.d.ts

@@ -17,6 +17,7 @@ interface PlanExecuteAppProps {
         model: string;
         endpoint: string;
     };
+    resumeLastSession?: boolean;
 }
 export declare const PlanExecuteApp: React.FC<PlanExecuteAppProps>;
 export default PlanExecuteApp;

package/dist/ui/components/PlanExecuteApp.js

@@ -38,6 +38,7 @@ import { readHookConfig } from '../../orquesta/hook-init.js';
 import { remotePhone } from '../../orquesta/remote-phone.js';
 import { logger } from '../../utils/logger.js';
 import { usageTracker } from '../../core/usage-tracker.js';
+import { estimateCost, formatCostUsd } from '../../core/pricing.js';
 import { UpdateNotification } from '../UpdateNotification.js';
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../../utils/update-checker.js';
 import { setToolExecutionCallback, setTellToUserCallback, setToolResponseCallback, setPlanCreatedCallback, setTodoStartCallback, setTodoCompleteCallback, setTodoFailCallback, setCompactCallback, setAssistantResponseCallback, setToolApprovalCallback, setReasoningCallback, } from '../../tools/llm/simple/file-tools.js';
@@ -88,7 +89,7 @@ function getStatusText({ phase, todos, currentToolName }) {
     }
     return `${progressPrefix}Processing`;
 }
-export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
+export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeLastSession }) => {
     const { exit } = useApp();
     const hookBinding = useMemo(() => {
         const cfg = readHookConfig(process.cwd());
@@ -103,6 +104,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     const [messages, setMessages] = useState([]);
     const { input, setInput, handleHistoryPrev, handleHistoryNext, addToHistory } = useInputHistory();
     const [isProcessing, setIsProcessing] = useState(false);
+    const [streamingText, setStreamingText] = useState('');
     const [updatePhase, setUpdatePhase] = useState('hidden');
     const [updateLatest, setUpdateLatest] = useState('');
     const [updateProgress, setUpdateProgress] = useState('');
@@ -168,6 +170,21 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     useEffect(() => {
         sessionManager.setLogEntries(logEntries);
     }, [logEntries]);
+    useEffect(() => {
+        if (!resumeLastSession)
+            return;
+        (async () => {
+            const sessions = await sessionManager.listSessions();
+            if (sessions.length === 0)
+                return;
+            const last = sessions[0];
+            const data = await sessionManager.loadSession(last.id);
+            if (data && data.messages.length > 0) {
+                setMessages(data.messages);
+                addLog({ type: 'session_restored', content: `↩ Resumed session (${data.messages.filter(m => m.role === 'user').length} messages)` });
+            }
+        })();
+    }, [resumeLastSession]);
     const fileBrowserState = useFileBrowserState(input, isProcessing);
     const commandBrowserState = useCommandBrowserState(input, isProcessing);
     const planExecutionState = usePlanExecution(pendingMessageCallbacks);
@@ -261,6 +278,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     }, [addLog]);
     useEffect(() => {
         setAssistantResponseCallback((content) => {
+            setStreamingText('');
             addLog({
                 type: 'assistant_message',
                 content,
@@ -271,6 +289,17 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
             setAssistantResponseCallback(null);
         };
     }, [addLog]);
+    useEffect(() => {
+        if (llmClient) {
+            llmClient.onStreamingContent = (token) => {
+                setStreamingText(prev => prev + token);
+            };
+        }
+        return () => {
+            if (llmClient)
+                llmClient.onStreamingContent = null;
+        };
+    }, [llmClient]);
     useEffect(() => {
         setReasoningCallback((content, _isStreaming) => {
             addLog({
@@ -432,29 +461,30 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
             logger.startTimer('app-init');
             try {
                 setInitStep('health');
-                logger.flow('Running health check');
+                logger.flow('Running health check + docs init in parallel');
                 setHealthStatus('checking');
-                if (configManager.hasEndpoints()) {
-                    const healthResults = await LLMClient.healthCheckAll();
-                    let hasHealthy = false;
-                    for (const [endpointId, modelResults] of healthResults) {
-                        logger.vars({ name: 'endpointId', value: endpointId }, { name: 'healthyModels', value: modelResults.filter(r => r.healthy).length });
-                        if (modelResults.some((r) => r.healthy)) {
-                            hasHealthy = true;
+                const healthPromise = (async () => {
+                    if (configManager.hasEndpoints()) {
+                        const healthResults = await LLMClient.healthCheckAll();
+                        let hasHealthy = false;
+                        for (const [endpointId, modelResults] of healthResults) {
+                            logger.vars({ name: 'endpointId', value: endpointId }, { name: 'healthyModels', value: modelResults.filter(r => r.healthy).length });
+                            if (modelResults.some((r) => r.healthy)) {
+                                hasHealthy = true;
+                            }
                         }
+                        logger.state('Health status', 'checking', hasHealthy ? 'healthy' : 'unhealthy');
+                        setHealthStatus(hasHealthy ? 'healthy' : 'unhealthy');
+                        await configManager.updateAllHealthStatus(healthResults);
                     }
-                    logger.state('Health status', 'checking', hasHealthy ? 'healthy' : 'unhealthy');
-                    setHealthStatus(hasHealthy ? 'healthy' : 'unhealthy');
-                    await configManager.updateAllHealthStatus(healthResults);
-                }
-                else {
-                    setHealthStatus('unknown');
-                }
-                setInitStep('docs');
-                logger.flow('Initializing docs directory');
-                await initializeDocsDirectory().catch((err) => {
+                    else {
+                        setHealthStatus('unknown');
+                    }
+                })();
+                const docsPromise = initializeDocsDirectory().catch((err) => {
                     logger.warn('Docs directory initialization warning', { error: err });
                 });
+                await Promise.all([healthPromise, docsPromise]);
                 setInitStep('config');
                 logger.flow('Checking configuration');
                 if (!configManager.hasEndpoints()) {
@@ -938,6 +968,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
         let updatedMessages = [...messages, userMsg];
         setMessages(updatedMessages);
         setIsProcessing(true);
+        setStreamingText('');
         setActivityStartTime(Date.now());
         setSubActivities([]);
         if (llmClient) {
@@ -1389,8 +1420,10 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
         React.createElement(Static, { items: logEntries }, (entry) => renderLogEntry(entry)),
         pendingToolApproval && (React.createElement(Box, { marginY: 1 },
             React.createElement(ApprovalDialog, { toolName: pendingToolApproval.toolName, args: pendingToolApproval.args, reason: pendingToolApproval.reason, onResponse: handleApprovalResponse }))),
-        isProcessing && (planExecutionState.executionPhase === 'planning' || planExecutionState.todos.length === 0) && !pendingToolApproval && !isDocsSearching && (React.createElement(Box, { marginY: 1 },
-            React.createElement(ActivityIndicator, { activity: getCurrentActivityType(), startTime: activityStartTime, detail: activityDetail, subActivities: subActivities, modelName: currentModelInfo.model }))),
+        isProcessing && (planExecutionState.executionPhase === 'planning' || planExecutionState.todos.length === 0) && !pendingToolApproval && !isDocsSearching && (React.createElement(Box, { marginY: 1, flexDirection: "column" },
+            React.createElement(ActivityIndicator, { activity: getCurrentActivityType(), startTime: activityStartTime, detail: activityDetail, subActivities: subActivities, modelName: currentModelInfo.model }),
+            streamingText && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
+                React.createElement(Text, { wrap: "wrap" }, streamingText))))),
         isDocsSearching && (React.createElement(DocsSearchProgress, { logs: docsSearchLogs, isSearching: isDocsSearching })),
         planExecutionState.todos.length > 0 && (React.createElement(Box, { marginTop: 2, marginBottom: 1 },
             React.createElement(TodoPanel, { todos: planExecutionState.todos, currentTodoId: planExecutionState.currentTodoId, isProcessing: isProcessing }))),
@@ -1458,7 +1491,11 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
                         ' ',
                         "(esc to interrupt \u00B7 ",
                         formatElapsedTime(sessionElapsed),
-                        sessionTokens > 0 && ` · ↑ ${formatTokensCompact(sessionTokens)} tokens`,
+                        sessionTokens > 0 && (() => {
+                            const usage = usageTracker.getSessionUsage();
+                            const cost = estimateCost(currentModelInfo.model, usage.inputTokens, usage.outputTokens);
+                            return ` · ↑ ${formatTokensCompact(sessionTokens)} tokens${cost ? ` · ${formatCostUsd(cost)}` : ''}`;
+                        })(),
                         ")"))),
             React.createElement(Box, null,
                 (() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",
@@ -11,14 +11,16 @@
   "scripts": {
     "preinstall": "node scripts/check-node.cjs",
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "postbuild": "chmod +x dist/cli.js",
-    "dev": "ts-node src/cli.ts",
+    "dev": "tsx watch src/cli.ts",
     "start": "node dist/cli.js",
     "watch": "tsc --watch",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "eslint src/**/*.ts --fix",
     "format": "prettier --write \"src/**/*.ts\"",
-    "test": "cd tests && python -m pytest test_eval.py -v",
+    "test:eval": "cd tests && python -m pytest test_eval.py -v",
     "test:quick": "cd tests && python -m pytest test_eval.py -v -m 'not slow'",
     "prepr": "npm run lint && npm run build",
     "bun:build": "node scripts/inject-version.js && npm run build && bun build dist/cli.js --compile --outfile bin/lcli && cp node_modules/yoga-wasm-web/dist/yoga.wasm bin/",
@@ -126,7 +128,9 @@
     "react-devtools-core": "^4.28.5",
     "react-dom": "^18.3.1",
     "ts-node": "^10.9.2",
+    "tsx": "^4.19.0",
     "typescript": "^5.3.3",
-    "vite": "^7.3.1"
+    "vite": "^7.3.1",
+    "vitest": "^3.2.1"
   }
 }