pelulu-cli 1.0.5 → 1.2.0

package/src/tools/agent.js

@@ -0,0 +1,80 @@
+/**
+ * Agent Tool — Expose agent capabilities (1 MCP tool, 5 actions)
+ * Actions: run, status, abort, reset, context
+ */
+import { bus } from '../core/event-bus.js';
+
+let agentController = null;
+
+export function setAgentController(controller) {
+  agentController = controller;
+}
+
+const ACTIONS = {
+  run: {
+    required: ['task'],
+    handler: async ({ task }) => {
+      if (!agentController) throw new Error('Agent not initialized');
+      const result = await agentController.run(task, { generatePlan: false });
+      return { success: result.success, result: result.result, iterations: result.iterations };
+    },
+  },
+
+  status: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      return agentController.summary;
+    },
+  },
+
+  abort: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      agentController.abort();
+      return { aborted: true };
+    },
+  },
+
+  reset: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      agentController.reset();
+      return { reset: true };
+    },
+  },
+
+  context: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      return { context: await agentController.getContext() };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'agent',
+  description: 'Agent: run task, status, abort, reset, context',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string' },
+      task: { type: 'string' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown: ${action}. Use: ${actionNames.join(', ')}`);
+    for (const f of a.required) {
+      if (params[f] === undefined) throw new Error(`Missing: ${f}`);
+    }
+    return a.handler(params);
+  },
+};

package/src/tools/file.js

@@ -46,13 +46,19 @@ const ACTIONS = {
   },
 
   edit: {
-    required: ['path', 'old_text', 'new_text'],
+    // new_text is intentionally NOT required: XiaoZhi (a voice model) often
+    // omits it — either it means "delete this text" or it dropped the field
+    // mid-call. Treating a missing/undefined new_text as an empty string keeps
+    // the edit working (as a deletion) instead of failing the whole turn with
+    // "Missing required field: new_text".
+    required: ['path', 'old_text'],
     handler: async ({ path, old_text, new_text }) => {
       const abs = safe(path);
+      const replacement = new_text ?? '';
       let content = await readFile(abs, 'utf-8');
       if (!content.includes(old_text)) throw new Error(`old_text not found in ${abs}`);
       const count = content.split(old_text).length - 1;
-      content = content.replace(old_text, new_text);
+      content = content.split(old_text).join(replacement);
       await writeFile(abs, content, 'utf-8');
       log('file', `[EDIT] Edited: ${abs} (${count} occurrence(s))`);
       return { path: abs, edited: true, occurrences: count };

package/src/tools/git.js

@@ -1,14 +1,18 @@
 /**
  * Git Tool — consolidated git operations (1 MCP tool, 10 actions)
  * Actions: init, clone, status, diff, log, add, commit, push, pull, branch
+ *
+ * Long-running operations (clone, push, pull) stream progress via task:progress
+ * so the TUI shows live feedback instead of appearing stuck.
  */
 import { exec } from 'child_process';
 import { log } from '../core/logger.js';
 import { getConfig } from '../core/config.js';
+import { bus } from '../core/event-bus.js';
 
-function git(cmd, cwd) {
+function git(cmd, cwd, { timeout = 60000 } = {}) {
   return new Promise((resolve, reject) => {
-    exec(`git ${cmd}`, { cwd, timeout: 30000, maxBuffer: 512 * 1024 }, (err, stdout, stderr) => {
+    exec(`git ${cmd}`, { cwd, timeout, maxBuffer: 512 * 1024 }, (err, stdout, stderr) => {
       if (err?.killed) return reject(new Error('Git timed out'));
       resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '', code: err?.code ?? 0 });
     });
@@ -17,6 +21,37 @@ function git(cmd, cwd) {
 
 function cwd(params) { return params?.cwd || getConfig().agent?.workspace || process.cwd(); }
 
+/**
+ * Run a git command with progress reporting. For operations that may take
+ * a while (clone, push, pull), emits task:progress events.
+ */
+async function gitWithProgress(cmd, dir, { label, timeout = 120000 } = {}) {
+  const started = Date.now();
+  const tag = label || `git ${cmd.split(' ')[0]}`;
+
+  bus.emit('task:progress', {
+    tool: 'git', running: true, phase: 'exec',
+    target: tag, elapsed: 0, log: `running: git ${cmd}`,
+  });
+
+  try {
+    const result = await git(cmd, dir, { timeout });
+    const elapsed = Math.round((Date.now() - started) / 1000);
+    bus.emit('task:progress', {
+      tool: 'git', running: false, phase: 'done',
+      target: tag, elapsed, log: result.code === 0 ? 'completed' : `exit ${result.code}`,
+    });
+    return result;
+  } catch (err) {
+    bus.emit('task:progress', {
+      tool: 'git', running: false, phase: 'error',
+      target: tag, elapsed: Math.round((Date.now() - started) / 1000),
+      log: err.message,
+    });
+    throw err;
+  }
+}
+
 const ACTIONS = {
   init: {
     required: [],
@@ -31,7 +66,12 @@ const ACTIONS = {
     required: ['url'],
     handler: async ({ url, path, branch }) => {
       const cmd = `clone${branch ? ` -b ${branch}` : ''} "${url}"${path ? ` "${path}"` : ''}`;
-      await git(cmd);
+      log('git', `[CLONE] ${url}`);
+      const result = await gitWithProgress(cmd, undefined, {
+        label: `clone ${url.split('/').pop()?.replace('.git', '') || url}`,
+        timeout: 120000,
+      });
+      if (result.code !== 0) throw new Error(result.stderr || 'clone failed');
       return { cloned: true, url, path: path || url.split('/').pop()?.replace('.git', '') };
     },
   },
@@ -85,7 +125,7 @@ const ACTIONS = {
       const msg = params.message.replace(/"/g, '\\"');
       const r = await git(`commit -m "${msg}"`, dir);
       if (r.code !== 0 && r.stderr.includes('nothing to commit')) return { committed: false, reason: 'nothing to commit' };
-      log('git', `[EDIT] Committed: ${params.message}`);
+      log('git', `[COMMIT] ${params.message}`);
       return { committed: true, message: params.message, output: r.stdout.slice(-300) };
     },
   },
@@ -96,7 +136,12 @@ const ACTIONS = {
       const dir = cwd(params);
       const remote = params.remote || '';
       const branch = params.branch || '';
-      const r = await git(`push ${remote} ${branch}`.trim(), dir);
+      log('git', `[PUSH] ${remote} ${branch}`);
+      const r = await gitWithProgress(`push ${remote} ${branch}`.trim(), dir, {
+        label: `push ${remote || 'origin'} ${branch || 'current'}`,
+        timeout: 60000,
+      });
+      if (r.code !== 0) throw new Error(r.stderr || 'push failed');
       return { pushed: true, output: r.stdout.slice(-300) || r.stderr.slice(-300) };
     },
   },
@@ -107,7 +152,12 @@ const ACTIONS = {
       const dir = cwd(params);
       const remote = params.remote || '';
       const branch = params.branch || '';
-      const r = await git(`pull ${remote} ${branch}`.trim(), dir);
+      log('git', `[PULL] ${remote} ${branch}`);
+      const r = await gitWithProgress(`pull ${remote} ${branch}`.trim(), dir, {
+        label: `pull ${remote || 'origin'} ${branch || 'current'}`,
+        timeout: 60000,
+      });
+      if (r.code !== 0) throw new Error(r.stderr || 'pull failed');
       return { pulled: true, output: r.stdout.slice(-300) };
     },
   },

package/src/tools/jobs.js

@@ -0,0 +1,93 @@
+/**
+ * jobs — universal poll interface for background tool runs.
+ *
+ * Any tool action that takes longer than the grace window is turned into a
+ * background job (see core/job-manager.js). This tool is how the AI keeps
+ * track of them so it never assumes a still-running action "timed out":
+ *
+ *   jobs { action: "list" }                 -> all recent jobs + their status
+ *   jobs { action: "status", id: "job_x" }  -> one job (or the latest if no id)
+ *   jobs { action: "wait",   id: "job_x" }  -> wait briefly for it to finish
+ *   jobs { action: "result", id: "job_x" }  -> the finished job's result payload
+ *   jobs { action: "cancel", id: "job_x" }  -> request cancellation
+ */
+import { jobManager } from '../core/job-manager.js';
+
+function describe(job) {
+  if (!job) return null;
+  const snap = jobManager.snapshot(job);
+  return {
+    ...snap,
+    hint:
+      snap.status === 'running'
+        ? `Still running (${snap.elapsed_s}s). Poll again with action=status id=${snap.id}, or action=wait.`
+        : snap.status === 'done'
+          ? `Finished in ${snap.elapsed_s}s. Use action=result id=${snap.id} to read the output.`
+          : `${snap.status}.`,
+  };
+}
+
+const ACTIONS = {
+  list: () => {
+    const jobs = jobManager.list().map(describe);
+    const running = jobs.filter((j) => j.status === 'running').length;
+    return {
+      total: jobs.length,
+      running,
+      message: running
+        ? `${running} job(s) still running. Poll them with action=status.`
+        : 'No jobs are currently running.',
+      jobs: jobs.slice(-15),
+    };
+  },
+
+  status: ({ id }) => {
+    const job = id ? jobManager.get(id) : jobManager.latest();
+    if (!job) return { status: 'none', message: 'No jobs yet. Start a tool action first.' };
+    return describe(job);
+  },
+
+  wait: async ({ id, timeout }) => {
+    const target = id ? jobManager.get(id) : jobManager.latest();
+    if (!target) return { status: 'none', message: 'No jobs to wait for.' };
+    const ms = Math.min(Math.max(Number(timeout) || 20000, 1000), 25000); // capped < XiaoZhi timeout
+    const job = await jobManager.wait(target.id, ms);
+    const out = describe(job);
+    if (job.status === 'running') out.message = `Still running after ${Math.round(ms / 1000)}s — poll again or action=wait.`;
+    return out;
+  },
+
+  result: ({ id }) => {
+    const job = id ? jobManager.get(id) : jobManager.latest();
+    if (!job) return { status: 'none', message: 'No jobs yet.' };
+    if (job.status === 'running') return { ...describe(job), message: 'Not finished yet — use action=wait first.' };
+    return { id: job.id, tool: job.tool, action: job.action, status: job.status, error: job.error || undefined, result: job.result };
+  },
+
+  cancel: ({ id }) => {
+    const job = id ? jobManager.get(id) : jobManager.latest();
+    if (!job) return { status: 'none', message: 'No job to cancel.' };
+    const ok = jobManager.cancel(job.id);
+    return { id: job.id, cancelled: ok, message: ok ? 'Cancellation requested.' : `Job is already ${job.status}.` };
+  },
+};
+
+export default {
+  name: 'jobs',
+  description: 'Track background tool jobs so long-running actions never look timed out. Actions: list, status, wait, result, cancel.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['list', 'status', 'wait', 'result', 'cancel'] },
+      id: { type: 'string', description: 'Job id (defaults to the latest job)' },
+      timeout: { type: 'number', description: 'wait: max ms to block (<=25000)' },
+    },
+    required: ['action'],
+  },
+  async handler(args = {}) {
+    const action = args.action || 'status';
+    const fn = ACTIONS[action];
+    if (!fn) return { error: `Unknown action "${action}". Use: ${Object.keys(ACTIONS).join(', ')}` };
+    return await fn(args);
+  },
+};

package/src/tools/network.js

@@ -7,46 +7,79 @@ import { exec } from 'child_process';
 import { createWriteStream } from 'fs';
 import { pipeline } from 'stream/promises';
 import { log } from '../core/logger.js';
-
-function httpGet(url, maxChars = 5000) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
-    client.get(url, { timeout: 15000, headers: { 'User-Agent': 'coding-agent/1.0' } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        return httpGet(res.headers.location, maxChars).then(resolve, reject);
-      }
-      let d = '';
-      res.on('data', c => { if (d.length < maxChars) d += c; });
-      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: d }));
-    }).on('error', reject);
-  });
-}
+import { request as httpClientRequest } from '../core/http-client.js';
+import { bus } from '../core/event-bus.js';
 
 const ACTIONS = {
   async fetch({ url, method, body, headers }) {
     if (!url) throw new Error('url required');
-    log('network', `[WEB] ${method || 'GET'} ${url}`);
-    const result = await httpGet(url);
-    return { url, status: result.status, body: result.body.slice(0, 5000) };
+    const m = method || 'GET';
+    log('network', `[WEB] ${m} ${url}`);
+    const r = await httpClientRequest(url, { method: m, body, headers: headers || {}, timeout: 15000, followRedirects: true, maxBody: 200000 });
+    return {
+      url: r.finalUrl || url, status: r.status, headers: r.headers,
+      redirects: r.redirectChain, duration_ms: r.duration_ms,
+      body: r.body.slice(0, 8000), body_length: r.bytes,
+    };
   },
 
   async download({ url, path }) {
     if (!url || !path) throw new Error('url and path required');
-    log('network', `📥 Downloading: ${url}`);
+    log('network', `[DL] Downloading: ${url}`);
+    const started = Date.now();
     const client = url.startsWith('https') ? https : http;
+
+    bus.emit('task:progress', {
+      tool: 'network', running: true, phase: 'download',
+      target: url, elapsed: 0, log: 'starting download',
+    });
+
     return new Promise((resolve, reject) => {
-      client.get(url, { timeout: 30000, headers: { 'User-Agent': 'coding-agent/1.0' } }, async (res) => {
+      client.get(url, { timeout: 60000, headers: { 'User-Agent': 'pelulu-cli/1.0' } }, async (res) => {
         if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
           try { resolve(await ACTIONS.download({ url: res.headers.location, path })); } catch (e) { reject(e); }
           return;
         }
-        if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+        if (res.statusCode !== 200) {
+          bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: `HTTP ${res.statusCode}` });
+          return reject(new Error(`HTTP ${res.statusCode}`));
+        }
+        const totalBytes = parseInt(res.headers['content-length'] || '0', 10);
+        let downloaded = 0;
+        let lastReport = 0;
+
+        // Track download progress
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          const now = Date.now();
+          if (now - lastReport > 2000) { // report every 2s
+            lastReport = now;
+            const elapsed = Math.round((now - started) / 1000);
+            const pct = totalBytes ? `${Math.round(downloaded / totalBytes * 100)}%` : `${Math.round(downloaded / 1024)}KB`;
+            bus.emit('task:progress', {
+              tool: 'network', running: true, phase: 'download',
+              target: url, elapsed, log: `${pct} downloaded`,
+            });
+          }
+        });
+
         const ws = createWriteStream(path);
         try {
           await pipeline(res, ws);
-          resolve({ downloaded: true, path, url });
-        } catch (e) { reject(e); }
-      }).on('error', reject);
+          const elapsed = Math.round((Date.now() - started) / 1000);
+          bus.emit('task:progress', {
+            tool: 'network', running: false, phase: 'done',
+            target: url, elapsed, log: `${Math.round(downloaded / 1024)}KB saved`,
+          });
+          resolve({ downloaded: true, path, url, bytes: downloaded, elapsed_s: elapsed });
+        } catch (e) {
+          bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: e.message });
+          reject(e);
+        }
+      }).on('error', (e) => {
+        bus.emit('task:progress', { tool: 'network', running: false, phase: 'error', target: url, log: e.message });
+        reject(e);
+      });
     });
   },
 

package/src/tools/project.js

@@ -1,6 +1,9 @@
 /**
  * Project Tool — project lifecycle operations (1 MCP tool, 6 actions)
  * Actions: init, build, test, lint, deps, info
+ *
+ * Long-running operations (build, test, deps) stream progress via task:progress
+ * so the TUI shows live feedback instead of appearing stuck.
  */
 import { exec } from 'child_process';
 import { readFile } from 'fs/promises';
@@ -8,6 +11,7 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { log } from '../core/logger.js';
 import { getConfig } from '../core/config.js';
+import { bus } from '../core/event-bus.js';
 
 function run(cmd, cwd, timeout = 120000) {
   return new Promise((resolve, reject) => {
@@ -18,6 +22,35 @@ function run(cmd, cwd, timeout = 120000) {
   });
 }
 
+/**
+ * Run a command with progress reporting for long operations.
+ */
+async function runWithProgress(cmd, dir, { label, timeout = 120000 } = {}) {
+  const started = Date.now();
+  bus.emit('task:progress', {
+    tool: 'project', running: true, phase: 'exec',
+    target: label || cmd.split(' ')[0], elapsed: 0, log: `running: ${cmd}`,
+  });
+
+  try {
+    const result = await run(cmd, dir, timeout);
+    const elapsed = Math.round((Date.now() - started) / 1000);
+    bus.emit('task:progress', {
+      tool: 'project', running: false, phase: 'done',
+      target: label || cmd.split(' ')[0], elapsed,
+      log: result.code === 0 ? 'completed' : `exit ${result.code}`,
+    });
+    return result;
+  } catch (err) {
+    bus.emit('task:progress', {
+      tool: 'project', running: false, phase: 'error',
+      target: label || cmd.split(' ')[0],
+      elapsed: Math.round((Date.now() - started) / 1000), log: err.message,
+    });
+    throw err;
+  }
+}
+
 function cwd(p) { return p || getConfig().agent?.workspace || process.cwd(); }
 
 async function detectProject(dir) {
@@ -58,7 +91,7 @@ const ACTIONS = {
       const cmd = BUILD_CMD[type];
       if (!cmd) throw new Error(`No build for ${type}`);
       log('project', `[BUILD] Building (${type})...`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `build (${type})`, timeout: 180000 });
       return { success: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-500) || r.stderr.slice(-500) };
     },
   },
@@ -71,7 +104,7 @@ const ACTIONS = {
       const cmd = TEST_CMD[type];
       if (!cmd) throw new Error(`No test for ${type}`);
       log('project', `[TEST] Testing (${type})...`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `test (${type})`, timeout: 180000 });
       return { passed: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-1000) || r.stderr.slice(-1000) };
     },
   },
@@ -83,7 +116,7 @@ const ACTIONS = {
       const type = await detectProject(dir);
       const cmd = LINT_CMD[type];
       if (!cmd) throw new Error(`No lint for ${type}`);
-      const r = await run(cmd, dir);
+      const r = await runWithProgress(cmd, dir, { label: `lint (${type})` });
       return { type, issues: r.stdout.slice(-2000) };
     },
   },
@@ -96,7 +129,8 @@ const ACTIONS = {
       if (params.install) {
         const cmd = INSTALL_CMD[type];
         if (!cmd) throw new Error(`No install for ${type}`);
-        await run(cmd, dir, 180000);
+        log('project', `[DEPS] Installing (${type})...`);
+        await runWithProgress(cmd, dir, { label: `deps install (${type})`, timeout: 180000 });
         return { installed: true, type };
       }
       try {

package/src/tools/search.js

@@ -3,9 +3,9 @@
  * Actions: grep, find, web
  */
 import { exec } from 'child_process';
-import https from 'https';
-import http from 'http';
 import { log } from '../core/logger.js';
+import { request as httpClientRequest } from '../core/http-client.js';
+import { bus } from '../core/event-bus.js';
 
 function runCmd(cmd, timeout = 10000) {
   return new Promise((resolve) => {
@@ -15,18 +15,10 @@ function runCmd(cmd, timeout = 10000) {
   });
 }
 
-function httpGet(url, maxChars = 8000) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
-    client.get(url, { timeout: 15000, headers: { 'User-Agent': 'coding-agent/1.0' } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        return httpGet(res.headers.location, maxChars).then(resolve, reject);
-      }
-      let d = '';
-      res.on('data', c => { if (d.length < maxChars) d += c; });
-      res.on('end', () => resolve({ status: res.statusCode, body: d }));
-    }).on('error', reject);
-  });
+// Delegates to the shared HTTP engine (gzip-aware, follows redirects).
+async function httpGet(url, maxChars = 8000) {
+  const r = await httpClientRequest(url, { timeout: 15000, followRedirects: true, maxBody: Math.max(maxChars, 8000) });
+  return { status: r.status, body: r.body.slice(0, maxChars) };
 }
 
 const ACTIONS = {
@@ -40,7 +32,9 @@ const ACTIONS = {
       const inc = include ? `--include="*.${include}"` : '';
       const ctx = context ? `-C ${context}` : '';
       const cmd = `grep ${flags}${ic} ${inc} ${ctx} "${pattern}" "${path || '.'}" 2>/dev/null | head -100`;
+      bus.emit('task:progress', { tool: 'search', running: true, phase: 'grep', target: path || '.', log: `searching: ${pattern}` });
       const r = await runCmd(cmd);
+      bus.emit('task:progress', { tool: 'search', running: false, phase: 'done', target: path || '.' });
       const lines = r.stdout.split('\n').filter(Boolean);
       return { pattern, matches: lines.length, results: lines };
     },
@@ -52,7 +46,9 @@ const ACTIONS = {
       log('search', `[FIND] find: ${name}`);
       const t = type ? `-type ${type}` : '';
       const cmd = `find "${path || '.'}" ${t} -name "${name}" 2>/dev/null | head -50`;
+      bus.emit('task:progress', { tool: 'search', running: true, phase: 'find', target: path || '.', log: `finding: ${name}` });
       const r = await runCmd(cmd);
+      bus.emit('task:progress', { tool: 'search', running: false, phase: 'done', target: path || '.' });
       return { pattern: name, matches: r.stdout.split('\n').filter(Boolean).length, files: r.stdout.split('\n').filter(Boolean) };
     },
   },

package/src/tools/shell.js

@@ -1,15 +1,76 @@
 /**
  * Shell Tool — consolidated shell operations (1 MCP tool, 4 actions)
  * Actions: exec, bg, ps, kill
+ *
+ * Long-running commands are streamable: stdout/stderr are captured in chunks
+ * and reported via task:progress so the TUI can show live output. The job
+ * layer (core/job-manager.js) auto-backgrounds anything > 8s.
  */
 import { exec, spawn } from 'child_process';
 import { log } from '../core/logger.js';
 import { getConfig } from '../core/config.js';
+import { bus } from '../core/event-bus.js';
+import { jobManager } from '../core/job-manager.js';
 
 const BLOCKED = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=.*of=\/dev/, /chmod\s+777\s+\//];
 
 function isBlocked(cmd) { return BLOCKED.some(re => re.test(cmd)); }
 
+/**
+ * Run a command with streaming progress. Emits task:progress on each chunk
+ * so the TUI shows live output instead of waiting for the full result.
+ */
+function runStreaming(cmd, timeout, { label } = {}) {
+  return new Promise((resolve, reject) => {
+    if (isBlocked(cmd)) return reject(new Error('Blocked: dangerous command'));
+    const cfg = getConfig();
+    const t = timeout || cfg.tools?.shell_timeout || 30000;
+    const started = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let chunkCount = 0;
+
+    const child = spawn('bash', ['-c', cmd], {
+      timeout: t,
+      maxBuffer: 1024 * 1024,
+      env: { ...process.env, FORCE_COLOR: '0' },
+    });
+
+    child.stdout?.on('data', (d) => {
+      stdout += d;
+      chunkCount++;
+      if (chunkCount % 5 === 0) {
+        bus.emit('task:progress', {
+          tool: 'shell', running: true,
+          phase: 'exec', target: label || cmd.slice(0, 60),
+          elapsed: Math.round((Date.now() - started) / 1000),
+          log: `${stdout.length + stderr.length} bytes captured`,
+        });
+      }
+    });
+
+    child.stderr?.on('data', (d) => {
+      stderr += d;
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0 && !stdout && stderr) {
+        reject(new Error(stderr.trim().slice(0, 500)));
+      } else {
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code: code ?? 0 });
+      }
+    });
+
+    // Timeout guard
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`Timed out after ${t}ms`));
+    }, t);
+    child.on('close', () => clearTimeout(timer));
+  });
+}
+
 function run(cmd, timeout) {
   return new Promise((resolve, reject) => {
     if (isBlocked(cmd)) return reject(new Error('Blocked: dangerous command'));
@@ -26,9 +87,14 @@ const ACTIONS = {
   exec: {
     required: ['command'],
     handler: async ({ command, timeout }) => {
-      log('shell', `[CFG] $ ${command}`);
-      const result = await run(command, timeout);
-      const maxLen = getConfig().tools?.max_output || 10000;
+      log('shell', `[EXEC] $ ${command}`);
+      // Use streaming for commands that might take a while
+      const cfg = getConfig();
+      const t = timeout || cfg.tools?.shell_timeout || 30000;
+      const result = t > 10000
+        ? await runStreaming(command, timeout, { label: command.slice(0, 60) })
+        : await run(command, timeout);
+      const maxLen = cfg.tools?.max_output || 10000;
       return { stdout: result.stdout.slice(0, maxLen), stderr: result.stderr.slice(0, 2000), exitCode: result.code };
     },
   },
@@ -36,7 +102,7 @@ const ACTIONS = {
   bg: {
     required: ['command'],
     handler: async ({ command }) => {
-      log('shell', `[CFG] [bg] $ ${command}`);
+      log('shell', `[BG] $ ${command}`);
       const child = spawn('bash', ['-c', command], { detached: true, stdio: 'ignore' });
       child.unref();
       return { pid: child.pid, background: true, command };