autoclaw 1.1.1 → 1.3.0

package/README.md

@@ -30,11 +30,14 @@ Unlike "screen-seeing" agents (such as OpenClaw) that rely on visual interpretat
 
 ## Features
 
-- 📜 **Headless Execution**: No browsers, no GUIs. Pure terminal efficiency.
+- 📜 **Headless Execution**: No GUI required — pure terminal efficiency. Core operation is shell + file I/O; the optional web tools run in headless Chromium.
 - 🤖 **Non-Interactive Mode**: Intelligent flag handling (`-y`, `--no-interactive`) for zero-touch automation.
 - 📂 **Universal Control**: From simple file I/O to complex system administration.
-- 🧠 **Context Aware**: Detects container environments and provides accurate system time for relative date queries.
+- 🛡️ **Runaway Protection**: Max-step cap per task, API retries with exponential backoff, shell command timeouts, and tool output truncation to keep the model context bounded.
+- 🧠 **Context Aware**: Provides accurate OS, system and time context so relative dates ("today", "next Monday") are handled correctly.
 - 🌐 **Web Search**: Integrated with Tavily for real-time information retrieval.
+- 🌍 **Web Reading & Screenshots**: Extract article content and capture page screenshots (requires `npx playwright install chromium`).
+- 🎨 **Image Generation**: DALL-E compatible image generation via any OpenAI-compatible images API.
 - 🕒 **Time Accuracy**: Built-in tool to get precise system date and time for correct temporal context.
 - 📧 **Communication**: Send emails and push notifications to chat groups automatically.
 
@@ -43,7 +46,8 @@ Unlike "screen-seeing" agents (such as OpenClaw) that rely on visual interpretat
 - **Language**: TypeScript
 - **Framework**: Commander.js
 - **UI**: Inquirer (interactivity), Chalk (styling), Ora (spinners)
-- **AI**: OpenAI SDK (Compatible with DeepSeek, LocalLLM, etc.)
+- **AI**: OpenAI SDK (any OpenAI-compatible endpoint: DeepSeek, Kimi, Qwen, GLM, Ollama, …)
+- **Web tools**: Playwright (headless Chromium for `read_website` / `take_screenshot`)
 
 ## Installation
 
@@ -91,12 +95,31 @@ Simply run `autoclaw` to enter the chat loop.
 autoclaw
 > List all TypeScript files in the src folder.
 ```
+Interactive commands: `exit` / `quit` to leave, and `/view` to open the full output of the last tool result in a pager — tool output longer than 20 lines is folded on screen and saved to `~/.autoclaw/output/`.
 
 ### Headless Mode (One-Shot)
 Run a single command and exit.
 ```bash
 autoclaw "Check disk usage and save the report to usage.txt" --no-interactive
 ```
+The exit code reports the outcome for orchestrators: `0` completed, `1` hard failure (e.g. API error), `2` step cap reached (task unfinished).
+
+### Machine-Readable Output (--json)
+Add `--json` to print one JSON event per line on stdout (run_start, tool_call, tool_result, usage, run_end); human output moves to stderr, including anything tools print themselves.
+```bash
+autoclaw "Deploy and report" -y -n --json
+```
+Token usage is collected only when `AUTOCLOW_INCLUDE_USAGE=1` (or `true`) is set — it is opt-in because not every OpenAI-compatible provider accepts `stream_options.include_usage`.
+
+### Batch Mode (Swarm Worker)
+Feed a JSONL manifest of tasks; each task runs in a fresh, isolated agent (one task's context never leaks into another) and per-task results are written as JSONL:
+```bash
+autoclaw batch tasks.jsonl -y                          # results -> tasks.results.jsonl
+autoclaw batch tasks.jsonl -o out.jsonl --fail-fast
+```
+Manifest lines are `{"id": "...", "task": "..."}` — `id` is optional (defaults to `task-N`); blank lines and `#` comments are skipped. Optional per-task overrides: `maxSteps`, `model`, `provider`.
+
+One failing task does not stop the batch (use `--fail-fast` for that). The process exits `0` when every task completed, `1` otherwise, so cron and K8s Jobs can detect bad batches. Task output stays human-readable on stdout — the results file is the machine-readable contract, with `status`, `steps`, `message`, `error` and `usage` per task.
 
 ### Auto-Confirm (CI/CD)
 Automatically approve all tool executions (dangerous, use with caution or in sandboxes).
@@ -105,24 +128,36 @@ autoclaw "Refactor src/index.ts to use ES modules" -y
 ```
 
 ### CLI Options
-- `-m, --model <model>`: Specify the LLM model (default: `gpt-4o`).
+- `-m, --model <model>`: Specify the LLM model (default: `gpt-5.6`).
+- `-P, --provider <name>`: Use a provider preset (see [Providers](#providers)).
 - `-n, --no-interactive`: Exit after processing the initial query (Headless mode).
 - `-y, --yes`: Auto-confirm all tool executions (e.g., shell commands).
+- `--json`: Emit NDJSON events on stdout (for orchestrators; use with `-n`).
+
+### Providers
+AutoClaw works with any OpenAI-compatible endpoint. Built-in presets fill in the base URL and a default model for you:
+```bash
+autoclaw -P deepseek "Check disk usage and save a report" -y -n
+```
+Available presets: `openai`, `deepseek`, `moonshot` (Kimi), `dashscope` (Qwen), `zhipu` (GLM), `openrouter`, `ollama` (local). You can still override the model with `-m` or config. When `OPENAI_API_KEY` is not set, the API key is read from the provider's own env var (e.g. `DEEPSEEK_API_KEY`, `MOONSHOT_API_KEY`, `DASHSCOPE_API_KEY`, `ZHIPU_API_KEY`, `OPENROUTER_API_KEY`).
 
 ## Configuration
 
 AutoClaw uses a hierarchical configuration system.
 
 **Priority Order (Highest to Lowest):**
-1.  **CLI Arguments**: (e.g., `-m gpt-4o`)
+1.  **CLI Arguments**: (e.g., `-m gpt-5.6`)
 2.  **Environment Variables**: (`OPENAI_API_KEY`, `.env` file)
 3.  **Project Config**: (`./.autoclaw/setting.json` in current directory)
 4.  **Global Config**: (`~/.autoclaw/setting.json`)
 
 ### Supported Configuration Keys (JSON)
+- `provider`: Provider preset name (e.g. `deepseek`).
 - `apiKey`: Your OpenAI API Key.
 - `baseUrl`: Custom Base URL (e.g., for DeepSeek or LocalLLM).
 - `model`: Default model to use.
+- `maxSteps`: Max LLM turns per task before the agent stops (default: `25`).
+- `shellTimeout`: Shell command timeout in milliseconds (default: `120000`).
 - `tavilyApiKey`: API Key for Tavily Web Search.
 - `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP Email settings.
 - `feishuWebhook`, `dingtalkWebhook`, `wecomWebhook`: Notification webhooks.
@@ -131,13 +166,20 @@ AutoClaw uses a hierarchical configuration system.
 Create a file at `.autoclaw/setting.json`:
 ```json
 {
-  "model": "gpt-3.5-turbo",
+  "model": "gpt-5.6",
   "baseUrl": "https://api.deepseek.com/v1"
 }
 ```
 
 > **⚠️ Security Warning**: If you store your `apiKey` or secrets in `.autoclaw/setting.json`, make sure to add `.autoclaw/` to your `.gitignore` file to prevent leaking secrets!
 
