@vierratale/ai 0.1.0-beta.11 → 0.1.0-beta.13

package/README.md

@@ -4,11 +4,20 @@ Intelligent terminal assistant that runs AI models locally and in the cloud.
 
 ## Install
 
+Install requirements and run from source:
+
 ```bash
-# From npm
-npm install -g @vierratale/ai
+git clone <your-repo-url>/vierratale-ai.git
+cd vierratale-ai
+
+./install.sh --node   # installs requirements + links the commands
+vierratale             # start chatting
+```
 
-# Or run directly
+Or run directly from npm:
+
+```bash
+npm install -g @vierratale/ai
 npx @vierratale/ai
 ```
 

package/bin/vierrataleai.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // VierrataleAI launcher + installer.
 //
-// Running without flags starts the assistant (same as before).
-// Running with --install (or --setup / install) installs the engine + model and
-// creates a global "vierrataleai" command, then starts the assistant.
+// Running without flags starts the assistant and auto-detects dependencies:
+// if the AI engine (ollama) or the model is missing, they are installed first.
+// Running with --install (or --setup / install) additionally creates a global
+// "vierrataleai" / "vierratale" command, then starts the assistant.
 //
 // Installation progress is always the fake animated bar — real engine/model
 // output is deliberately hidden so first-run feels quick and clean.
@@ -12,6 +13,7 @@ import { Installer } from '../src/installer.js';
 import { Config } from '../src/config.js';
 import { Branding } from '../src/ui/branding.js';
 import { Terminal } from '../src/ui/terminal.js';
+import { dirname } from 'path';
 
 const C = Branding.colors;
 
@@ -23,6 +25,8 @@ const INSTALL_STEPS = [
   'Optimizing for this device',
 ];
 
