loom-agent 1.2.36 → 1.2.37

package/src/core/agents.js

@@ -60,9 +60,9 @@ function escapeRegExp(s) {
 const BUILTIN_AGENTS = {
   build: {
     id: 'build', name: 'Build', mode: 'primary',
-    description: 'Full development work with all tools enabled.',
+    description: 'Main orchestrator agent: full development work with all tools, drives tasks to completion.',
     tools: ['*'],
-    prompt: null,
+    prompt: 'You are the MAIN ORCHESTRATOR agent. For non-trivial, multi-step work: (1) capture the plan as a todowrite list up front, (2) keep working until every item is completed or explicitly cancelled — never stop mid-task with a summary while todos remain, (3) delegate independent/parallelizable packages via the task tool (research for deep investigation, coder for isolated implementation, reviewer for review, tester for tests, web for browser work, explore for fast code search), (4) verify your work (run tests/typecheck/lint the project actually uses) before declaring done, (5) finish with a terse summary of what changed.',
   },
   plan: {
     id: 'plan', name: 'Plan', mode: 'primary',
@@ -95,6 +95,36 @@ const BUILTIN_AGENTS = {
     tools: ['read', 'glob', 'grep', 'webfetch'],
     prompt: null,
   },
+  research: {
+    id: 'research', name: 'Research', mode: 'subagent',
+    description: 'Deep multi-source research: combines web search/fetch with local code and docs, cross-checks facts, and returns a structured findings report with sources and confidence levels.',
+    tools: ['read', 'glob', 'grep', 'webfetch', 'websearch', 'todowrite'],
+    prompt: 'You are the Research agent. Investigate the topic from multiple independent sources (websearch/webfetch AND local files when relevant). Never state a fact you have not verified in a source. Track your investigation with todowrite when it has many steps. Return a structured report: "## Findings" (numbered facts, each with its source: URL or file:line), "## Gaps" (what you could not verify), "## Recommendation".',
+  },
+  coder: {
+    id: 'coder', name: 'Coder', mode: 'subagent',
+    description: 'Implementation specialist: writes and edits code, runs commands, verifies results. Use for well-scoped feature/bugfix packages that can run independently.',
+    tools: ['*', '!task'],
+    prompt: 'You are the Coder agent. Implement exactly what was delegated — no scope creep. Follow the existing code conventions of the files you touch (imports, naming, JSDoc/typing style). Verify your work (run the relevant tests/typecheck) before reporting. Final report: files changed with line deltas, commands run and their outcomes, and anything left undone.',
+  },
+  reviewer: {
+    id: 'reviewer', name: 'Reviewer', mode: 'subagent',
+    description: 'Code review specialist: reads diffs and files, runs read-only git/inspection commands, returns severity-ranked findings with file:line references.',
+    tools: ['read', 'glob', 'grep', 'bash', 'webfetch'],
+    prompt: 'You are a strict code reviewer. Hunt for: correctness bugs, security issues, data loss risks, broken edge cases, missing tests, and convention violations. Inspect the actual diff/files (git diff, git log, read) — never review code you have not read. Findings first, ranked by severity (critical/major/minor), each with file:line and a concrete suggested fix. If there are no issues, say so explicitly and note what you checked.',
+  },
+  tester: {
+    id: 'tester', name: 'Tester', mode: 'subagent',
+    description: 'Test engineer: writes tests that reproduce the issue, runs them, iterates until green. Use for test creation, bug reproduction, and verification work.',
+    tools: ['read', 'write', 'edit', 'glob', 'grep', 'bash', 'todowrite'],
+    prompt: 'You are the Tester agent. First reproduce the behavior (write a failing test when possible), run it, then iterate until the outcome is deterministic and understood. Use the project\'s real test runner (inspect package.json/bunfig — never invent commands). Report: exact commands run, pass/fail counts, and what the tests prove.',
+  },
+  web: {
+    id: 'web', name: 'Web', mode: 'subagent',
+    description: 'Browser specialist: drives a real headless browser (navigate, click, fill, read DOM, screenshot) plus webfetch/websearch. Use for live-site inspection, rendered-page research, and end-to-end UI verification.',
+    tools: ['read', 'glob', 'grep', 'webfetch', 'websearch', 'browser', 'todowrite'],
+    prompt: 'You are the Web agent with a real headless browser (the browser tool). Prefer the browser over webfetch whenever the page needs JavaScript rendering, clicking, or form interaction. Verify claims by reading the ACTUAL DOM (browser text/eval/links) — never guess page content. Use screenshots to confirm visual state when relevant. Stay on http/https pages; do not use the browser to access local files.',
+  },
 };
 
 function readOnlyTools() {

package/src/core/cli.js

@@ -9,6 +9,10 @@ const { ProviderRouter, PROVIDERS } = require('../providers');
 const { saveSession, loadSession } = require('./session-store');
 const { defaultMcpInstall } = require('./plugin-cmd');
 
+// Single source of truth for every version string the CLI prints (banner,
+// --version). package.json is the only place to bump.
+const VERSION = require('../../package.json').version;
+
 const LOOM_BASE = `
  ██╗      ██████╗  ██████╗ ███╗   ███╗      ██████╗ ██████╗ ██████╗ ███████╗
  ██║     ██╔═══██╗██╔═══██╗████╗ ████║     ██╔════╝██╔═══██╗██╔══██╗██╔════╝
@@ -38,7 +42,7 @@ class LoomCLI {
       terminal: true,
     });
     console.log(LOOM_BASE);
-    console.log(`\n  Loom Code v1.2.28 — AI Coding Agent for the terminal`);
+    console.log(`\n  Loom Code v${VERSION} — AI Coding Agent for the terminal`);
     console.log(`  Press Ctrl+C or ESC to interrupt | /help for commands\n`);
 
     process.stdin.on('keypress', (str, key) => {
@@ -391,7 +395,13 @@ class LoomCLI {
    */
   async openGraphBrowser(graph) {
     const http = require('http');
-    const template = fs.readFileSync(path.join(__dirname, '..', 'web', 'graph-view.html'), 'utf8');
+    let template;
+    try {
+      template = fs.readFileSync(path.join(__dirname, '..', 'web', 'graph-view.html'), 'utf8');
+    } catch {
+      console.log('Browser graph view is not available (the web UI has been removed).');
+      return;
+    }
     const html = template.replace('window.__GRAPH__ || { nodes: [], edges: [] }', JSON.stringify(graph).replace(/<\/script/gi, '<\\/script'));
     const server = http.createServer((req, res) => {
       const p = req.url || '/';
@@ -509,7 +519,6 @@ async function main() {
   const cli = new LoomCLI();
 
   const args = process.argv.slice(2);
-  const VERSION = require('../../package.json').version;
 
   const printIdx = args.indexOf('-p');
   const printLongIdx = args.indexOf('--print');
@@ -530,8 +539,7 @@ if (args.includes('--help') || args.includes('-h')) {
     console.log('  loom --basic            Use basic line-mode REPL (no TUI)');
     console.log('  loom --auto             Auto-approve permission prompts');
     console.log('  loom acp                ACP server (JSON-RPC over stdio, for editor plugins)');
-    console.log('  loom web                Browser interface (HTTP server, opens the browser)');
-    console.log('  loom attach <url>       Attach the terminal to a running `loom web` server');
+    console.log('  loom add mcp <spec>     Add an MCP server (same syntax as /mcp add)');
     console.log('  loom -s <session-id>    Resume a saved session');
     console.log('  loom --version           Show version');
     console.log('  loom --help              Show this help');
@@ -551,6 +559,23 @@ if (args.includes('--help') || args.includes('-h')) {
     return;
   }
 
+  // loom add mcp <name> [--] <command> [args...] — register an MCP server from
+  // the shell with the same one-liner syntax as /mcp add (quote paths with
+  // spaces; -e KEY=V for env). Exits 0 on success.
+  if (args[0] === 'add' && args[1] === 'mcp') {
+    const spec = args.slice(2);
+    if (!spec.length) {
+      console.log('Usage: loom add mcp [-e KEY=V] <name> [--] <command> [args...]');
+      console.log('Example: loom add mcp fetch -- npx -y mcp-server-fetch');
+      process.exit(1);
+    }
+    const { mcpAddLineCmd } = require('./plugin-cmd');
+    const msg = mcpAddLineCmd(spec.join(' '));
+    const ok = typeof msg === 'string' && msg.startsWith('Added');
+    console.log(ok ? msg : 'Error: ' + msg);
+    process.exit(ok ? 0 : 1);
+  }
+
   if (sessionId && sIndex !== -1) {
     const data = loadSession(sessionId);
     if (data && data.messages && data.messages.length) {

package/src/core/permissions.js

@@ -34,7 +34,7 @@ const DANGER_PATTERNS = [
 // user config).
 const PERMISSION_KEYS = [
   'read', 'edit', 'glob', 'grep', 'bash', 'task', 'skill', 'lsp', 'question',
-  'webfetch', 'websearch',
+  'webfetch', 'websearch', 'browser',
   'external_directory', 'doom_loop',
 ];
 
@@ -53,6 +53,15 @@ const DEFAULT_PERMISSIONS = {
     '*.env.*': 'deny',
     '*.env.example': 'allow',
   },
+  // Browser: passive reads of live pages are as safe as webfetch (allow);
+  // INTERACTIVE actions (click/fill/press) can submit forms and change remote
+  // state, so they prompt by default. Patterns match "action arg".
+  browser: {
+    '*': 'allow',
+    'click*': 'ask',
+    'fill*': 'ask',
+    'press*': 'ask',
+  },
 };
 
 // Tools that write files map onto the "edit" permission (OpenCode semantics:
@@ -71,6 +80,7 @@ const TOOL_TO_PERMISSION = {
   ask: 'question',
   webfetch: 'webfetch',
   websearch: 'websearch',
+  browser: 'browser',
   todowrite: null,   // never prompts
   mcp: null,         // wired by the session (only the "add" action prompts)
 };
@@ -301,6 +311,7 @@ class PermissionManager {
       case 'ask': return String(inp.question ?? inp.text ?? '');
       case 'webfetch': return String(inp.url ?? '');
       case 'websearch': return String(inp.query ?? '');
+      case 'browser': return String(inp.action ?? '') + ' ' + String(inp.url ?? inp.selector ?? inp.key ?? inp.path ?? '');
       default: return String(inp.command ?? inp.filePath ?? inp.path ?? inp.pattern ?? inp.url ?? '');
     }
   }

package/src/core/plugin-cmd.js

@@ -123,6 +123,7 @@ function mcpHelp() {
     '',
     'Example (claude-compatible): /mcp add stm32 -- "C:\\stm32-mcp\\.venv\\Scripts\\python.exe" -m stm32_mcp.server',
     'Example with env: /mcp add -e BRAVE_API_KEY=x brave-search -- npx -y @modelcontextprotocol/server-brave-search',
+    'From the shell (same syntax): loom add mcp [-e KEY=V] <name> [--] <command> [args...]',
     'The "--" separator is optional; quote any path with spaces. Env keys are usable as $KEY in args.',
     'In the /mcp and /connectors browsers, press A to add with the same one-liner syntax.',
   ].join('\n');

package/src/core/session.js

@@ -23,6 +23,13 @@ const COMPACT_DEFAULT_THRESHOLD = 0.75;
 const COMPACT_KEEP_MESSAGES = 8;
 // Never compact conversations shorter than this.
 const COMPACT_MIN_MESSAGES = 6;
+// Drive-to-completion: how many continuation nudges one turn may spend when
+// the model stops with todos still unfinished (the "stops between tasks"
+// failure). Capped so a model that refuses to update its todos cannot spin.
+const MAX_DRIVE_NUDGES = 5;
+// Transient provider failures (network blip, 5xx, stream reset) retry the
+// model call this many times before the turn surfaces an error.
+const PROVIDER_RETRIES = 2;
 
 /**
  * @typedef {Object} SpeedStats
@@ -244,6 +251,19 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
 - If the user wants code changes, tell them to switch to Build mode (Tab or /build) and resend.` : ''}${this.config.outputStyle ? `\n\n## Output style\n${this.config.outputStyle}` : ''}`;
   }
 
+  // System-prompt suffix for the active PRIMARY agent (build/plan/chat): each
+  // primary can carry a role prompt (the Build orchestrator instructions, the
+  // Plan agent role, …) that appends after the base prompt. Child sessions and
+  // @agent turns already use _agentBlock, and primaries never set this.agent,
+  // so the two cannot stack. Resolved lazily so per-turn config changes apply.
+  _primaryBlock() {
+    if (this._isChild || this.agent) return '';
+    let agent = null;
+    try { agent = require('./agents').resolveAgent(this.mode); } catch { return ''; }
+    if (!agent || !agent.prompt) return '';
+    return '\n\n## Acting as the "' + agent.name + '" agent\n' + agent.prompt + '\n';
+  }
+
   // Create ./LOOM.md with a template when missing, so memory exists from the
   // first turn (Claude Code behavior). Disable with LOOM_MEM_AUTO=0 (tests).
   ensureMemoryFile() {
@@ -542,13 +562,19 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
           interrupted: true,
         });
       }
-      return { type: 'text', content: streamed || '(interrupted)', interrupted: true };
+      return { type: 'text', content: streamed || '(interrupted before any text was streamed)', interrupted: true };
     };
 
     // No tool-use cap: the model decides when a turn is finished; the user can
     // always Esc-interrupt a runaway loop.
     let ranTools = false;
     let nudged = false;
+    let toolCallsThisTurn = 0;
+    // Drive-to-completion state (see the no-toolCalls branch below).
+    let driveNudges = 0;
+    let todowroteThisTurn = false;
+    // Transient provider-error retry state.
+    let providerRetries = 0;
     while (true) {
       if (this.interrupted) {
         return finishInterrupted();
@@ -575,6 +601,16 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
             continue;
           }
         }
+        // Transient provider failure (network blip, 5xx, stream reset): retry
+        // the model call a couple of times instead of killing the turn
+        // mid-task. No tools ran for this iteration, so a retry is side-effect
+        // free.
+        if (providerRetries < PROVIDER_RETRIES) {
+          providerRetries++;
+          await new Promise((resolve) => setTimeout(resolve, 400 * providerRetries));
+          if (this.interrupted) return finishInterrupted();
+          continue;
+        }
         return { type: 'error', content: err.message };
       }
 
@@ -611,15 +647,59 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
         // Silent-stop guard: models occasionally end a turn with an EMPTY
         // reply right after running tools (truncation / provider hiccup),
         // which reads to the user like "the agent just stopped". One
-        // automatic continuation instead of dead-ending with '(no response)'.
+        // automatic continuation instead of dead-ending with a placeholder.
         if (!text.trim() && ranTools && !nudged && !this.interrupted) {
           nudged = true;
-          this.addMessage({ role: 'user', content: '(your last reply was empty — continue where you left off and finish the task)' });
+          this.addMessage({
+            role: 'user',
+            content: '(the model returned an empty reply after ' + toolCallsThisTurn +
+              ' tool call(s) — continue where you left off and finish the task)',
+          });
           continue;
         }
-        return { type: 'text', content: text || '(no response)' };
+        // Drive-to-completion guard: the model stopped calling tools in the
+        // middle of tracked work (todos written this turn still
+        // pending/in_progress). Inject one continuation that quotes the
+        // model's ACTUAL last message and lists the unfinished items — up to
+        // MAX_DRIVE_NUDGES times — so a premature summary does not strand the
+        // task. The model can stop cleanly by completing or cancelling the
+        // items via todowrite. Plan/chat modes are excluded (plan drafts are
+        // meant to end with pending steps).
+        if (!this.interrupted && this.mode === 'build' && ranTools && todowroteThisTurn && driveNudges < MAX_DRIVE_NUDGES) {
+          const unfinished = (this.todos || []).filter((t) => t.status === 'pending' || t.status === 'in_progress');
+          if (unfinished.length) {
+            driveNudges++;
+            const list = unfinished.slice(0, 20).map((t) => '- [' + t.status + '] ' + t.content).join('\n');
+            // Quote what the model actually said — a canned nudge alone gives
+            // the user (and the model) no clue WHERE the turn went off the rails.
+            const lastReply = text.replace(/\s+/g, ' ').trim();
+            const snippet = lastReply
+              ? '\nYour last message was: "' + (lastReply.length > 240 ? lastReply.slice(0, 240) + '…' : lastReply) + '"'
+              : '';
+            this.addMessage({
+              role: 'user',
+              content: '(unfinished work detected: ' + unfinished.length + ' todo(s) still open:\n' + list + snippet +
+                '\nYour reply stopped the turn, but the work above is not done — continue exactly where you left off and finish it. ' +
+                'Only stop when every item is completed or cancelled via todowrite, or when something concrete blocks you — then name the blocker.)',
+            });
+            continue;
+          }
+        }
+        // Surface WHAT is still open when a build-mode turn that WROTE todos
+        // ends with work remaining (same signal as the nudge above), so the
+        // UI can show the real leftovers instead of a generic "stopped"
+        // placeholder. Stale todos from older turns stay silent.
+        const openTodos = (this.mode === 'build' && todowroteThisTurn)
+          ? (this.todos || []).filter((t) => t.status === 'pending' || t.status === 'in_progress')
+          : [];
+        return {
+          type: 'text',
+          content: text || '(the model ended the turn without any text)',
+          openTodos: openTodos.length ? openTodos : undefined,
+        };
       }
       ranTools = true;
+      toolCallsThisTurn += toolCalls.length;
 
       // Execute independent tool calls in parallel; results are appended in the
       // original call order so the conversation history stays deterministic.
@@ -659,7 +739,7 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
         // are checked separately where they apply.
         const permKey = { read:'read', edit:'edit', write:'edit', glob:'glob', grep:'grep', bash:'bash',
                           task:'task', skill:'skill', lsp:'lsp', question:'question', ask:'question', webfetch:'webfetch',
-                          websearch:'websearch' }[tc.name];
+                          websearch:'websearch', browser:'browser' }[tc.name];
         const isMcpAdd = tc.name === 'mcp' && tc.input && tc.input.action === 'add';
         if (permKey || isMcpAdd) {
           const arg = this.permissions.permissionArg(tc.name, tc.input || {});
@@ -734,6 +814,7 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
         this.addMessage({ role: 'tool', toolCallId: tc.id, content: text });
         // Persist real todo state when the model uses the todowrite tool.
         if (tc.name === 'todowrite' && !outcome.error) {
+          todowroteThisTurn = true;
           this.setTodos(tc.input && tc.input.todos);
           // Notify observers (sidebar, etc.) over the tiny event bus — the TUI
           // subscribes once and the panel updates without a re-render cycle.
@@ -805,7 +886,7 @@ ${this.mode === 'build' ? `- You have all tools available: read, write, edit, ba
       maxTokens: this.config.maxTokens || 8192,
       temperature: this.config.temperature ?? 0.7,
       tools: toolDefs,
-      system: this.systemPrompt + (this._skillBlock || '') + (this._agentBlock || ''),
+      system: this.systemPrompt + (this._skillBlock || '') + (this._agentBlock || '') + this._primaryBlock(),
       signal: this.abortController?.signal,
       // Extended thinking: models tagged 'reasoning' reason BEFORE every
       // reply — including after each tool result — so complex tasks get

package/src/tools/browser.js

@@ -0,0 +1,204 @@
+// Headless browser control for the Web agent (and any build-mode session).
+// Wraps Playwright behind a single-page singleton: the first action launches
+// a headless Chromium and every later action reuses it, so "open a page, click
+// around, read the DOM" works across tool calls without re-launching.
+//
+// Engine resolution order:
+//   1. `playwright` (bundled chromium download, if the user installed it)
+//   2. `playwright-core` + a system Chrome / Edge channel (zero download)
+// Everything runs in the page context only — no filesystem access beyond the
+// screenshot path the caller passes (enforced by the tool-layer sandbox for
+// writes is intentionally NOT applied here: screenshots land in the OS temp
+// dir by default and the tool returns the absolute path).
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const INSTALL_HINT = 'Install a browser engine:  npm i playwright  then  npx playwright install chromium  (or install playwright-core and have Chrome/Edge available)';
+const ACTION_TIMEOUT_MS = 30000;
+
+/** @type {{ browser: any, page: any }|null} */
+let _engine = null;
+let _playwright = null; // null = not tried, false = unavailable, else module
+
+const ACTIONS = ['goto', 'click', 'fill', 'press', 'text', 'eval', 'links', 'screenshot', 'close'];
+
+function loadPlaywright() {
+  if (_playwright !== null) return _playwright || null;
+  for (const mod of ['playwright', 'playwright-core']) {
+    try { _playwright = require(mod); return _playwright; } catch {}
+  }
+  _playwright = false;
+  return null;
+}
+
+function withTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('browser action timed out after ' + ms + 'ms')), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+function checkUrl(url) {
+  const u = String(url || '').trim();
+  if (!u) return { error: 'goto needs a url.' };
+  let parsed;
+  try { parsed = new URL(u); } catch { return { error: 'Invalid url: ' + u }; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return { error: 'Only http/https urls are allowed (got ' + parsed.protocol + ').' };
+  }
+  return { url: parsed.href };
+}
+
+async function pageSnapshot(page) {
+  const title = await page.title().catch(() => '');
+  return 'URL: ' + page.url() + (title ? '\nTitle: ' + title : '');
+}
+
+/** Launch (or reuse) the headless browser. Returns the page or {error}. */
+async function ensurePage() {
+  if (_engine && _engine.page && !_engine.page.isClosed()) return _engine.page;
+  const pw = loadPlaywright();
+  if (!pw) {
+    return { error: 'No browser engine found. ' + INSTALL_HINT };
+  }
+  const attempts = [
+    () => pw.chromium.launch({ headless: true }),
+    () => pw.chromium.launch({ headless: true, channel: 'chrome' }),
+    () => pw.chromium.launch({ headless: true, channel: 'msedge' }),
+  ];
+  let lastErr = null;
+  for (const attempt of attempts) {
+    try {
+      const browser = await withTimeout(attempt(), 20000);
+      const context = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+      const page = await context.newPage();
+      _engine = { browser, page };
+      return page;
+    } catch (err) { lastErr = err; }
+  }
+  return { error: 'Failed to launch a browser: ' + (lastErr && lastErr.message) + '. ' + INSTALL_HINT };
+}
+
+/** Close the singleton browser (also used as the `close` action). */
+async function closeBrowser() {
+  if (!_engine) return 'No browser is running.';
+  try { await _engine.browser.close(); } catch {}
+  _engine = null;
+  return 'Browser closed.';
+}
+
+/**
+ * Execute one browser action. `params` comes straight from the tool call:
+ *   action, url, selector, text, key, script, path
+ * @param {Record<string, any>} params
+ * @returns {Promise<string|{error: string}>}
+ */
+async function run(params) {
+  const action = String(params.action || '').toLowerCase().trim();
+  if (!ACTIONS.includes(action)) {
+    return { error: 'Unknown action "' + action + '". Use one of: ' + ACTIONS.join(' | ') };
+  }
+  if (action === 'close') return closeBrowser();
+
+  // Validate inputs BEFORE launching a browser so bad calls fail fast and
+  // never spawn a headless process.
+  if (action === 'goto') {
+    const u = checkUrl(params.url);
+    if (u.error) return u;
+  }
+  if ((action === 'click' || action === 'fill') && !String(params.selector || '').trim()) {
+    return { error: action + ' needs a CSS selector.' };
+  }
+  if (action === 'press' && !String(params.key || '').trim()) {
+    return { error: 'press needs a key (e.g. Enter, Tab, Escape, Control+A).' };
+  }
+  if (action === 'eval' && !String(params.script || '').trim()) {
+    return { error: 'eval needs a JavaScript expression (runs in the page context).' };
+  }
+
+  const page = await ensurePage();
+  if (page && typeof page === 'object' && 'error' in page) return page;
+
+  try {
+    switch (action) {
+      case 'goto': {
+        const u = checkUrl(params.url);
+        if (u.error) return u;
+        await withTimeout(page.goto(u.url, { waitUntil: 'domcontentloaded', timeout: ACTION_TIMEOUT_MS }), ACTION_TIMEOUT_MS + 2000);
+        await page.waitForLoadState('load', { timeout: 10000 }).catch(() => {});
+        return 'Opened ' + (await pageSnapshot(page));
+      }
+      case 'click': {
+        const sel = String(params.selector || '').trim();
+        if (!sel) return { error: 'click needs a CSS selector.' };
+        await withTimeout(page.click(sel, { timeout: 10000 }), 12000);
+        await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => {});
+        return 'Clicked "' + sel + '".\n' + (await pageSnapshot(page));
+      }
+      case 'fill': {
+        const sel = String(params.selector || '').trim();
+        if (!sel) return { error: 'fill needs a CSS selector.' };
+        await withTimeout(page.fill(sel, String(params.text ?? ''), { timeout: 10000 }), 12000);
+        return 'Filled "' + sel + '" with ' + String(params.text ?? '').length + ' chars.';
+      }
+      case 'press': {
+        const key = String(params.key || '').trim();
+        if (!key) return { error: 'press needs a key (e.g. Enter, Tab, Escape, Control+A).' };
+        await page.keyboard.press(key);
+        await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => {});
+        return 'Pressed ' + key + '.\n' + (await pageSnapshot(page));
+      }
+      case 'text': {
+        const body = await withTimeout(page.innerText('body').catch(() => ''), 10000);
+        const text = String(body || '').replace(/\n{3,}/g, '\n\n').trim();
+        const head = await pageSnapshot(page);
+        return head + '\n\n' + (text ? text.slice(0, 10000) : '(page has no visible text — try action="eval" or action="links")');
+      }
+      case 'eval': {
+        const script = String(params.script || '').trim();
+        if (!script) return { error: 'eval needs a JavaScript expression (runs in the page context).' };
+        // Function-body form keeps multi-statement scripts working.
+        const result = await withTimeout(page.evaluate((src) => {
+          try { return JSON.stringify({ ok: true, value: new Function('return (' + src + ')')() }); }
+          catch (e) { return JSON.stringify({ ok: false, error: String(e && e.message || e) }); }
+        }, script), 10000);
+        const parsed = JSON.parse(String(result));
+        if (!parsed.ok) return { error: 'eval failed: ' + parsed.error };
+        const out = typeof parsed.value === 'string' ? parsed.value : JSON.stringify(parsed.value, null, 2);
+        return String(out == null ? 'null' : out).slice(0, 10000);
+      }
+      case 'links': {
+        const links = await withTimeout(
+          page.$$eval('a[href]', (els) => els.slice(0, 100).map((a) => ({
+            href: a.getAttribute('href') || '',
+            text: (a.textContent || '').trim().replace(/\s+/g, ' ').slice(0, 120),
+          }))),
+          10000,
+        );
+        if (!links.length) return (await pageSnapshot(page)) + '\n\n(no links found)';
+        return links.map((l, i) => (i + 1) + '. ' + l.text + ' — ' + l.href).join('\n').slice(0, 10000);
+      }
+      case 'screenshot': {
+        const dest = params.path
+          ? path.resolve(String(params.path))
+          : path.join(os.tmpdir(), 'loom-browser-' + Date.now() + '.png');
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        await withTimeout(page.screenshot({ path: dest, fullPage: false }), 15000);
+        return 'Screenshot saved: ' + dest + '\n' + (await pageSnapshot(page));
+      }
+      default:
+        return { error: 'Unknown action "' + action + '".' };
+    }
+  } catch (err) {
+    return { error: 'browser ' + action + ' failed: ' + (err && err.message || err) };
+  }
+}
+
+// Test/diagnostic hook — true when a browser page is live.
+function isRunning() {
+  return !!( _engine && _engine.page && !_engine.page.isClosed() );
+}
+
+module.exports = { run, closeBrowser, isRunning, ACTIONS };