+### Environment Variables
+- `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`: main LLM settings.
+- `AUTOCLOW_PROVIDER`: provider preset used when `-P` is not passed.
+- `AUTOCLOW_MAX_STEPS`, `AUTOCLOW_SHELL_TIMEOUT`: reliability limits (max LLM turns per task; shell timeout in ms).
+- `AUTOCLOW_INCLUDE_USAGE`: set to `1`/`true` to request token usage from the API (opt-in).
+- `TAVILY_API_KEY`, `SMTP_HOST`/`SMTP_PORT`/`SMTP_USER`/`SMTP_PASS`, `FEISHU_WEBHOOK`/`FEISHU_KEYWORD`, `DINGTALK_WEBHOOK`/`DINGTALK_KEYWORD`, `WECOM_WEBHOOK`/`WECOM_KEYWORD`: tool credentials as an alternative to setup.
+
 ## Integrations
 
 ### Web Search (Tavily)
@@ -158,6 +200,14 @@ Built-in utility to provide the agent with the current system time, ensuring acc
 
 ## Docker Support
 
+### Build & Run
+The repository ships a multi-stage `Dockerfile` (node:22-alpine, browser downloads skipped to keep the image slim). The container runs headless one-shot tasks against the mounted directory:
+```bash
+docker build -t autoclaw .
+docker run --rm -v "$PWD":/workspace -w /workspace -e OPENAI_API_KEY=sk-... autoclaw "Check disk usage and save a report" -y -n
+```
+Note: browser-based tools (`read_website` / `take_screenshot`) are not functional in the default image since browsers are not bundled — they return a friendly install hint instead.
+
 ### Chinese Font Issues in Screenshots
 When running AutoClaw inside a Docker container (especially Alpine or Debian Slim), screenshots of Chinese websites may display text as square boxes ("tofu") due to missing fonts. Emojis (e.g., 🔥) may also appear as squares.
 

package/README.zh-CN.md

@@ -31,11 +31,14 @@ AutoClaw 是一款针对 **“无界面系统” (Headless Systems)** 的高稳
 
 ## 特性
 
-- 📜 **无头执行 (Headless Execution)**: 真正的无头模式，无需浏览器或图形化界面。
+- 📜 **无头执行 (Headless Execution)**: 无需图形界面，纯终端运行。核心流程仅依赖 Shell 与文件操作；可选的网页工具在无头 Chromium 中运行。
 - 🤖 **非交互模式**: 支持自动化标志（`-y`, `--no-interactive`），完美适配零干预的自动化流程。
-- 📂 **全方位控制 (Universal Control)**: 从基础的文件 I/O 到复杂的系统管理与代码重构。
-- 🧠 **上下文感知 (Context Aware)**: 自动识别操作系统与容器环境，并提供精确的系统时间以处理相对时间查询。
+- 📂 **全方位控制 (Universal Control)**: 从基础的文件 I/O 到复杂的系统管理。
+- 🛡️ **防失控保护**: 单任务步数上限、API 指数退避重试、Shell 命令超时、工具输出截断，保证模型上下文不被撑爆。
+- 🧠 **上下文感知 (Context Aware)**: 提供精确的操作系统与时间上下文，正确处理"今天"、"下周一"等相对时间。
 - 🌐 **网页搜索**: 集成 Tavily，支持实时信息检索。
+- 🌍 **网页阅读与截图**: 提取文章正文、截取页面图片（需先执行 `npx playwright install chromium`）。
+- 🎨 **图像生成**: 通过任意 OpenAI 兼容的图像接口生成图片（兼容 DALL-E）。
 - 🕒 **时间精准**: 内置工具获取精确系统日期和时间，确保正确的时间上下文。
 - 📧 **通讯能力**: 自动发送电子邮件并将通知推送至聊天群组。
 
@@ -44,7 +47,8 @@ AutoClaw 是一款针对 **“无界面系统” (Headless Systems)** 的高稳
 - **语言**: TypeScript
 - **框架**: Commander.js
 - **UI**: Inquirer (交互), Chalk (样式), Ora (加载动画)
-- **AI**: OpenAI SDK (兼容 DeepSeek, LocalLLM 等)
+- **AI**: OpenAI SDK（任意 OpenAI 兼容端点：DeepSeek、Kimi、Qwen、GLM、Ollama 等）
+- **网页工具**: Playwright（无头 Chromium，用于 `read_website` / `take_screenshot`）
 
 ## 安装
 
@@ -92,12 +96,31 @@ npm install -g autoclaw
 autoclaw
 > 列出 src 文件夹中所有的 TypeScript 文件。
 ```
+交互命令：`exit` / `quit` 退出；`/view` 用分页器查看上一次工具的完整输出——超过 20 行的工具输出会在屏幕上折叠，并保存到 `~/.autoclaw/output/`。
 
 ### 无头模式 (一次性任务)
 执行单个指令后立即退出。
 ```bash
 autoclaw "检查磁盘使用情况并将报告保存到 usage.txt" --no-interactive
 ```
+退出码向编排器报告结果：`0` 完成，`1` 硬性失败（如 API 错误），`2` 触发步数上限（任务未完成）。
+
+### 机器可读输出 (--json)
+加 `--json` 后，stdout 每行输出一个 JSON 事件（run_start、tool_call、tool_result、usage、run_end）；人类可读输出（包括工具自己打印的内容）全部转到 stderr。
+```bash
+autoclaw "执行部署并汇报" -y -n --json
+```
+Token 用量仅在设置 `AUTOCLOW_INCLUDE_USAGE=1`（或 `true`）时才收集——这是可选项，因为并非所有 OpenAI 兼容端点都接受 `stream_options.include_usage`。
+
+### 批处理模式 (蜂群工人)
+把 JSONL 任务清单交给 AutoClaw；每个任务在全新的隔离 Agent 中执行（任务之间上下文互不污染），结果逐行写入 JSONL 文件：
+```bash
+autoclaw batch tasks.jsonl -y                          # 结果 -> tasks.results.jsonl
+autoclaw batch tasks.jsonl -o out.jsonl --fail-fast
+```
+清单每行为 `{"id": "...", "task": "..."}`——`id` 可省略（默认 `task-N`）；空行和 `#` 注释行会跳过。可选的每任务覆盖项：`maxSteps`、`model`、`provider`。
+
+单个任务失败不会中断批次（需要中断用 `--fail-fast`）。全部完成时进程退出 `0`，否则 `1`，cron 和 K8s Job 由此感知批次成败。任务输出保持人类可读——结果文件才是机器可读契约，含每个任务的 `status`、`steps`、`message`、`error`、`usage`。
 
 ### 自动确认 (CI/CD)
 自动批准所有工具执行（危险操作，请谨慎使用或在沙箱环境下运行）。