+const READY_STEPS = ['Checking engine', 'Installing dependencies', 'Downloading model', 'Optimizing'];
+
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -53,6 +57,7 @@ async function fakeProgress(steps, work) {
 async function main() {
   const args = process.argv.slice(2);
   const doInstall = args.includes('--install') || args.includes('--setup') || args.includes('install');
+  const quick = args.includes('--version') || args.includes('-v') || args.includes('--help') || args.includes('-h');
 
   Config.load();
 
@@ -60,11 +65,18 @@ async function main() {
     console.log(`\n  ${C.bold}${C.primary}${Branding.APP_NAME} ${Branding.VERSION}${C.reset} ${C.dim}— installer${C.reset}\n`);
     const result = await fakeProgress(INSTALL_STEPS, Installer.install());
     if (!result.command) {
-      Terminal.printInfo('Could not create a global "vierrataleai" command; run it via the bin script.');
+      Terminal.printInfo('Could not create a global command; run it via the bin script.');
     } else {
-      Terminal.printSuccess(`Engine + model installed; "vierrataleai" command available at ${result.command}`);
+      Terminal.printSuccess(`Engine + model installed; "vierrataleai" (or "vierratale") command available at ${result.commandAlias || result.command}`);
+      if (!result.commandOnPath) {
+        Terminal.printInfo(`"vierrataleai" won't resolve in a new shell: add ${dirname(result.command)} to PATH, e.g. export PATH="$HOME/.local/bin:$PATH", then reopen the terminal.`);
+      }
     }
     console.log();
+  } else if (!quick) {
+    // Auto-detect: install anything that's missing (engine, model) before starting.
+    await fakeProgress(READY_STEPS, Installer.ensure());
+    console.log();
   }
 
   return run();

package/package.json

@@ -1,31 +1,30 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.11",
+  "version": "0.1.0-beta.13",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
-  "files": [
-    "bin/",
-    "scripts/",
-    "src/",
-    "README.md"
-  ],
-  "bin": {
-    "vierrataleai": "./bin/vierrataleai.js"
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
   },
-  "main": "./src/index.js",
-  "exports": {
-    ".": "./src/index.js"
+  "bin": {
+    "vierrataleai": "./bin/vierrataleai.js",
+    "vierratale": "./bin/vierrataleai.js"
   },
   "scripts": {
-    "start": "node bin/vierrataleai.js",
-    "test": "node --test \"test/*.test.js\"",
     "postinstall": "node scripts/postinstall.js"
   },
-  "keywords": ["ai", "chatbot", "terminal", "assistant", "llm"],
-  "author": "Vierratale",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {}
-}
+  "files": [
+    "bin",
+    "src",
+    "scripts",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "chatbot",
+    "terminal",
+    "assistant",
+    "llm"
+  ]
+}

package/src/cli.js

@@ -18,6 +18,7 @@ import { Session } from './session.js';
 import { ChatUI, FrameThrottle } from './ui/chatbox.js';
 import { logger } from './utils/logger.js';
 import { runWithTools, TOOL_RESULTS_PROMPT, looksLikeOperationRequest } from './cmd/agent.js';
+import { loadTodos, addTodo, updateTodo, clearTodos, saveTodos, formatTodos, todosFile } from './cmd/todos.js';
 
 function parseArgs(args) {
   const parsed = { provider: null, model: null, clear: false, version: false, help: false, install: false };
@@ -46,6 +47,8 @@ Options:
   --version, -v           Show version
   --help, -h              Show this help
 
+Missing dependencies (engine + model) are installed automatically on start.
+
 Commands (in chat):
   /help                   Show commands
   /model [name]           Switch model
@@ -54,6 +57,7 @@ Commands (in chat):
   /search <query>         Search the web and summarize with AI
   /fetch <url>            Open a link and summarize its content
   /download <url>         Download a file, folder listing or archive
+  /todos                  List the todo list (add <text> | done/undone <n> | clear)
   /log [n|path]           Show the last n log entries (default 30), or the log file path
   /clear                  Clear screen
   /new                    Start a new empty session (keeps old ones)
@@ -79,6 +83,7 @@ export const SLASH_COMMANDS = [
   { name: 'fetch', args: '<url>', desc: 'Open a link and summarize' },
   { name: 'download', args: '<url>', desc: 'Download a file / folder / archive' },
   { name: 'system', desc: 'Show or set the system prompt' },
+  { name: 'todos', args: '[add <text> | done <n> | undone <n> | clear]', desc: 'Manage the todo list' },
   { name: 'sessions', desc: 'List saved sessions' },
   { name: 'session', args: 'new | open | delete | backup | restore', desc: 'Manage sessions' },
   { name: 'log', args: '[n | path]', desc: 'Show recent log entries' },
@@ -656,7 +661,7 @@ async function chat(provider, systemPrompt) {
     if (cmd === '/help') {
       chatUI.clearNotices();
       chatUI.notify(
-        `Commands:\n  /search <query> · /fetch <url> · /model [name] · /provider [name]\n  /models · /log [n|path] · /new · /sessions · /session new|open|delete|backup|restore\n  /clear · /help · /quit`
+        `Commands:\n  /search <query> · /fetch <url> · /model [name] · /provider [name]\n  /models · /todos · /log [n|path] · /new · /sessions · /session new|open|delete|backup|restore\n  /clear · /help · /quit`
       );
       chatUI.render(messages);
       continue;
@@ -977,6 +982,11 @@ async function chat(provider, systemPrompt) {
       continue;
     }
 
+    if (cmd === '/todos' || cmd.startsWith('/todos ')) {
+      handleTodosCommand(trimmed, chatUI, messages, process.cwd());
+      continue;
+    }
+
     const intent = detectIntent(trimmed);
     if (intent.type === 'self') {
       const model = Config.getEffectiveModel(provider.name);
@@ -1125,6 +1135,49 @@ async function ensureRawLocalModel(realModel, notify) {
 export { looksLikeFileRequest, requestedFileName, extractFallbackFile, storyFileName, responseWantsFile, responseIsSoloCode, languageFileName, fallbackHasUsefulCode, validateWrittenCode, looksLikeJunkCode, warnIfJunkCode, writeFilesFromResponse }; 
 // Command/tool layer: asks the model to plan filesystem/shell operations,
 // executes them with the sandboxed executor, then streams the final answer.
+function handleTodosCommand(trimmed, chatUI, messages, cwd) {
+  chatUI.clearNotices();
+  const rest = trimmed.slice('/todos'.length).trim();
+  let out;
+  if (!rest) {
+    out = `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^add\s+/i.test(rest)) {
+    const err = addTodo(cwd, rest.replace(/^add\s+/i, '').trim());
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^done\s+\d+$/i.test(rest)) {
+    const err = updateTodo(cwd, parseInt(rest.replace(/^done\s+/i, ''), 10), { done: true });
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^undone\s+\d+$/i.test(rest)) {
+    const err = updateTodo(cwd, parseInt(rest.replace(/^undone\s+/i, ''), 10), { done: false });
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else if (/^remove\s+\d+$/i.test(rest)) {
+    const n = parseInt(rest.replace(/^remove\s+/i, ''), 10);
+    const todos = loadTodos(cwd);
+    if (!Number.isInteger(n - 1) || n - 1 < 0 || n - 1 >= todos.length) {
+      out = `No todo #${n}.`;
+    } else {
+      const next = todos.filter((_, i) => i !== n - 1);
+      saveTodos(cwd, next);
+      out = `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+    }
+  } else if (/^clear$/i.test(rest)) {
+    clearTodos(cwd);
+    out = `Todos cleared (${todosFile(cwd)}). (no todos yet)`;
+  } else if (/^\d+$/.test(rest)) {
+    const n = parseInt(rest, 10);
+    const todos = loadTodos(cwd);
+    const err = (Number.isInteger(n - 1) && n - 1 >= 0 && n - 1 < todos.length)
+      ? updateTodo(cwd, n, { done: !todos[n - 1].done })
+      : { error: `No todo #${n}.` };
+    out = err && err.error ? err.error : `Todos (${todosFile(cwd)}):\n${formatTodos(loadTodos(cwd))}`;
+  } else {
+    out = 'Usage: /todos [add <text> | done <n> | undone <n> | remove <n> | <n> (toggle) | clear]';
+  }
+  chatUI.notify(out);
+  logger.log('CMD', `todos: ${rest || '(list)'}`);
+  chatUI.render(messages);
+}
+
 async function answerWithTools(messages, provider, requestText, systemPrompt, confirm, chatUI, cwd, timeoutMs) {
   let results = [];
   try {

package/src/cmd/agent.js

@@ -3,7 +3,8 @@ import { readFileSync } from 'node:fs';
 import { join } from 'path';
 import { Config } from '../config.js';
 import { logger } from '../utils/logger.js';
-import { makeExecutor, dispatchTool, TOOL_EXECUTORS } from './tools.js';
+import { renderFileTree } from '../utils/filetree.js';
+import { makeExecutor, dispatchTool, TOOL_EXECUTORS, pickPackageManager } from './tools.js';
 
 const MAX_PLANNING_ROUNDS = 3;
 const MAX_STEPS = 8;
@@ -19,14 +20,20 @@ Reply with EXACTLY ONE JSON array of the tool calls needed to do the job, in ord
 {"name":"list_directory","path":"."}
 {"name":"delete_file","path":"old.txt"}
 {"name":"download_url","url":"https://example.com/file.zip","dir":"downloads"}
+{"name":"todo_add","text":"install dependencies"}
+{"name":"todo_list"}
+{"name":"todo_update","index":1,"done":true}
+{"name":"todo_clear"}
 
 Rules:
-- run_command runs WITHOUT a shell. Allowed commands: mkdir touch ls pwd cat cp mv rm npm npx node python python3 git echo printf.
+- run_command runs WITHOUT a shell. Allowed commands: mkdir touch ls pwd cat cp mv rm npm npx node python python3 git echo printf apt apt-get pkg.
 - run_command supports arguments with spaces (quote them). No shell operators (&& | > ; etc.), no wildcards for rm, no inline -e/-c code for node/python, no paths outside the workspace.
 - To create a file containing code or text, ALWAYS use create_file (never echo/cat > …). Pass the full content in "content".
 - Prefer create_file over redirecting output.
 - If you need to create a folder first, plan create_directory before create_file inside it.
 - To download a file, web asset, archive or folder listing from the web, use download_url with the full URL. dir is optional (defaults to ~/Downloads).
+- To install a system package the user asked for, use run_command with pkg (Termux/Android) or apt/apt-get (Linux), e.g. {"name":"run_command","command":"pkg install -y curl wget"}. The -y/--yes confirm flag is added automatically — never use && or sudo.
+- For multi-step work, track your progress with todo_add/todo_list/todo_update (e.g. todo_add for each remaining subtask, todo_update to mark steps done).
 - Code you create must be runnable. For Python servers bind to 127.0.0.1, read PORT from the environment (default 8000), and fall back to a free port (port 0) when the default is taken. HTML/CSS/JS must be self-contained and reference each other by relative filename.
 - If NO tools are needed, reply exactly: NONE
 - Output the JSON array only — no prose, no markdown fences unless the array is inside them.`;
@@ -37,6 +44,20 @@ ${resultsJson}
 
 Give the user a short, natural reply (in the user's own language) telling them what happened. Keep the whole reply under 40 words. Do NOT tell them to run the commands yourself. If they asked for a file containing code and files were created with content, you may also emit FILE: blocks if more files are still required.`;
 
+// Auto error fixing: shown to the model when a tool call fails so it can emit
+// a corrected plan instead of giving up. Bounded by MAX_AUTO_FIXES per run.
+const MAX_AUTO_FIXES = 3;
+
+const TOOL_FIX_PROMPT = (call, result) => `A tool call made while working in the workspace FAILED. Fix the problem so the original request can complete.
+
+Failed tool call:
+${JSON.stringify(call, null, 2)}
+
+Failure:
+${JSON.stringify({ success: false, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr }, null, 2)}
+
+Emit a NEW tool plan (a JSON array of tool calls) that corrects the failure — for example re-create the file with the error fixed, run a command to repair it, or download/read what is missing. If your previous plan skipped a required step (like creating a parent folder), include it. Use todo tools to track remaining subtasks if useful. Reply with exactly one JSON array, or the single word NONE if no tool call can fix this.`;
+
 // ---------------------------------------------------------------------------
 // Request detection
 // ---------------------------------------------------------------------------
@@ -84,6 +105,18 @@ export function normalizeToolCall(raw) {
   } else if (name === 'download_url') {
     if (typeof raw.url !== 'string' || raw.url.trim() === '') return null;
     params = { url: raw.url, dir: typeof raw.dir === 'string' && raw.dir.trim() ? raw.dir.trim() : undefined };
+  } else if (name === 'todo_add') {
+    if (typeof raw.text !== 'string' || raw.text.trim() === '') return null;
+    params = { text: raw.text };
+  } else if (name === 'todo_update') {
+    if (!Number.isInteger(raw.index) && !/^\d+$/.test(String(raw.index ?? ''))) return null;
+    params = {
+      index: Number(raw.index),
+      done: typeof raw.done === 'boolean' ? raw.done : undefined,
+      text: typeof raw.text === 'string' && raw.text.trim() ? raw.text : undefined,
+    };
+  } else if (name === 'todo_list' || name === 'todo_clear') {
+    params = {};
   } else {
     return null;
   }
@@ -176,6 +209,24 @@ export function heuristicPlan(requestText) {
     return [{ name: 'run_command', params: { command: tail } }];
   }
 
+  // System package installs: explicit "pkg/apt install …" and generic
+  // "install <pkg>" requests ("pasang curl", "install wget").
+  const pkgInstall = /\b(pkg|apt-get|apt)\s+(install|i|add)\s+(.+)$/i.exec(text);
+  if (pkgInstall) {
+    const pkgs = pkgInstall[3].trim().split(/\s+/).slice(0, 8).filter((p) => /^[a-z0-9][a-z0-9.+_~-]*$/i.test(p));
+    if (pkgs.length) return [{ name: 'run_command', params: { command: `${pkgInstall[1]} install ${pkgs.join(' ')}` } }];
+  }
+  const INSTALL_BLOCKED = new Set(['project', 'proyek', 'folder', 'direktori', 'file', 'berkas', 'code', 'kode', 'dependencies', 'dependensi', 'app', 'aplikasi', 'gui', 'the', 'a', 'an', 'for', 'to', 'in', 'on', 'from', 'with', 'and', 'dan', 'lalu', 'semua', 'ini', 'itu', 'now', 'please', 'tolong']);
+  const genericInstall = /\b(install|pasang|installkan|menginstall|menginstal|set\s*up|setup)\b/i.exec(text);
+  const devInstallSpeak = /node modules|modules|dependenc\w*|package\.json|requirements(\.txt)?|virtualenv|pip\b|cargo\b|go get\b/gi;
+  if (genericInstall && !/\b(npm|yarn|pnpm|npx|bun|pip|pip3|uv|conda|apt|pkg)\b/i.test(text) && !devInstallSpeak.test(text)) {
+    const target = text.match(/\b(install|pasang|installkan|menginstall|menginstal|set\s*up|setup)\b\s+(?:(the|a|an|package|paket|tool|alat|program|utility|latest)\s+)?([a-z0-9][a-z0-9.+_~-]{1,63})\b/i);
+    if (target && !INSTALL_BLOCKED.has(target[3].toLowerCase())) {
+      const manager = pickPackageManager();
+      return [{ name: 'run_command', params: { command: `${manager} install ${target[3]}` } }];
+    }
+  }
+
   m = /\b(jalankan|run|execute|exec|kerjakan)\b\s+(node|python3?)\b\s*([A-Za-z0-9_.\/-]+(?:\.[A-Za-z0-9]+)?)?/i.exec(text);
   if (m) {
     const cmd = `${m[2]} ${m[3] || ''}`.trim();
@@ -1631,6 +1682,75 @@ export async function planOnce(provider, messages, requestText, options = {}) {
   return heuristic;
 }
 
+async function executeToolCall({ executor, call, chatUI, messages, cwd }) {
+  const label = call.name === 'run_command' ? call.params.command
+    : call.name === 'download_url' ? `download_url(${call.params.url})`
+    : (call.name === 'todo_add' || call.name === 'todo_update')
+      ? `${call.name}(${JSON.stringify(call.params ?? {})})`
+      : `${call.name}(${call.params.path})`;
+  if (chatUI) {
+    chatUI.setStatus(`Running: ${label}`);
+    chatUI.setThinking(true);
+    chatUI.render(messages);
+  }
+  const result = await dispatchTool(executor, call);
+  logger.log('EXEC', `${label} -> ${result.exitCode}${result.timedOut ? ' [timeout]' : ''}`);
+  if (result.success) {
+    if (chatUI) chatUI.notify(`\u2713 ${label}`);
+    if (result.stdout.trim()) logger.log('EXEC', `${label} stdout: ${result.stdout.trim().slice(0, 500)}`);
+    if (result.stderr.trim()) logger.log('WARN', `${label} stderr: ${result.stderr.trim().slice(0, 500)}`);
+    if (call.name === 'create_file' && /\.py$/i.test(call.params.path)) {
+      const check = spawnSync('python3', [
+        '-c', 'import ast,sys; ast.parse(open(sys.argv[1], encoding="utf-8").read())',
+        join(cwd || '.', call.params.path),
+      ], { encoding: 'utf-8', timeout: 30000 });
+      if (check.status === 1) {
+        const detail = (check.stderr || '').trim().split('\n').slice(-2).join(' ');
+        if (chatUI) chatUI.notify(`\u2717 python check failed: ${call.params.path} (${detail})`);
+        logger.log('WARN', `${label} failed python syntax check: ${detail}`);
+      }
+    }
+  } else {
+    if (chatUI) chatUI.notify(`\u2717 ${label}: ${(result.stderr || 'failed').trim().slice(0, 300)}`);
+    logger.log('ERROR', `${label} failed: ${(result.stderr || result.stdout || 'exit ' + result.exitCode).trim().slice(0, 500)}`);
+  }
+  return { label, result };
+}
+
+// Ask the model for a corrected tool plan after a failed call. Returns []
+// when the model emits nothing usable. Does NOT mutate the session messages.
+async function planAutoFix(provider, messages, requestText, call, result) {
+  const history = (messages && messages.length ? messages.slice(-6) : [{ role: 'user', content: String(requestText || '') }]);
+  const deadline = Config.get('planTimeoutMs');
+  const controller = new AbortController();
+  let text = '';
+  let timer;
+  try {
+    text = await Promise.race([
+      provider.complete([...history, { role: 'user', content: TOOL_FIX_PROMPT(call, result) }], {
+        model: Config.getEffectiveModel(provider.name),
+        system_prompt: TOOL_PLAN_PROMPT,
+        maxTokens: 400,
+        signal: controller.signal,
+      }),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          if (!controller.signal.aborted) controller.abort();
+          reject(Object.assign(new Error(`auto-fix exceeded ${deadline}ms`), { name: 'DeadlineError' }));
+        }, deadline);
+      }),
+    ]);
+  } catch (err) {
+    logger.log('FIX', `auto-fix plan failed: ${err.message}`);
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+  const plan = parseToolPlan(text);
+  if (plan.length) logger.log('FIX', `auto-fix plan: ${plan.map((p) => p.name).join(', ')}`);
+  return plan;
+}
+
 export async function runWithTools({
   provider,
   messages,
@@ -1648,6 +1768,7 @@ export async function runWithTools({
   const executor = makeExecutor({ cwd, timeoutMs });
   const results = [];
   const plannedByModel = [];
+  let autoFixes = 0;
 
   for (let round = 0; round < MAX_PLANNING_ROUNDS; round++) {
     let plan;
@@ -1662,43 +1783,36 @@ export async function runWithTools({
     const steps = Math.min(plan.length, MAX_STEPS - results.length);
     let allOk = true;
     for (const call of plan.slice(0, steps)) {
-      const label = call.name === 'run_command' ? call.params.command
-        : call.name === 'download_url' ? `download_url(${call.params.url})`
-        : `${call.name}(${call.params.path})`;
-      if (chatUI) {
-        chatUI.setStatus(`Running: ${label}`);
-        chatUI.setThinking(true);
-        chatUI.render(messages);
-      }
-      const result = await dispatchTool(executor, call);
+      const { result } = await executeToolCall({ executor, call, chatUI, messages, cwd });
       results.push({ name: call.name, params: call.params, result });
-      logger.log('EXEC', `${label} -> ${result.exitCode}${result.timedOut ? ' [timeout]' : ''}`);
-      if (result.success) {
-        if (chatUI) chatUI.notify(`\u2713 ${label}`);
-        if (result.stdout.trim()) logger.log('EXEC', `${label} stdout: ${result.stdout.trim().slice(0, 500)}`);
-        if (result.stderr.trim()) logger.log('WARN', `${label} stderr: ${result.stderr.trim().slice(0, 500)}`);
-        if (call.name === 'create_file' && /\.py$/i.test(call.params.path)) {
-          const check = spawnSync('python3', [
-            '-c', 'import ast,sys; ast.parse(open(sys.argv[1], encoding="utf-8").read())',
-            join(cwd || '.', call.params.path),
-          ], { encoding: 'utf-8', timeout: 30000 });
-          if (check.status === 1) {
-            const detail = (check.stderr || '').trim().split('\n').slice(-2).join(' ');
-            if (chatUI) chatUI.notify(`\u2717 python check failed: ${call.params.path} (${detail})`);
-            logger.log('WARN', `${label} failed python syntax check: ${detail}`);
-          }
+      if (!result.success) allOk = false;
+      if (result.timedOut && !result.success) break;
+
+      if (!result.success && autoFixes < MAX_AUTO_FIXES && results.length < MAX_STEPS) {
+        autoFixes++;
+        if (chatUI) chatUI.setStatus('Auto-fixing failed step…');
+        const fixPlan = await planAutoFix(provider, messages, requestText, call, result);
+        const fixSteps = Math.min(fixPlan.length, MAX_STEPS - results.length);
+        let fixedOk = fixPlan.length > 0;
+        for (const fcall of fixPlan.slice(0, fixSteps)) {
+          const f = await executeToolCall({ executor, call: fcall, chatUI, messages, cwd });
+          results.push({ name: fcall.name, params: fcall.params, result: f.result });
+          if (!f.result.success) { fixedOk = false; break; }
         }
-      } else {
-        allOk = false;
-        if (chatUI) chatUI.notify(`\u2717 ${label}: ${(result.stderr || 'failed').trim().slice(0, 300)}`);
-        logger.log('ERROR', `${label} failed: ${(result.stderr || result.stdout || 'exit ' + result.exitCode).trim().slice(0, 500)}`);
+        if (fixedOk && chatUI) chatUI.notify('Auto-fixed after failure.');
+        if (fixedOk) allOk = true;
       }
-      if (result.timedOut && !result.success) break;
     }
     if (allOk || !results.length || round >= MAX_PLANNING_ROUNDS - 1) break;
   }
 
   if (results.length) {
+    const madeFiles = results.some((r) => (r.name === 'create_file' || r.name === 'create_directory') && r.result.success);
+    if (madeFiles) {
+      const treeText = renderFileTree(cwd || process.cwd()).join('\n');
+      logger.log('TREE', treeText.slice(0, 2500));
+      if (chatUI) chatUI.notify(treeText);
+    }
     if (chatUI) {
       chatUI.setStatus('');
       chatUI.setThinking(true);

package/src/cmd/executor.js

@@ -4,8 +4,16 @@ import { dirname, resolve, sep } from 'path';
 const ALLOWED_BINS = new Set([
   'mkdir', 'touch', 'ls', 'pwd', 'cat', 'cp', 'mv', 'rm',
   'npm', 'npx', 'node', 'python', 'python3', 'git', 'echo', 'printf',
+  'apt', 'apt-get', 'pkg',
 ]);
 
+// Package-manager commands never run interactively (no TTY), so auto-append a
+// confirm flag to mutating subcommands instead of letting apt/pkg block on a
+// prompt. pkg is the Termux/Android wrapper, apt/apt-get the Linux ones.
+const INSTALL_MANAGERS = new Set(['apt', 'apt-get', 'pkg']);
+const INSTALL_SUBCOMMANDS = new Set(['install', 'upgrade', 'remove', 'autoremove', 'purge']);
+const INSTALL_CONFIRM_FLAGS = /^-y$|^--yes$|^-dy$|^--assume-yes$/i;
+
 const SHELL_META = /[;&|<>`$]|\$\{|\(\)|\|\||&&/;
 
 // Bins whose *path arguments* must stay inside the workspace. Reads like `ls`
@@ -115,6 +123,12 @@ export class SafeCommandExecutor {
     if (PATH_CONTAINED_BINS.has(bin)) {
       this._checkPaths(bin, args);
     }
+    if (INSTALL_MANAGERS.has(bin)) {
+      const subIdx = argv.findIndex((a) => INSTALL_SUBCOMMANDS.has(a));
+      if (subIdx !== -1 && !argv.some((a) => INSTALL_CONFIRM_FLAGS.test(a))) {
+        argv.splice(subIdx + 1, 0, '-y');
+      }
+    }
     return argv;
   }
 

package/src/cmd/todos.js

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const FILE_NAME = '.todos.json';
+
+export function todosFile(cwd) {
+  return join(cwd || '.', FILE_NAME);
+}
+
+export function loadTodos(cwd) {
+  try {
+    const data = JSON.parse(readFileSync(todosFile(cwd), 'utf-8'));
+    if (!Array.isArray(data)) return [];
+    return data.map((t, i) => {
+      if (t && typeof t === 'object') {
+        return {
+          text: String(t.text ?? '').trim(),
+          done: Boolean(t.done),
+          createdAt: t.createdAt ?? null,
+          updatedAt: t.updatedAt ?? null,
+        };
+      }
+      return { text: String(t ?? '').trim(), done: false, createdAt: null, updatedAt: null };
+    }).filter((t) => t.text.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+export function saveTodos(cwd, todos) {
+  writeFileSync(todosFile(cwd), JSON.stringify(todos, null, 2) + '\n', 'utf-8');
+}
+
+export function formatTodos(todos) {
+  if (!todos || !todos.length) return '(no todos yet)';
+  return todos.map((t, i) => `${i + 1}. ${t.done ? '[x]' : '[ ]'} ${t.text}`).join('\n');
+}
+
+export function addTodo(cwd, text) {
+  const clean = String(text ?? '').trim();
+  if (!clean) return { error: 'Missing todo text.' };
+  const todos = loadTodos(cwd);
+  todos.push({ text: clean, done: false, createdAt: new Date().toISOString(), updatedAt: null });
+  saveTodos(cwd, todos);
+  return { okay: true };
+}
+
+export function updateTodo(cwd, index, { done, text } = {}) {
+  const todos = loadTodos(cwd);
+  const i = Number(index) - 1;
+  if (!Number.isInteger(i) || i < 0 || i >= todos.length) {
+    return { error: `No todo #${index}.` };
+  }
+  if (typeof done === 'boolean') todos[i].done = done;
+  if (typeof text === 'string' && text.trim()) todos[i].text = text.trim();
+  todos[i].updatedAt = new Date().toISOString();
+  saveTodos(cwd, todos);
+  return { okay: true };
+}
+
+export function clearTodos(cwd) {
+  saveTodos(cwd, []);
+  return { okay: true };
+}

package/src/cmd/tools.js

@@ -1,8 +1,9 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { resolve, sep } from 'path';
+import { accessSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, X_OK } from 'fs';
+import { delimiter, join, resolve, sep } from 'path';
 import { toolResult, SafeCommandExecutor } from './executor.js';
 import { Downloader } from '../utils/downloader.js';
 import { Config } from '../config.js';
+import { loadTodos, addTodo, updateTodo, clearTodos, formatTodos } from './todos.js';
 
 // Resolve a path relative to the workspace and require it to stay inside.
 // Throws if the path escapes the workspace (or hits the workspace root for
@@ -105,6 +106,23 @@ export function deleteFile(cwd, path) {
   }
 }
 
+// Pick the package manager to use for installing system packages: pkg is the
+// Termux/Android wrapper, everywhere else apt/apt-get.
+export function pickPackageManager() {
+  const dirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
+  const available = (bin) => dirs.some((dir) => {
+    try {
+      accessSync(join(dir, bin), X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  if (available('pkg')) return 'pkg';
+  if (available('apt-get')) return 'apt-get';
+  return 'apt';
+}
+
 export async function downloadUrl(cwd, url, dir) {
   if (!url || typeof url !== 'string' || !/^https?:\/\//i.test(url.trim())) {
     return fail({ command: 'download_url', stderr: 'Invalid URL. Provide a valid http(s) address.', cwd });
@@ -124,6 +142,35 @@ export async function downloadUrl(cwd, url, dir) {
   }
 }
 
+export function todoAdd(cwd, text) {
+  const err = addTodo(cwd, text);
+  if (err && err.error) return fail({ command: `todo_add("${text}")`, stderr: err.error, cwd });
+  return ok({ command: `todo_add("${text}")`, stdout: formatTodos(loadTodos(cwd)), cwd });
+}
+
+export function todoList(cwd) {
+  try {
+    return ok({ command: 'todo_list', stdout: formatTodos(loadTodos(cwd)), cwd });
+  } catch (err) {
+    return fail({ command: 'todo_list', stderr: err.message, cwd });
+  }
+}
+
+export function todoUpdate(cwd, index, done, text) {
+  const err = updateTodo(cwd, index, { done, text });
+  if (err && err.error) return fail({ command: `todo_update(${index})`, stderr: err.error, cwd });
+  return ok({ command: `todo_update(${index})`, stdout: formatTodos(loadTodos(cwd)), cwd });
+}
+
+export function todoClear(cwd) {
+  try {
+    clearTodos(cwd);
+    return ok({ command: 'todo_clear', stdout: '(no todos yet)', cwd });
+  } catch (err) {
+    return fail({ command: 'todo_clear', stderr: err.message, cwd });
+  }
+}
+
 // Structured tool registry shared with the agent loop.
 export const TOOL_EXECUTORS = {
   run_command: (executor, params) => executor.runCommand(params.command),
@@ -133,6 +180,10 @@ export const TOOL_EXECUTORS = {
   list_directory: (executor, params) => listDirectory(executor.cwd, params.path || '.'),
   delete_file: (executor, params) => deleteFile(executor.cwd, params.path),
   download_url: (executor, params) => downloadUrl(executor.cwd, params.url, params.dir),
+  todo_add: (executor, params) => todoAdd(executor.cwd, params ? params.text : undefined),
+  todo_list: (executor, params) => todoList(executor.cwd),
+  todo_update: (executor, params) => todoUpdate(executor.cwd, params ? params.index : undefined, params ? params.done : undefined, params ? params.text : undefined),
+  todo_clear: (executor, params) => todoClear(executor.cwd),
 };
 
 export function makeExecutor({ cwd, timeoutMs } = {}) {

package/src/installer.js

@@ -1,6 +1,7 @@
 import { execSync, exec } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync, lstatSync, readlinkSync, rmSync, realpathSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
 import { homedir, platform } from 'os';
 import { Catalog } from './catalog.js';
 import { Config } from './config.js';
@@ -112,19 +113,61 @@ function localBinDir() {
   return '/usr/local/bin';
 }
 
-function installAppCommand() {
+function isOnPath(dir) {
+  const sep = platform() === 'win32' ? ';' : ':';
+  let dirResolved;
   try {
-    const dir = localBinDir();
-    mkdirSync(dir, { recursive: true, mode: 0o755 });
-    const launcherPath = join(dir, 'vierrataleai');
-    if (platform() === 'win32') {
-      if (existsSync(launcherPath)) return launcherPath;
-      writeFileSync(launcherPath, `@echo off\r\nnode "${process.argv[1]}" %*\r\n`);
-      return launcherPath;
+    dirResolved = existsSync(dir) ? realpathSync(dir) : resolve(dir);
+  } catch {
+    dirResolved = resolve(dir);
+  }
+  return String(process.env.PATH || '')
+    .split(sep)
+    .some((entry) => {
+      entry = entry.trim();
+      if (!entry) return false;
+      try {
+        const e = existsSync(entry) ? realpathSync(entry) : resolve(entry);
+        return e === dirResolved;
+      } catch {
+        return false;
+      }
+    });
+}
+
+// Prefer a bin dir that is already on PATH (and writable) so the installed
+// command is callable immediately; fall back to the local bin dir.
+function chooseBinDir() {
+  const local = localBinDir();
+  if (isOnPath(local)) return local;
+  for (const candidate of ['/usr/local/bin', '/usr/bin']) {
+    try {
+      mkdirSync(candidate, { recursive: true, mode: 0o755 });
+      const probe = join(candidate, `.vierrataleai-write-test-${process.pid}`);
+      writeFileSync(probe, '');
+      rmSync(probe, { force: true });
+      return candidate;
+    } catch {}
+  }
+  return local;
+}
+
+// Create (or refresh) a launcher link for `name` pointing at the node bin.
+function writeLauncher(dir, name, target) {
+  const launcherPath = join(dir, name);
+  if (platform() === 'win32') {
+    if (!existsSync(launcherPath)) {
+      writeFileSync(launcherPath, `@echo off\r\nnode "${target}" %*\r\n`);
     }
-    // Prefer a real symlink; fall back to a small shim that calls the node bin.
-    if (existsSync(launcherPath)) return launcherPath;
-    const target = process.argv[1] && existsSync(process.argv[1]) ? process.argv[1] : join(Config.getConfigDir(), '..', '..', 'src', 'cli.js');
+    return launcherPath;
+  }
+  // Prefer a real symlink; fall back to a small shim that calls the node bin.
+  let live = false;
+  try {
+    live = lstatSync(launcherPath).isSymbolicLink() && readlinkSync(launcherPath) === target;
+  } catch {}
+  if (!live) {
+    rmSync(launcherPath, { force: true });
     try {
       symlinkSync(target, launcherPath);
       chmodSync(launcherPath, 0o755);
@@ -132,6 +175,19 @@ function installAppCommand() {
       writeFileSync(launcherPath, `#!/bin/sh\nnode "${target}" "$@"\n`);
       chmodSync(launcherPath, 0o755);
     }
+  }
+  return launcherPath;
+}
+
+function installAppCommand() {
+  try {
+    const dir = chooseBinDir();
+    mkdirSync(dir, { recursive: true, mode: 0o755 });
+    const defaultTarget = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin', 'vierrataleai.js');
+    const target = process.argv[1] && existsSync(process.argv[1]) ? process.argv[1] : defaultTarget;
+    // Both spellings run the assistant.
+    const launcherPath = writeLauncher(dir, 'vierrataleai', target);
+    writeLauncher(dir, 'vierratale', target);
     return launcherPath;
   } catch {
     return null;
@@ -158,6 +214,9 @@ export const Installer = {
 
   chooseModel,
 
+  installAppCommand,
+  isOnPath,
+
   async ensure() {
     const host = Config.get('engineHost');
 
@@ -227,7 +286,15 @@ export const Installer = {
     }
 
     let command = null;
-    if (includeCommand) command = installAppCommand();
-    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command };
+    let commandAlias = null;
+    let commandOnPath = false;
+    if (includeCommand) {
+      command = installAppCommand();
+      if (command) {
+        commandAlias = join(dirname(command), 'vierratale');
+        commandOnPath = isOnPath(dirname(command));
+      }
+    }
+    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command, commandAlias, commandOnPath };
   },
 };

package/src/ui/branding.js

@@ -1,6 +1,6 @@
 export const Branding = {
   APP_NAME: 'VierrataleAI',
-  VERSION: '0.1.0-beta.11',
+  VERSION: '0.1.0-beta.12',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',

package/src/utils/filetree.js

@@ -0,0 +1,44 @@
+import { readdirSync } from 'fs';
+import { join } from 'path';
+
+// Directories that are never worth expanding in a workspace tree.
+const SKIP_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.cache']);
+
+// Render a compact box-drawing tree of a directory. Returns an array of lines
+// starting with "." for the workspace root. Bounded so huge folders (node_modules,
+// caches, download dirs) can never flood a chat with thousands of lines.
+export function renderFileTree(rootDir, { maxDepth = 4, maxEntries = 150 } = {}) {
+  const root = rootDir || process.cwd();
+  const lines = ['.'];
+  let entries = 0;
+
+  const walk = (dir, depth, prefix) => {
+    if (entries >= maxEntries) return;
+    let names;
+    try {
+      names = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    names = names
+      .filter((e) => !SKIP_DIRS.has(e.name))
+      .sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+    for (let i = 0; i < names.length; i++) {
+      if (entries >= maxEntries) return;
+      const e = names[i];
+      const last = i === names.length - 1;
+      lines.push(`${prefix}${last ? '└── ' : '├── '}${e.name}`);
+      entries++;
+      if (e.isDirectory() && depth < maxDepth) {
+        walk(join(dir, e.name), depth + 1, `${prefix}${last ? '    ' : '│   '}`);
+      }
+    }
+  };
+
+  walk(root, 0, '');
+  if (entries >= maxEntries) lines.push(`… showing first ${entries} entries`);
+  return lines;
+}