package/src/tools/index.js

@@ -440,7 +440,7 @@ const TOOLS = {
   },
   task: {
     name: 'task',
-    description: 'Delegate a self-contained subtask to a subagent that runs fully autonomously and returns its final answer. Use when a piece of work can run independently (parallelizable), needs a focused toolset, or benefits from a different model. Pick the smallest suitable agent: explore (fast read-only code search), scout (web/docs research), general (full toolset except delegation). Pass the agent a COMPLETE, self-contained instruction: the goal, relevant file paths, and exactly what to return. The subagent may run tools autonomously; fold its findings into your own answer afterwards.',
+    description: 'Delegate a self-contained subtask to a subagent that runs fully autonomously and returns its final answer. Use when a piece of work can run independently (parallelizable), needs a focused toolset, or benefits from a different model. Agents: general (full toolset, default), explore (fast read-only code search), scout (quick docs lookups), research (deep multi-source investigation with a sourced report), coder (isolated implementation packages), reviewer (severity-ranked code review), tester (write/run tests until green), web (headless-browser work on live pages). Pick the smallest suitable agent. Pass a COMPLETE, self-contained instruction: the goal, relevant file paths, and exactly what to return. The subagent may run tools autonomously; fold its findings into your own answer afterwards.',
     parameters: {
       prompt: { type: 'string', required: true, description: 'Complete instructions for the subagent — goal, relevant file paths, and the exact output to return' },
       agent: { type: 'string', required: false, description: 'Subagent id: general (default), explore, scout, or a custom one from config.agents' },
@@ -462,6 +462,22 @@ const TOOLS = {
       return usage + '\n\n' + res.content;
     }
   },
+  browser: {
+    name: 'browser',
+    description: 'Drive a real headless browser (Playwright). Actions: goto (open an http/https url), click (CSS selector), fill (selector + text), press (key like Enter), text (visible page text + title/url), eval (JS expression in the page context), links (list page links), screenshot (save PNG, returns the file path), close. The browser stays open between calls so you can navigate, interact, and re-read the page. Prefer this over webfetch when the page needs JavaScript rendering or interaction.',
+    parameters: {
+      action: { type: 'string', required: true, description: '"goto" | "click" | "fill" | "press" | "text" | "eval" | "links" | "screenshot" | "close"' },
+      url: { type: 'string', required: false, description: 'Page url (action=goto)' },
+      selector: { type: 'string', required: false, description: 'CSS selector (action=click or fill)' },
+      text: { type: 'string', required: false, description: 'Text to type into the selector (action=fill)' },
+      key: { type: 'string', required: false, description: 'Key to press, e.g. Enter (action=press)' },
+      script: { type: 'string', required: false, description: 'JS expression evaluated in the page (action=eval)' },
+      path: { type: 'string', required: false, description: 'Screenshot destination path (action=screenshot; default: OS temp dir)' },
+    },
+    async execute(params) {
+      return require('./browser').run(params);
+    }
+  },
   mcp: {
     name: 'mcp',
     description: 'Manage MCP (tool) servers for this workspace. Use when the user asks to add/remove/enable/disable an MCP server or connector (e.g. github, filesystem, gmail) or when a task requires tools the session does not have yet. In the TUI, hosting/cloud services (supabase, vercel, nextjs, railway, netlify, cloudflare) live under /connectors; dev-tool MCP servers (playwright, github, sentry, figma, postgres, mongodb, linear, slack, brave-search, exa, context7, filesystem, sqlite, puppeteer) live under /mcp. Common packages: Playwright=@playwright/mcp, Sentry=@sentry/mcp-server (needs --access-token TOKEN), Figma=figma-developer-mcp (env FIGMA_API_KEY), Postgres=@modelcontextprotocol/server-postgres (env DATABASE_URL), MongoDB=mongodb-mcp-server (env MONGODB_CONNECTION_STRING), Linear=linear-mcp-server (env LINEAR_API_KEY), Slack=@modelcontextprotocol/server-slack (env SLACK_BOT_TOKEN + SLACK_TEAM_ID), Brave=@modelcontextprotocol/server-brave-search (env BRAVE_API_KEY), Exa=exa-mcp-server (env EXA_API_KEY), Context7=@upstash/context7-mcp, Vercel=vercel-mcp-server (env VERCEL_TOKEN), Railway=@railway/mcp-server (env RAILWAY_API_TOKEN), Netlify=netlify-mcp-server (env NETLIFY_AUTH_TOKEN), Cloudflare=@cloudflare/mcp-server-cloudflare (env CLOUDFLARE_API_TOKEN + CLOUDFLARE_ACCOUNT_ID), Supabase=@supabase/mcp-server-supabase (needs --access-token TOKEN), GitHub=ghcr.io/github/github-mcp-server (docker). If unsure about an MCP package, verify it exists first with webfetch (e.g. https://registry.npmjs.org/<pkg>) or web search (fetch or bash curl) — never trust an unverified npm package.',

package/src/tui/App.tsx

@@ -464,12 +464,27 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
         // Keep the partial text in the bubble; the session already stored it,
         // so the user can type "continue" to resume the task.
         patchMessageAt(idx, { thinking: false, interrupted: true, thinkTime: Date.now() - t0, isError: false, parts: snapshotParts() });
-        appendMessage({ role: "system", content: "Interrupted \u2014 partial response kept. Type \"continue\" to resume the task." });
+        var keptChars = String(resp.content || "").length;
+        var inProgress = null;
+        var tdNow = sess.todos || [];
+        for (var ti = 0; ti < tdNow.length; ti++) { if (tdNow[ti].status === "in_progress") { inProgress = tdNow[ti]; break; } }
+        appendMessage({ role: "system", content: "Interrupted \u2014 kept " + keptChars + " chars of the partial response" + (inProgress ? " (in progress: " + inProgress.content + ")" : "") + ". Type \"continue\" to resume the task." });
       } else {
-        patchMessageAt(idx, { content: resp.content || "(no response)", thinking: false, thinkTime: Date.now() - t0, isError: isErr, parts: snapshotParts() });
+        patchMessageAt(idx, { content: resp.content || "(the model ended the turn without any text)", thinking: false, thinkTime: Date.now() - t0, isError: isErr, parts: snapshotParts() });
+        // Real leftovers, not a generic stop line: when the turn wrote todos
+        // and still has open ones, the session reports exactly which.
+        var openTodos = resp.openTodos;
+        if (!isErr && openTodos && openTodos.length) {
+          var openNames = [];
+          for (var oi = 0; oi < Math.min(openTodos.length, 8); oi++) openNames.push("- [" + openTodos[oi].status + "] " + openTodos[oi].content);
+          appendMessage({ role: "system", content: "Stopped with " + openTodos.length + " todo(s) still open:\n" + openNames.join("\n") + (openTodos.length > 8 ? "\n- \u2026" : "") + "\nSay \"continue\" to keep going." });
+        }
       }
       if (!isErr && sess.mode === "plan") {
-        appendMessage({ role: "system", content: "Plan complete \u2014 press Tab to switch to Build, then send \"go\" to execute." });
+        var plannedSteps = 0;
+        var planTodos = sess.todos || [];
+        for (var pi = 0; pi < planTodos.length; pi++) { if (planTodos[pi].status !== "completed" && planTodos[pi].status !== "cancelled") plannedSteps++; }
+        appendMessage({ role: "system", content: "Plan complete \u2014 " + (plannedSteps ? plannedSteps + " step(s) planned. " : "") + "press Tab to switch to Build, then send \"go\" to execute." });
       }
       setSpeedStats({ live: null, last: sess.getSpeed().last });
     }).catch(function(e) {
@@ -710,7 +725,7 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
           fsx.mkdirSync(dir, { recursive: true });
           const esc = (s: string) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
           const body = messages().map((m: any) => `<div class="m ${esc(m.role)}"><b>${esc(m.role)}</b><pre>${esc(String(m.content ?? ""))}</pre></div>`).join("\n");
-          const html = `<!doctype html><meta charset="utf-8"><title>Loom session</title><style>body{background:#191817;color:#e8e2d9;font-family:ui-monospace,monospace;max-width:900px;margin:2rem auto;padding:0 1rem}.m{border-left:3px solid #555;padding:.25rem .75rem;margin:.6rem 0}.m.user{border-color:#d7a35f}.m.assistant{border-color:#7aa2f7}.m.system{color:#9a938a}pre{white-space:pre-wrap;font-family:inherit;margin:.2rem 0}</style><h1>Loom Code session</h1>${body}`;
+          const html = `<!doctype html><meta charset="utf-8"><title>Loom session</title><style>body{background:#171512;color:#f2ede4;font-family:ui-monospace,monospace;max-width:900px;margin:2rem auto;padding:0 1rem}.m{border-left:3px solid #463f36;padding:.25rem .75rem;margin:.6rem 0}.m.user{border-color:#a8c496}.m.assistant{border-color:#e8845c}.m.system{color:#a89d8d}pre{white-space:pre-wrap;font-family:inherit;margin:.2rem 0}</style><h1>Loom Code session</h1>${body}`;
           const f = pathx.join(dir, (sessionId() || "session") + ".html");
           fsx.writeFileSync(f, html);
           showToast("Shared: " + f, "ok", 6000);