@@ -106,24 +129,36 @@ autoclaw "将 src/index.ts 重构为使用 ES 模块" -y
 ```
 
 ### CLI 选项
-- `-m, --model <model>`: 指定 LLM 模型 (默认: `gpt-4o`)。
+- `-m, --model <model>`: 指定 LLM 模型 (默认: `gpt-5.6`)。
+- `-P, --provider <name>`: 使用 provider 预设 (见 [Provider 预设](#provider-预设))。
 - `-n, --no-interactive`: 处理完初始查询后退出 (无头模式)。
 - `-y, --yes`: 自动确认所有工具执行 (例如 Shell 命令)。
+- `--json`: 在 stdout 输出 NDJSON 事件流 (供编排器使用,配合 `-n`)。
+
+### Provider 预设
+AutoClaw 可对接任意 OpenAI 兼容端点。内置预设可自动填好 Base URL 和默认模型：
+```bash
+autoclaw -P deepseek "检查磁盘使用情况并保存报告" -y -n
+```
+可用预设：`openai`、`deepseek`、`moonshot` (Kimi)、`dashscope` (Qwen)、`zhipu` (GLM)、`openrouter`、`ollama` (本地)。模型仍可用 `-m` 或配置覆盖。未设置 `OPENAI_API_KEY` 时，会自动读取各家自己的环境变量 (如 `DEEPSEEK_API_KEY`、`MOONSHOT_API_KEY`、`DASHSCOPE_API_KEY`、`ZHIPU_API_KEY`、`OPENROUTER_API_KEY`)。
 
 ## 配置
 
 AutoClaw 使用层级配置系统。
 
 **优先级排序 (从高到低):**
-1.  **CLI 参数**: (例如 `-m gpt-4o`)
+1.  **CLI 参数**: (例如 `-m gpt-5.6`)
 2.  **环境变量**: (`OPENAI_API_KEY`, `.env` 文件)
 3.  **项目配置**: (当前目录下的 `./.autoclaw/setting.json`)
 4.  **全局配置**: (`~/.autoclaw/setting.json`)
 
 ### 支持的配置键 (JSON)
+- `provider`: Provider 预设名 (如 `deepseek`)。
 - `apiKey`: 您的 OpenAI API 密钥。
 - `baseUrl`: 自定义 API 基础地址 (例如 DeepSeek 或本地 LLM)。
 - `model`: 默认使用的模型。
+- `maxSteps`: 单任务最大 LLM 轮数，超出后自动停止 (默认: `25`)。
+- `shellTimeout`: Shell 命令超时时间（毫秒）(默认: `120000`)。
 - `tavilyApiKey`: Tavily 网页搜索的 API 密钥。
 - `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP 邮件设置。
 - `feishuWebhook`, `dingtalkWebhook`, `wecomWebhook`: 通知钩子地址。
@@ -132,13 +167,20 @@ AutoClaw 使用层级配置系统。
 在 `.autoclaw/setting.json` 创建文件：
 ```json
 {
-  "model": "gpt-3.5-turbo",
+  "model": "gpt-5.6",
   "baseUrl": "https://api.deepseek.com/v1"
 }
 ```
 
 > **⚠️ 安全警告**: 如果您在 `.autoclaw/setting.json` 中存储了 `apiKey` 或机密信息，请务必将 `.autoclaw/` 添加到您的 `.gitignore` 文件中，以防泄露！
 
+### 环境变量
+- `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`: 主模型设置。
+- `AUTOCLOW_PROVIDER`: 未传 `-P` 时使用的 provider 预设。
+- `AUTOCLOW_MAX_STEPS`, `AUTOCLOW_SHELL_TIMEOUT`: 稳定性限制（单任务最大轮数；Shell 超时毫秒数）。
+- `AUTOCLOW_INCLUDE_USAGE`: 设为 `1`/`true` 时向 API 请求 token 用量（可选开启）。
+- `TAVILY_API_KEY`, `SMTP_HOST`/`SMTP_PORT`/`SMTP_USER`/`SMTP_PASS`, `FEISHU_WEBHOOK`/`FEISHU_KEYWORD`, `DINGTALK_WEBHOOK`/`DINGTALK_KEYWORD`, `WECOM_WEBHOOK`/`WECOM_KEYWORD`: 工具凭据，可作为 setup 的替代方式。
+
 ## 集成功能
 
 ### 网页搜索 (Tavily)
@@ -159,6 +201,14 @@ AutoClaw 使用层级配置系统。
 
 ## Docker 支持
 
+### 构建与运行
+仓库自带多阶段构建的 `Dockerfile`（node:22-alpine，跳过浏览器下载保持镜像苗条）。容器内直接运行无头一次性任务，配合目录挂载操作当前目录：
+```bash
+docker build -t autoclaw .
+docker run --rm -v "$PWD":/workspace -w /workspace -e OPENAI_API_KEY=sk-... autoclaw "检查磁盘使用情况并保存报告" -y -n
+```
+注意：默认镜像中未内置浏览器，基于浏览器的工具（`read_website` / `take_screenshot`）不可用——它们会返回友好的安装提示，而不是报错崩溃。
+
 ### 截图中的中文显示问题
 在 Docker 容器（尤其是 Alpine 或 Debian Slim）中运行时，网页截图中的中文可能会显示为方块（"豆腐块"）。表情符号（如 🔥）也可能显示为方块。
 

package/dist/agent.js

@@ -4,14 +4,26 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import * as util from 'util';
 import { getToolDefinitions, executeToolHandler } from './tools/index.js';
+import { withRetry } from './retry.js';
+import { truncateOutput } from './truncate.js';
+const DEFAULT_MAX_STEPS = 25;
+// The shell behind child_process.exec differs by platform; telling the model
+// up front avoids trial-and-error turns (cmd.exe rejects ; and $()).
+export function buildShellInfo(platform = os.platform()) {
+    if (platform === 'win32') {
+        return 'cmd.exe (Windows). Chain commands with && only, there is no $() command substitution, mkdir has no -p flag, and native tool output may be GBK-garbled. For system queries prefer: powershell -Command "..."';
+    }
+    return 'POSIX shell (sh). Standard Unix tools apply.';
+}
 export class Agent {
     client;
     messages;
     model;
     config;
     lastOutputFile = null;
-    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview', config = {}) {
+    constructor(apiKey, baseURL, model = 'gpt-5.6', config = {}) {
         this.client = new OpenAI({
             apiKey: apiKey,
             baseURL: baseURL
@@ -21,6 +33,7 @@ export class Agent {
         const systemInfo = `
 System Information:
 - OS: ${os.type()} ${os.release()} (${os.platform()})
+- Shell: ${buildShellInfo()}
 - Architecture: ${os.arch()}
 - Node.js Version: ${process.version}
 - Current Working Directory: ${process.cwd()}
@@ -28,6 +41,9 @@ System Information:
 - Home Directory: ${os.homedir()}
 - Current Date: ${new Date().toLocaleString()}
 `;
+        const windowsShellRule = os.platform() === 'win32'
+            ? `\n8. Mind the shell noted above: on Windows it is cmd.exe, not bash — && only, no \$(...) substitution, no mkdir -p, GBK output possible; prefer powershell -Command "..." for system queries.`
+            : '';
         this.messages = [
             {
                 role: "system",
@@ -48,59 +64,133 @@ WHAT YOU CAN DO:
 RULES OF ENGAGEMENT:
 1. One shot, not one chat. Produce working results, not conversation. Be terse.
 2. Use the right tool for the job. Shell for system ops. Files for content. Web tools for external info.
-3. Always pass non-interactive flags: --yes for npx, -y for apt/apk, -f for rm, etc. Assume no human is watching.
+3. Always pass non-interactive flags: --yes for npx, -y for apt/apk, -f for rm, etc. Assume no human is watching. Set GIT_TERMINAL_PROMPT=0 for git commands that may need credentials so they fail fast instead of hanging.
 4. Container-friendly: stick to standard Unix tools available in Alpine/Debian slim images. No GUI apps, no browser-based debug tools.
 5. For creative or complex tasks (image prompts, long-form writing, intricate scripts): call optimize_prompt first. It significantly raises output quality.
 6. If a command fails, diagnose and try one alternative. Don't retry the same thing, don't give up on first error.
-7. Read before write. When modifying a file, read it first. When installing a package, check if it's already there.
+7. Read before write. When modifying a file, read it first. When installing a package, check if it's already there.${windowsShellRule}
 `
             }
         ];
     }
+    get jsonMode() {
+        return !!this.config?.jsonMode;
+    }
+    emitEvent(event) {
+        if (this.jsonMode)
+            console.log(JSON.stringify(event));
+    }
+    // Tool handlers print progress via console; in JSON mode stdout is an NDJSON
+    // contract, so route those prints to stderr for the duration of the call.
+    async runToolQuietly(run) {
+        const original = [console.log, console.info, console.warn, console.error];
+        const toStderr = (...args) => process.stderr.write(util.format(...args) + '\n');
+        [console.log, console.info, console.warn, console.error] = [toStderr, toStderr, toStderr, toStderr];
+        try {
+            return await run();
+        }
+        finally {
+            [console.log, console.info, console.warn, console.error] = original;
+        }
+    }
     async chat(userInput) {
         this.messages.push({ role: "user", content: userInput });
+        const maxSteps = Number(this.config?.maxSteps || process.env.AUTOCLOW_MAX_STEPS || DEFAULT_MAX_STEPS);
         let active = true;
+        let step = 0;
+        let status = 'completed';
+        let errorMessage;
+        let lastContent = null;
+        const totalUsage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+        let sawUsage = false;
+        this.emitEvent({ event: 'run_start', model: this.model, task: userInput });
         while (active) {
-            const spinner = ora('Thinking...').start();
+            if (step >= maxSteps) {
+                status = 'max_steps';
+                if (!this.jsonMode) {
+                    console.log(chalk.yellow(`\n[MaxSteps] Reached the ${maxSteps}-turn limit; stopping to avoid a runaway loop.`));
+                }
+                break;
+            }
+            step++;
+            const spinner = this.jsonMode
+                ? { stop() { }, fail() { }, text: '' }
+                : ora('Thinking...').start();
+            let stream;
             try {
-                const stream = await this.client.chat.completions.create({
+                // Retries cover request setup and the header phase; a failure after
+                // the stream started yielding chunks is not retried, because partial
+                // output may already have been printed.
+                stream = await withRetry(async () => this.client.chat.completions.create({
                     model: this.model,
                     messages: this.messages,
                     tools: getToolDefinitions(),
                     tool_choice: "auto",
-                    stream: true
+                    stream: true,
+                    // Not every OpenAI-compatible provider accepts stream_options;
+                    // usage tracking is therefore opt-in only.
+                    ...(this.config?.includeUsage ? { stream_options: { include_usage: true } } : {})
+                }), {
+                    onRetry: (err, nextAttempt, delayMs) => {
+                        spinner.text = `API error (${err.message}); retrying in ${Math.round(delayMs / 1000)}s (attempt ${nextAttempt})...`;
+                    }
                 });
-                let content = '';
-                let reasoningContent = '';
-                let toolCalls = [];
-                let contentStarted = false;
-                let reasoningStarted = false;
-                const toolNamesSeen = new Set();
+            }
+            catch (error) {
+                spinner.fail('Error during processing');
+                if (!this.jsonMode)
+                    console.error(chalk.red(error.message));
+                status = 'error';
+                errorMessage = error.message;
+                active = false;
+                break;
+            }
+            let content = '';
+            let reasoningContent = '';
+            let toolCalls = [];
+            let contentStarted = false;
+            let reasoningStarted = false;
+            const toolNamesSeen = new Set();
+            try {
                 for await (const chunk of stream) {
+                    if (chunk.usage) {
+                        sawUsage = true;
+                        totalUsage.prompt_tokens += chunk.usage.prompt_tokens ?? 0;
+                        totalUsage.completion_tokens += chunk.usage.completion_tokens ?? 0;
+                        totalUsage.total_tokens += chunk.usage.total_tokens ?? 0;
+                    }
                     const delta = chunk.choices[0]?.delta;
                     // Handle reasoning/thinking content (e.g., DeepSeek)
                     if (delta?.reasoning_content) {
                         if (!reasoningStarted) {
                             spinner.stop();
-                            process.stdout.write(chalk.dim('\n[Thinking] '));
+                            if (!this.jsonMode) {
+                                process.stdout.write(chalk.dim('\n[Thinking] '));
+                            }
                             reasoningStarted = true;
                         }
-                        process.stdout.write(chalk.dim(delta.reasoning_content));
+                        if (!this.jsonMode) {
+                            process.stdout.write(chalk.dim(delta.reasoning_content));
+                        }
                         reasoningContent += delta.reasoning_content;
                     }
                     // Handle regular content
                     if (delta?.content) {
                         if (!contentStarted) {
                             spinner.stop();
-                            if (reasoningStarted)
-                                process.stdout.write('\n');
-                            process.stdout.write(chalk.blue("AutoClaw: "));
+                            if (!this.jsonMode) {
+                                if (reasoningStarted)
+                                    process.stdout.write('\n');
+                                process.stdout.write(chalk.blue("AutoClaw: "));
+                            }
                             contentStarted = true;
                         }
-                        process.stdout.write(delta.content);
+                        if (!this.jsonMode) {
+                            process.stdout.write(delta.content);
+                        }
                         content += delta.content;
                     }
-                    // Handle tool calls - show name as soon as available
+                    // Handle tool calls
                     if (delta?.tool_calls) {
                         for (const tc of delta.tool_calls) {
                             const idx = tc.index;
@@ -113,45 +203,76 @@ RULES OF ENGAGEMENT:
                                 toolCalls[idx].function.name += tc.function.name;
                             if (tc.function?.arguments)
                                 toolCalls[idx].function.arguments += tc.function.arguments;
-                            // Show tool name as soon as it's complete
                             if (tc.function?.name && !toolNamesSeen.has(idx)) {
                                 toolNamesSeen.add(idx);
                                 spinner.stop();
-                                if (contentStarted)
-                                    process.stdout.write('\n');
-                                if (reasoningStarted && !contentStarted)
-                                    process.stdout.write('\n');
-                                process.stdout.write(chalk.cyan(`[Calling] ${tc.function.name}\n`));
+                                if (!this.jsonMode) {
+                                    if (contentStarted)
+                                        process.stdout.write('\n');
+                                    if (reasoningStarted && !contentStarted)
+                                        process.stdout.write('\n');
+                                    process.stdout.write(chalk.cyan(`[Calling] ${tc.function.name}\n`));
+                                }
                             }
                         }
                     }
                 }
-                if (reasoningStarted) {
+            }
+            catch (error) {
+                spinner.fail('Error during processing');
+                if (!this.jsonMode)
+                    console.error(chalk.red(error.message));
+                status = 'error';
+                errorMessage = error.message;
+                active = false;
+                break;
+            }
+            if (!this.jsonMode) {
+                if (reasoningStarted)
                     console.log(); // newline after reasoning
-                }
-                if (contentStarted) {
+                if (contentStarted)
                     console.log(); // newline after streamed content
-                }
-                if (!reasoningStarted && !contentStarted) {
+                if (!reasoningStarted && !contentStarted)
                     spinner.stop();
-                }
-                // Build the full message for history
-                const message = { role: "assistant" };
-                if (content)
-                    message.content = content;
-                if (reasoningContent)
-                    message.reasoning_content = reasoningContent;
-                if (toolCalls.length > 0) {
-                    message.tool_calls = toolCalls;
-                    message.content = message.content || null;
-                }
-                this.messages.push(message);
-                if (toolCalls.length > 0) {
-                    for (const toolCall of toolCalls) {
-                        if (toolCall.type !== 'function')
-                            continue;
-                        const functionName = toolCall.function.name;
-                        const functionArgs = JSON.parse(toolCall.function.arguments);
+            }
+            // Build the full message for history
+            const message = { role: "assistant" };
+            if (content)
+                message.content = content;
+            if (reasoningContent)
+                message.reasoning_content = reasoningContent;
+            if (toolCalls.length > 0) {
+                message.tool_calls = toolCalls;
+                message.content = message.content || null;
+            }
+            this.messages.push(message);
+            if (content)
+                lastContent = content;
+            if (toolCalls.length > 0) {
+                for (const toolCall of toolCalls) {
+                    if (toolCall.type !== 'function')
+                        continue;
+                    const functionName = toolCall.function.name;
+                    let functionArgs;
+                    try {
+                        functionArgs = JSON.parse(toolCall.function.arguments || '{}');
+                    }
+                    catch (parseError) {
+                        // Feed the failure back so the model can correct itself next turn
+                        if (!this.jsonMode) {
+                            console.log(chalk.red(`\n[Tool] ${functionName} — malformed arguments (not valid JSON)`));
+                        }
+                        this.messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error: arguments for ${functionName} were not valid JSON (${parseError.message}). Re-issue the tool call with well-formed JSON arguments.`
+                        });
+                        continue;
+                    }
+                    if (this.jsonMode) {
+                        this.emitEvent({ event: 'tool_call', step, tool: functionName, args: functionArgs });
+                    }
+                    else {
                         // Display tool call info
                         console.log(chalk.cyan(`\n[Tool] ${functionName}`));
                         const argsStr = JSON.stringify(functionArgs, null, 2);
@@ -163,56 +284,82 @@ RULES OF ENGAGEMENT:
                         else {
                             console.log(chalk.dim(argsStr));
                         }
-                        const execSpinner = ora('Executing...').start();
-                        let toolResult;
-                        try {
-                            toolResult = await executeToolHandler(functionName, functionArgs, this.config);
-                            execSpinner.stop();
-                        }
-                        catch (err) {
-                            execSpinner.fail('Tool execution failed');
-                            toolResult = `Error: ${err.message}`;
-                        }
-                        // Display result with folding for long output
-                        const MAX_PREVIEW_LINES = 20;
-                        const resultLines = toolResult.split('\n');
-                        console.log(chalk.green(`[Result]`));
-                        if (resultLines.length > MAX_PREVIEW_LINES) {
-                            // Show preview
+                    }
+                    let toolResult;
+                    try {
+                        const run = () => executeToolHandler(functionName, functionArgs, this.config);
+                        toolResult = this.jsonMode ? await this.runToolQuietly(run) : await run();
+                    }
+                    catch (err) {
+                        toolResult = `Error: ${err.message}`;
+                    }
+                    // Bound what goes back into the model context; the full output is
+                    // kept on disk for /view.
+                    const MAX_PREVIEW_LINES = 20;
+                    const truncation = truncateOutput(toolResult);
+                    const boundedResult = truncation.content;
+                    const resultLines = boundedResult.split('\n');
+                    let outputFile = null;
+                    if (resultLines.length > MAX_PREVIEW_LINES || truncation.truncated) {
+                        outputFile = await this.saveOutput(functionName, toolResult);
+                        this.lastOutputFile = outputFile;
+                        if (!this.jsonMode) {
+                            console.log(chalk.green(`[Result]`));
                             console.log(resultLines.slice(0, MAX_PREVIEW_LINES).join('\n'));
                             const remaining = resultLines.length - MAX_PREVIEW_LINES;
-                            console.log(chalk.dim(`\n  ... ${remaining} more lines (${resultLines.length} lines total)`));
-                            // Save full output to file
-                            const outputDir = path.join(os.homedir(), '.autoclaw', 'output');
-                            if (!fs.existsSync(outputDir)) {
-                                fs.mkdirSync(outputDir, { recursive: true });
+                            if (remaining > 0) {
+                                console.log(chalk.dim(`\n  ... ${remaining} more lines (${resultLines.length} lines total)`));
                             }
-                            const ts = new Date().toISOString().replace(/[:.]/g, '-');
-                            const outputFile = path.join(outputDir, `${functionName}_${ts}.txt`);
-                            fs.writeFileSync(outputFile, toolResult, 'utf-8');
-                            this.lastOutputFile = outputFile;
                             console.log(chalk.dim(`  Type '/view' to see full output`));
                         }
-                        else {
-                            console.log(toolResult);
-                            this.lastOutputFile = null;
-                        }
-                        this.messages.push({
-                            role: "tool",
-                            tool_call_id: toolCall.id,
-                            content: toolResult
+                    }
+                    else if (!this.jsonMode) {
+                        console.log(chalk.green(`[Result]`));
+                        console.log(boundedResult);
+                        this.lastOutputFile = null;
+                    }
+                    if (this.jsonMode) {
+                        this.emitEvent({
+                            event: 'tool_result',
+                            step,
+                            tool: functionName,
+                            truncated: truncation.truncated,
+                            bytes: truncation.totalBytes,
+                            ...(outputFile ? { output_file: outputFile } : {})
                         });
                     }
-                }
-                else {
-                    active = false;
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: boundedResult
+                    });
                 }
             }
-            catch (error) {
-                spinner.fail('Error during processing');
-                console.error(chalk.red(error.message));
+            else {
                 active = false;
             }
+            if (sawUsage) {
+                this.emitEvent({ event: 'usage', step, ...totalUsage });
+            }
+        }
+        const result = {
+            status,
+            steps: step,
+            message: lastContent,
+            ...(errorMessage ? { error: errorMessage } : {}),
+            ...(sawUsage ? { usage: totalUsage } : {})
+        };
+        this.emitEvent({ event: 'run_end', ...result });
+        return result;
+    }
+    async saveOutput(functionName, toolResult) {
+        const outputDir = path.join(os.homedir(), '.autoclaw', 'output');
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
         }
+        const ts = new Date().toISOString().replace(/[:.]/g, '-');
+        const outputFile = path.join(outputDir, `${functionName}_${ts}.txt`);
+        fs.writeFileSync(outputFile, toolResult, 'utf-8');
+        return outputFile;
     }
 }

package/dist/batch.js

@@ -0,0 +1,64 @@
+// Blank lines and lines starting with '#' are skipped. Malformed lines are
+// kept as errored entries (in manifest order) rather than dropped, so the
+// result file accounts for every task the user submitted.
+export function parseManifest(raw) {
+    return raw
+        .split('\n')
+        .map((line, idx) => {
+        const lineNo = idx + 1;
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            return null;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            // fall through to the error entry below
+        }
+        const id = parsed && typeof parsed === 'object' && typeof parsed.id === 'string' && parsed.id.trim()
+            ? parsed.id.trim()
+            : `task-${lineNo}`;
+        if (!parsed || typeof parsed !== 'object' || typeof parsed.task !== 'string' || !parsed.task.trim()) {
+            return { lineNo, id, task: '', error: 'not valid JSON or missing "task" field' };
+        }
+        const entry = { lineNo, id, task: parsed.task.trim() };
+        if (typeof parsed.maxSteps === 'number' && parsed.maxSteps > 0)
+            entry.maxSteps = parsed.maxSteps;
+        if (typeof parsed.model === 'string' && parsed.model.trim())
+            entry.model = parsed.model.trim();
+        if (typeof parsed.provider === 'string' && parsed.provider.trim())
+            entry.provider = parsed.provider.trim();
+        return entry;
+    })
+        .filter((entry) => entry !== null);
+}
+export async function runBatch(entries, execute, options = {}) {
+    const total = entries.length;
+    const results = [];
+    let completed = 0;
+    let failed = 0;
+    for (const entry of entries) {
+        let result;
+        if (entry.error) {
+            result = { id: entry.id, status: 'error', error: `Manifest line ${entry.lineNo}: ${entry.error}`, durationMs: 0 };
+        }
+        else {
+            try {
+                result = await execute(entry);
+            }
+            catch (err) {
+                result = { id: entry.id, status: 'error', error: err?.message ?? String(err), durationMs: 0 };
+            }
+        }
+        if (result.status === 'completed')
+            completed++;
+        else
+            failed++;
+        results.push(result);
+        options.onResult?.(entry, result, results.length, total);
+        if (options.failFast && result.status !== 'completed')
+            break;
+    }
+    return { results, completed, failed };
+}

package/dist/index.js

@@ -4,6 +4,8 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import dotenv from 'dotenv';
 import { Agent } from './agent.js';
+import { parseManifest, runBatch } from './batch.js';
+import { PROVIDER_PRESETS, providerNames, resolveProvider } from './providers.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -42,7 +44,7 @@ dotenv.config({ path: GLOBAL_ENV_FILE });
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
 const pkgPath = path.join(__dirname, '..', 'package.json');
-let version = '1.0.2';
+let version = '1.3.0';
 try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     version = pkg.version;
@@ -56,8 +58,10 @@ program
     .description('A lightweight AI agent CLI tool')
     .version(version)
     .option('-m, --model <model>', 'Model to use')
+    .option('-P, --provider <name>', 'Use a provider preset (openai, deepseek, moonshot, dashscope, zhipu, openrouter, ollama)')
     .option('-n, --no-interactive', 'Exit after processing the initial query (Headless mode)')
-    .option('-y, --yes', 'Auto-confirm all tool executions (e.g., shell commands)');
+    .option('-y, --yes', 'Auto-confirm all tool executions (e.g., shell commands)')
+    .option('--json', 'Emit NDJSON events on stdout (for orchestrators; use with -n)');
 program
     .command('setup')
     .description('Run the interactive setup wizard to configure API keys')
@@ -72,6 +76,15 @@ program
     const options = program.opts();
     await runChat(queryParts, options);
 });
+program
+    .command('batch <manifest>')
+    .description('Run tasks from a JSONL manifest, each in a fresh agent ({"id":"...","task":"..."})')
+    .option('-o, --output <file>', 'Per-task results as JSONL (default: <manifest base>.results.jsonl)')
+    .option('--fail-fast', 'Stop on the first failed task')
+    .action(async (manifest, cmdOptions) => {
+    const options = program.opts();
+    await runBatchCommand(manifest, options, cmdOptions);
+});
 program.parse(process.argv);
 async function runSetup(options = {}) {
     const isProject = options.project;
@@ -92,6 +105,20 @@ async function runSetup(options = {}) {
             return '******';
         return `${secret.slice(0, 3)}...${secret.slice(-4)}`;
     }
+    const providerAnswer = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'provider',
+            message: 'Select your LLM provider:',
+            choices: [
+                ...providerNames().map((name) => ({ name: `${PROVIDER_PRESETS[name].label} (${name})`, value: name })),
+                { name: 'Custom OpenAI-compatible endpoint', value: 'custom' }
+            ],
+            default: currentConfig.provider || 'openai'
+        }
+    ]);
+    const provider = providerAnswer.provider;
+    const preset = resolveProvider(provider === 'custom' ? undefined : provider);
     const answers = await inquirer.prompt([
         {
             type: 'password',
@@ -112,13 +139,13 @@ async function runSetup(options = {}) {
             type: 'input',
             name: 'baseUrl',
             message: 'Enter API Base URL:',
-            default: currentConfig.baseUrl || 'https://api.openai.com/v1'
+            default: currentConfig.baseUrl || preset?.baseUrl || 'https://api.openai.com/v1'
         },
         {
             type: 'input',
             name: 'model',
             message: 'Enter default Model:',
-            default: currentConfig.model || 'gpt-4o'
+            default: currentConfig.model || preset?.defaultModel || 'gpt-5.6'
         },
         {
             type: 'confirm',
@@ -319,6 +346,7 @@ async function runSetup(options = {}) {
         apiKey: finalApiKey,
         baseUrl: answers.baseUrl,
         model: answers.model,
+        provider: provider === 'custom' ? undefined : provider,
         ...imageConfig,
         ...emailConfig,
         ...searchConfig,
@@ -336,11 +364,9 @@ async function runSetup(options = {}) {
         console.error(chalk.red(`Failed to write config: ${error.message}`));
     }
 }
-async function runChat(queryParts, options) {
-    if (options.interactive) {
-        console.log(chalk.bold.cyan("Welcome to AutoClaw CLI 🦞"));
-    }
-    const initialQuery = queryParts.join(' ');
+// Shared by `chat` and `batch`: resolve credentials, endpoints and runtime
+// flags from CLI args > env > project config > global config > provider preset.
+async function resolveRuntime(options) {
     // 1. Load Global JSON
     const globalConfig = loadJsonConfig(GLOBAL_CONFIG_FILE);
     // 2. Load Local JSON (Project Level)
@@ -351,18 +377,31 @@ async function runChat(queryParts, options) {
     // 3. Merge Configs for Tool Usage
     // Priority: Local > Global
     const fullConfig = { ...globalConfig, ...localConfig };
-    // 4. Resolve Env Vars (CLI > Env > Config)
-    let apiKey = process.env.OPENAI_API_KEY || fullConfig.apiKey;
-    let baseURL = process.env.OPENAI_BASE_URL || fullConfig.baseUrl;
-    let model = options.model || process.env.OPENAI_MODEL || fullConfig.model || 'gpt-4o';
+    // 4. Resolve Provider Preset (CLI > Env > Config)
+    const providerName = options.provider || process.env.AUTOCLOW_PROVIDER || fullConfig.provider;
+    const preset = resolveProvider(providerName);
+    if (providerName && !preset) {
+        console.log(chalk.yellow(`Unknown provider '${providerName}'. Known providers: ${providerNames().join(', ')}`));
+    }
+    // 5. Resolve Env Vars (CLI > Env > Config > Provider preset)
+    let apiKey = process.env.OPENAI_API_KEY || fullConfig.apiKey || (preset?.apiKeyEnv ? process.env[preset.apiKeyEnv] : undefined);
+    let baseURL = process.env.OPENAI_BASE_URL || fullConfig.baseUrl || preset?.baseUrl;
+    let model = options.model || process.env.OPENAI_MODEL || fullConfig.model || preset?.defaultModel || 'gpt-5.6';
     // Inject Runtime Flags
     fullConfig.autoConfirm = options.yes;
+    fullConfig.jsonMode = !!options.json;
+    // Usage tracking is opt-in: not every OpenAI-compatible provider accepts
+    // stream_options.include_usage, so never force it on.
+    fullConfig.includeUsage =
+        !!fullConfig.includeUsage ||
+            process.env.AUTOCLOW_INCLUDE_USAGE === '1' ||
+            process.env.AUTOCLOW_INCLUDE_USAGE === 'true';
     // Inject Env vars
     if (process.env.SMTP_HOST)
         fullConfig.smtpHost = process.env.SMTP_HOST;
     if (process.env.SMTP_PORT)
         fullConfig.smtpPort = process.env.SMTP_PORT;
-    if (process.env.SMTP_User)
+    if (process.env.SMTP_USER)
         fullConfig.smtpUser = process.env.SMTP_USER;
     if (process.env.SMTP_PASS)
         fullConfig.smtpPass = process.env.SMTP_PASS;
@@ -393,9 +432,10 @@ async function runChat(queryParts, options) {
         if (doSetup) {
             await runSetup();
             const newConfig = loadJsonConfig(GLOBAL_CONFIG_FILE);
-            apiKey = newConfig.apiKey;
-            baseURL = newConfig.baseUrl;
-            model = options.model || newConfig.model || 'gpt-4o';
+            const setupPreset = resolveProvider(newConfig.provider);
+            apiKey = newConfig.apiKey || (setupPreset?.apiKeyEnv ? process.env[setupPreset.apiKeyEnv] : undefined);
+            baseURL = newConfig.baseUrl || setupPreset?.baseUrl;
+            model = options.model || newConfig.model || setupPreset?.defaultModel || 'gpt-5.6';
             Object.assign(fullConfig, newConfig);
         }
         else {
@@ -407,6 +447,74 @@ async function runChat(queryParts, options) {
         console.error(chalk.red("API Key is still missing. Exiting."));
         process.exit(1);
     }
+    return { apiKey, baseURL, model, fullConfig };
+}
+async function runBatchCommand(manifestPath, globalOptions, cmdOptions) {
+    const { apiKey, baseURL, model, fullConfig } = await resolveRuntime(globalOptions);
+    let raw;
+    try {
+        raw = fs.readFileSync(manifestPath, 'utf-8');
+    }
+    catch (err) {
+        console.error(chalk.red(`Cannot read manifest ${manifestPath}: ${err.message}`));
+        process.exit(1);
+    }
+    const entries = parseManifest(raw);
+    if (entries.length === 0) {
+        console.error(chalk.red(`Manifest ${manifestPath} contains no tasks (blank lines and '#' comments are skipped).`));
+        process.exit(1);
+    }
+    const outputPath = cmdOptions.output || manifestPath.replace(/\.[^.]+$/, '') + '.results.jsonl';
+    console.log(chalk.bold.cyan(`AutoClaw Batch 🦞  ${entries.length} task(s)`));
+    console.log(chalk.dim(`Results: ${outputPath}\n`));
+    const startedAt = Date.now();
+    const { results, completed, failed } = await runBatch(entries, async (entry) => {
+        // A fresh Agent per task keeps contexts isolated; per-task overrides
+        // beat the globally resolved defaults.
+        const taskPreset = resolveProvider(entry.provider);
+        const taskModel = entry.model || taskPreset?.defaultModel || model;
+        const taskBaseURL = taskPreset?.baseUrl || baseURL;
+        const taskConfig = {
+            ...fullConfig,
+            // The results file is the machine-readable contract in batch mode.
+            jsonMode: false,
+            maxSteps: entry.maxSteps ?? fullConfig.maxSteps
+        };
+        const agent = new Agent(apiKey, taskBaseURL, taskModel, taskConfig);
+        const start = Date.now();
+        const runResult = await agent.chat(entry.task);
+        return {
+            id: entry.id,
+            status: runResult.status,
+            steps: runResult.steps,
+            message: runResult.message ?? null,
+            ...(runResult.error ? { error: runResult.error } : {}),
+            ...(runResult.usage ? { usage: runResult.usage } : {}),
+            durationMs: Date.now() - start
+        };
+    }, {
+        failFast: !!cmdOptions.failFast,
+        onResult: (entry, result, done, total) => {
+            const color = result.status === 'completed' ? chalk.green : chalk.red;
+            console.log(color(`[${done}/${total}] ${entry.id} -> ${result.status} (${Math.round(result.durationMs / 1000)}s)`));
+        }
+    });
+    try {
+        fs.writeFileSync(outputPath, results.map(r => JSON.stringify(r)).join('\n') + '\n', 'utf-8');
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to write results to ${outputPath}: ${err.message}`));
+        process.exit(1);
+    }
+    console.log(chalk.cyan(`\nBatch done: ${completed}/${results.length} completed, ${failed} failed in ${Math.round((Date.now() - startedAt) / 1000)}s -> ${outputPath}`));
+    process.exit(failed > 0 ? 1 : 0);
+}
+async function runChat(queryParts, options) {
+    if (options.interactive) {
+        console.log(chalk.bold.cyan("Welcome to AutoClaw CLI 🦞"));
+    }
+    const initialQuery = queryParts.join(' ');
+    const { apiKey, baseURL, model, fullConfig } = await resolveRuntime(options);
     const agent = new Agent(apiKey, baseURL, model, fullConfig);
     if (options.interactive) {
         console.log(chalk.green(`Agent initialized with model: ${model}`));
@@ -417,10 +525,11 @@ async function runChat(queryParts, options) {
         if (options.interactive) {
             console.log(chalk.blue("\nProcessing initial request: ") + chalk.bold(initialQuery));
         }
-        await agent.chat(initialQuery);
-        // Headless mode exit
+        const result = await agent.chat(initialQuery);
+        // Headless mode exit — the exit code is the orchestrator-facing outcome:
+        // 0 completed, 1 hard failure, 2 step cap reached (task unfinished).
         if (!options.interactive) {
-            process.exit(0);
+            process.exit(result.status === 'completed' ? 0 : result.status === 'max_steps' ? 2 : 1);
         }
     }
     // Main chat loop

package/dist/providers.js

@@ -0,0 +1,51 @@
+export const PROVIDER_PRESETS = {
+    openai: {
+        label: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        defaultModel: 'gpt-5.6',
+        apiKeyEnv: 'OPENAI_API_KEY'
+    },
+    deepseek: {
+        label: 'DeepSeek',
+        baseUrl: 'https://api.deepseek.com/v1',
+        defaultModel: 'deepseek-v4-pro',
+        apiKeyEnv: 'DEEPSEEK_API_KEY'
+    },
+    moonshot: {
+        label: 'Moonshot (Kimi)',
+        baseUrl: 'https://api.moonshot.cn/v1',
+        defaultModel: 'kimi-k3',
+        apiKeyEnv: 'MOONSHOT_API_KEY'
+    },
+    dashscope: {
+        label: 'Alibaba DashScope (Qwen)',
+        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+        defaultModel: 'qwen3.8-max',
+        apiKeyEnv: 'DASHSCOPE_API_KEY'
+    },
+    zhipu: {
+        label: 'Zhipu (GLM)',
+        baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+        defaultModel: 'glm-5',
+        apiKeyEnv: 'ZHIPU_API_KEY'
+    },
+    openrouter: {
+        label: 'OpenRouter',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        defaultModel: 'openai/gpt-5.6',
+        apiKeyEnv: 'OPENROUTER_API_KEY'
+    },
+    ollama: {
+        label: 'Ollama (local)',
+        baseUrl: 'http://localhost:11434/v1',
+        defaultModel: 'qwen3'
+    }
+};
+export function resolveProvider(name) {
+    if (!name)
+        return undefined;
+    return PROVIDER_PRESETS[name.toLowerCase()];
+}
+export function providerNames() {
+    return Object.keys(PROVIDER_PRESETS);
+}

package/dist/retry.js

@@ -0,0 +1,42 @@
+export const DEFAULT_MAX_ATTEMPTS = 3;
+export const DEFAULT_BASE_DELAY_MS = 1000;
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function isRetryableError(err) {
+    if (!err)
+        return false;
+    const status = err.status ?? err.statusCode;
+    if (typeof status === 'number') {
+        return status === 429 || status === 408 || status >= 500;
+    }
+    const match = /status code (\d{3})/.exec(String(err.message ?? ''));
+    if (match) {
+        const code = Number(match[1]);
+        return code === 429 || code === 408 || code >= 500;
+    }
+    const transientCodes = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'EAI_AGAIN', 'ECONNABORTED', 'EPIPE', 'ENOTFOUND'];
+    if (typeof err.code === 'string' && transientCodes.includes(err.code))
+        return true;
+    return /fetch failed|network|socket hang up|connection error|terminated/i.test(String(err.message ?? ''));
+}
+export async function withRetry(fn, options = {}) {
+    const attempts = options.attempts ?? DEFAULT_MAX_ATTEMPTS;
+    const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const sleepFn = options.sleepFn ?? sleep;
+    let lastErr;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt >= attempts || !isRetryableError(err))
+                throw err;
+            const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
+            options.onRetry?.(err, attempt + 1, delayMs);
+            await sleepFn(delayMs);
+        }
+    }
+    throw lastErr;
+}

package/dist/tools/core.js

@@ -5,6 +5,8 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import util from 'util';
 const execAsync = util.promisify(exec);
+const DEFAULT_SHELL_TIMEOUT_MS = 120000;
+const SHELL_MAX_BUFFER = 10 * 1024 * 1024;
 export const ShellTool = {
     name: "Shell Execution",
     definition: {
@@ -25,8 +27,14 @@ export const ShellTool = {
     handler: async (args, config) => {
         console.log(chalk.yellow(`\nAI wants to execute: `) + chalk.bold(args.command));
         console.log(chalk.dim(`Reason: ${args.rationale}`));
+        const timeoutMs = Number(config?.shellTimeout || process.env.AUTOCLOW_SHELL_TIMEOUT || DEFAULT_SHELL_TIMEOUT_MS);
         // Check for auto-confirm flag
         if (!config?.autoConfirm) {
+            if (!process.stdin.isTTY) {
+                // No human can answer the confirmation prompt in this environment;
+                // denying beats hanging on a dead prompt or auto-running unasked.
+                return "Denied: this shell command requires user confirmation, but no interactive terminal is attached. Re-run with --yes (or -y) to allow unattended execution.";
+            }
             const { confirm } = await inquirer.prompt([
                 {
                     type: 'confirm',
@@ -42,10 +50,16 @@ export const ShellTool = {
             console.log(chalk.gray("(Auto-confirming command execution due to --yes flag)"));
         }
         try {
-            const { stdout, stderr } = await execAsync(args.command);
+            const { stdout, stderr } = await execAsync(args.command, {
+                timeout: timeoutMs,
+                maxBuffer: SHELL_MAX_BUFFER
+            });
             return stdout + (stderr ? `\nStderr: ${stderr}` : '');
         }
         catch (error) {
+            if (error.killed === true || error.signal) {
+                return `Command timed out after ${timeoutMs}ms and was terminated.\nStdout: ${error.stdout ?? ''}\nStderr: ${error.stderr ?? ''}`;
+            }
             return `Command failed: ${error.message}\nStdout: ${error.stdout}\nStderr: ${error.stderr}`;
         }
     }

package/dist/tools/prompt-optimizer.js

@@ -33,7 +33,7 @@ export const PromptOptimizerTool = {
         const contextMsg = args.context ? `Context: ${args.context}` : "Context: General AI Assistant interaction.";
         try {
             const completion = await client.chat.completions.create({
-                model: config.model || 'gpt-4o',
+                model: config.model || 'gpt-5.6',
                 messages: [
                     {
                         role: "system",

package/dist/truncate.js

@@ -0,0 +1,32 @@
+// Tool outputs are fed back into the model context, so they must be bounded.
+// Two independent limits apply — whichever is hit first wins:
+//   - line limit (default 2000 lines)
+//   - byte limit (default 50KB, counted as UTF-8 bytes)
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024;
+export function truncateOutput(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, 'utf8');
+    const lines = content.length === 0 ? [] : content.split('\n');
+    const totalLines = lines.length;
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return { content, truncated: false, totalLines, totalBytes, emittedLines: totalLines, emittedBytes: totalBytes };
+    }
+    let emittedLines = 0;
+    let emittedBytes = 0;
+    const kept = [];
+    for (const line of lines) {
+        if (kept.length + 1 > maxLines)
+            break;
+        const lineBytes = Buffer.byteLength(line, 'utf8') + (kept.length < lines.length - 1 ? 1 : 0);
+        if (emittedBytes + lineBytes > maxBytes)
+            break;
+        kept.push(line);
+        emittedLines++;
+        emittedBytes += lineBytes;
+    }
+    const notice = `[Truncated: showing ${emittedLines} of ${totalLines} lines, ${emittedBytes} of ${totalBytes} bytes]`;
+    const out = kept.length > 0 ? kept.join('\n') + '\n' + notice : notice;
+    return { content: out, truncated: true, totalLines, totalBytes, emittedLines, emittedBytes };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -10,7 +10,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "node --loader ts-node/esm src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build"
   },
   "files": [
@@ -64,7 +66,9 @@
     "@types/jsdom": "^27.0.0",
     "@types/node": "^25.2.1",
     "@types/nodemailer": "^7.0.9",
+    "@vitest/coverage-v8": "^4.1.11",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.4"
   }
 }