sparkecoder 0.1.59 → 0.1.61

package/dist/cli.js

@@ -404,7 +404,7 @@ var init_db = __esm({
 
 // src/config/types.ts
 import { z } from "zod";
-var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
+var ToolApprovalConfigSchema, SkillMetadataSchema, TaskConfigSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
 var init_types = __esm({
   "src/config/types.ts"() {
     "use strict";
@@ -423,11 +423,22 @@ var init_types = __esm({
       // Glob patterns - auto-inject when working with matching files
       globs: z.array(z.string()).optional().default([])
     });
+    TaskConfigSchema = z.object({
+      enabled: z.boolean(),
+      outputSchema: z.record(z.string(), z.unknown()),
+      webhookUrl: z.string().url().optional(),
+      maxIterations: z.number().optional(),
+      status: z.enum(["running", "completed", "failed"]),
+      result: z.unknown().optional(),
+      error: z.string().optional(),
+      iterations: z.number().optional()
+    });
     SessionConfigSchema = z.object({
       toolApprovals: z.record(z.string(), z.boolean()).optional(),
       approvalWebhook: z.string().url().optional(),
       skillsDirectory: z.string().optional(),
-      maxContextChars: z.number().optional().default(2e5)
+      maxContextChars: z.number().optional().default(2e5),
+      task: TaskConfigSchema.optional()
     });
     VectorGatewayConfigSchema = z.object({
       // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
@@ -558,8 +569,15 @@ function discoverSkillDirectories(workingDir) {
   if (existsSync(agentsMd)) {
     agentsMdPath = agentsMd;
   }
-  const builtInSkillsDir = resolve(dirname(import.meta.url.replace("file://", "")), "../skills/default");
-  if (existsSync(builtInSkillsDir)) {
+  const baseDir = dirname(import.meta.url.replace("file://", ""));
+  const builtInCandidates = [
+    resolve(baseDir, "../skills/default"),
+    // dev: src/config → src/skills/default
+    resolve(baseDir, "./skills/default")
+    // prod: dist/ → dist/skills/default
+  ];
+  const builtInSkillsDir = builtInCandidates.find((p) => existsSync(p));
+  if (builtInSkillsDir) {
     onDemandDirs.push({ path: builtInSkillsDir, priority: 100 });
     allDirectories.push(builtInSkillsDir);
   }
@@ -728,6 +746,9 @@ function getConfig() {
 }
 function requiresApproval(toolName, sessionConfig) {
   const config = getConfig();
+  if (sessionConfig?.toolApprovals?.["*"] !== void 0) {
+    return sessionConfig.toolApprovals["*"];
+  }
   if (sessionConfig?.toolApprovals?.[toolName] !== void 0) {
     return sessionConfig.toolApprovals[toolName];
   }
@@ -938,7 +959,7 @@ __export(skills_exports, {
   loadSkillsFromDirectory: () => loadSkillsFromDirectory
 });
 import { readFile as readFile6, readdir } from "fs/promises";
-import { resolve as resolve6, basename, extname as extname3, relative as relative4 } from "path";
+import { resolve as resolve6, basename, extname as extname4, relative as relative4 } from "path";
 import { existsSync as existsSync8 } from "fs";
 import { minimatch } from "minimatch";
 function parseSkillFrontmatter(content) {
@@ -1009,7 +1030,7 @@ function parseSkillFrontmatter(content) {
   }
 }
 function getSkillNameFromPath(filePath) {
-  return basename(filePath, extname3(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return basename(filePath, extname4(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory, options = {}) {
   const {
@@ -1334,9 +1355,9 @@ var init_hasher = __esm({
 });
 
 // src/semantic/chunker.ts
-import { extname as extname5, basename as basename2 } from "path";
+import { extname as extname6, basename as basename2 } from "path";
 function detectLanguage(filePath) {
-  const ext = extname5(filePath).toLowerCase();
+  const ext = extname6(filePath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function supportsSemanticChunking(language) {
@@ -2411,7 +2432,7 @@ import { createInterface } from "readline";
 
 // src/server/index.ts
 import "dotenv/config";
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -2425,28 +2446,186 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 init_db();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 import { existsSync as existsSync13, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync as statSync2, unlinkSync } from "fs";
 import { readdir as readdir5 } from "fs/promises";
-import { join as join5, basename as basename4, extname as extname6, relative as relative9 } from "path";
+import { join as join5, basename as basename4, extname as extname7, relative as relative9 } from "path";
 import { nanoid as nanoid4 } from "nanoid";
 
 // src/agent/index.ts
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool11,
+  tool as tool12,
   stepCountIs as stepCountIs2
 } from "ai";
 
 // src/agent/model.ts
 import { gateway } from "@ai-sdk/gateway";
+
+// src/agent/remote-model.ts
+function serializePrompt(prompt) {
+  return prompt.map((msg) => {
+    if (!Array.isArray(msg.content)) return msg;
+    return {
+      ...msg,
+      content: msg.content.map((part) => {
+        if (part.type === "file" && part.data instanceof Uint8Array) {
+          return {
+            ...part,
+            data: Buffer.from(part.data).toString("base64"),
+            _base64: true
+          };
+        }
+        return part;
+      })
+    };
+  });
+}
+function deserializeValue(value) {
+  if (value && typeof value === "object") {
+    if (value.__uint8array && typeof value.data === "string") {
+      return Buffer.from(value.data, "base64");
+    }
+    if (Array.isArray(value)) {
+      return value.map(deserializeValue);
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = deserializeValue(v);
+    }
+    return result;
+  }
+  return value;
+}
+function prepareOptions(options) {
+  const { abortSignal, ...rest } = options;
+  return {
+    ...rest,
+    prompt: serializePrompt(options.prompt)
+  };
+}
+function createRemoteModel(modelId, config) {
+  const baseUrl = config.url.replace(/\/$/, "");
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.authKey}`
+  };
+  return {
+    specificationVersion: "v3",
+    provider: "remote-proxy",
+    modelId,
+    supportedUrls: {},
+    async doGenerate(options) {
+      const res = await fetch(`${baseUrl}/inference/generate`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelId,
+          options: prepareOptions(options)
+        }),
+        signal: options.abortSignal
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(
+          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
+        );
+      }
+      const result = await res.json();
+      return deserializeValue(result);
+    },
+    async doStream(options) {
+      const res = await fetch(`${baseUrl}/inference/stream`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelId,
+          options: prepareOptions(options)
+        }),
+        signal: options.abortSignal
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(
+          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
+        );
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const stream = new ReadableStream({
+        async pull(controller) {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                try {
+                  const parsed = deserializeValue(JSON.parse(buffer.trim()));
+                  if (parsed.type === "error") {
+                    controller.error(new Error(parsed.error));
+                  } else {
+                    controller.enqueue(parsed);
+                  }
+                } catch {
+                }
+              }
+              controller.close();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const parsed = deserializeValue(JSON.parse(line));
+                if (parsed.type === "error") {
+                  controller.error(new Error(parsed.error));
+                  return;
+                }
+                controller.enqueue(parsed);
+              } catch {
+              }
+            }
+          }
+        },
+        cancel() {
+          reader.cancel();
+        }
+      });
+      const responseHeaders = {};
+      res.headers.forEach((v, k) => {
+        if (k.startsWith("x-upstream-")) {
+          responseHeaders[k.replace("x-upstream-", "")] = v;
+        }
+      });
+      return {
+        stream,
+        response: Object.keys(responseHeaders).length > 0 ? { headers: responseHeaders } : void 0
+      };
+    }
+  };
+}
+
+// src/agent/model.ts
+init_config();
 var ANTHROPIC_PREFIX = "anthropic/";
 function isAnthropicModel(modelId) {
   const normalized = modelId.trim().toLowerCase();
   return normalized.startsWith(ANTHROPIC_PREFIX) || normalized.startsWith("claude-");
 }
 function resolveModel(modelId) {
+  try {
+    const config = getConfig();
+    if (config.resolvedRemoteServer.isConfigured) {
+      return createRemoteModel(modelId.trim(), {
+        url: config.resolvedRemoteServer.url,
+        authKey: config.resolvedRemoteServer.authKey
+      });
+    }
+  } catch {
+  }
   return gateway(modelId.trim());
 }
 var SUBAGENT_MODELS = {
@@ -2458,7 +2637,7 @@ var SUBAGENT_MODELS = {
 // src/agent/index.ts
 init_db();
 init_config();
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/tools/bash.ts
@@ -3039,26 +3218,41 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
 import { tool as tool2 } from "ai";
 import { z as z3 } from "zod";
 import { readFile as readFile2, stat } from "fs/promises";
-import { resolve as resolve2, relative, isAbsolute } from "path";
+import { resolve as resolve2, relative, isAbsolute, extname } from "path";
 import { existsSync as existsSync3 } from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 var MAX_OUTPUT_CHARS3 = 5e4;
+var IMAGE_EXTENSIONS = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function isImageFile(filePath) {
+  return extname(filePath).toLowerCase() in IMAGE_EXTENSIONS;
+}
+function getImageMediaType(filePath) {
+  return IMAGE_EXTENSIONS[extname(filePath).toLowerCase()] || "image/png";
+}
 var readFileInputSchema = z3.object({
-  path: z3.string().describe("The path to the file to read. Can be relative to working directory or absolute."),
-  startLine: z3.number().optional().describe("Optional: Start reading from this line number (1-indexed)"),
-  endLine: z3.number().optional().describe("Optional: Stop reading at this line number (1-indexed, inclusive)")
+  path: z3.string().describe("The path to the file to read. Can be relative to working directory or absolute. Supports text files and images (png, jpg, jpeg, gif, webp)."),
+  startLine: z3.number().optional().describe("Optional: Start reading from this line number (1-indexed). Only for text files."),
+  endLine: z3.number().optional().describe("Optional: Stop reading at this line number (1-indexed, inclusive). Only for text files.")
 });
 function createReadFileTool(options) {
   return tool2({
     description: `Read the contents of a file. Provide a path relative to the working directory (${options.workingDirectory}) or an absolute path.
-Large files will be automatically truncated. Binary files are not supported.
-Use this to understand existing code, check file contents, or gather context.`,
+Supports text files (automatically truncated if large) and image files (png, jpg, jpeg, gif, webp).
+For images, the file contents are returned as visual data you can see and analyze.
+Use this to understand existing code, check file contents, view screenshots, or gather context.`,
     inputSchema: readFileInputSchema,
-    execute: async ({ path, startLine, endLine }) => {
+    execute: async ({ path: filePath, startLine, endLine }) => {
       try {
-        const absolutePath = isAbsolute(path) ? path : resolve2(options.workingDirectory, path);
+        const absolutePath = isAbsolute(filePath) ? filePath : resolve2(options.workingDirectory, filePath);
         const relativePath = relative(options.workingDirectory, absolutePath);
-        if (relativePath.startsWith("..") && !isAbsolute(path)) {
+        if (relativePath.startsWith("..") && !isAbsolute(filePath)) {
           return {
             success: false,
             error: "Path escapes the working directory. Use an absolute path if intentional.",
@@ -3068,22 +3262,43 @@ Use this to understand existing code, check file contents, or gather context.`,
         if (!existsSync3(absolutePath)) {
           return {
             success: false,
-            error: `File not found: ${path}`,
+            error: `File not found: ${filePath}`,
             content: null
           };
         }
         const stats = await stat(absolutePath);
-        if (stats.size > MAX_FILE_SIZE) {
+        if (stats.isDirectory()) {
           return {
             success: false,
-            error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB.`,
+            error: 'Path is a directory, not a file. Use bash with "ls" to list directory contents.',
             content: null
           };
         }
-        if (stats.isDirectory()) {
+        if (isImageFile(absolutePath)) {
+          if (stats.size > MAX_IMAGE_SIZE) {
+            return {
+              success: false,
+              error: `Image is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_IMAGE_SIZE / 1024 / 1024}MB.`,
+              content: null
+            };
+          }
+          const buffer = await readFile2(absolutePath);
+          const base64 = buffer.toString("base64");
+          const mediaType = getImageMediaType(absolutePath);
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative(options.workingDirectory, absolutePath),
+            content: `[Image: ${relativePath} (${mediaType}, ${(stats.size / 1024).toFixed(1)}KB)]`,
+            mediaType,
+            imageData: base64,
+            sizeBytes: stats.size
+          };
+        }
+        if (stats.size > MAX_FILE_SIZE) {
           return {
             success: false,
-            error: 'Path is a directory, not a file. Use bash with "ls" to list directory contents.',
+            error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB.`,
             content: null
           };
         }
@@ -3099,9 +3314,7 @@ Use this to understand existing code, check file contents, or gather context.`,
               content: null
             };
           }
-          content = lines.slice(start, end).join("\n");
-          const lineNumbers = lines.slice(start, end).map((line, idx) => `${(start + idx + 1).toString().padStart(4)}: ${line}`).join("\n");
-          content = lineNumbers;
+          content = lines.slice(start, end).map((line, idx) => `${(start + idx + 1).toString().padStart(4)}: ${line}`).join("\n");
         }
         const truncatedContent = truncateOutput(content, MAX_OUTPUT_CHARS3);
         const wasTruncated = truncatedContent.length < content.length;
@@ -3128,6 +3341,19 @@ Use this to understand existing code, check file contents, or gather context.`,
           content: null
         };
       }
+    },
+    toModelOutput: ({ output }) => {
+      if (output && typeof output === "object" && "imageData" in output && output.imageData) {
+        const result = output;
+        return {
+          type: "content",
+          value: [
+            { type: "text", text: result.content },
+            { type: "image-data", data: result.imageData, mediaType: result.mediaType }
+          ]
+        };
+      }
+      return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
     }
   });
 }
@@ -3328,7 +3554,7 @@ function clearCheckpointManager(sessionId) {
 }
 
 // src/lsp/index.ts
-import { extname as extname2, dirname as dirname4 } from "path";
+import { extname as extname3, dirname as dirname4 } from "path";
 
 // src/lsp/servers.ts
 import { spawn } from "child_process";
@@ -3451,9 +3677,9 @@ import {
 import { pathToFileURL, fileURLToPath } from "url";
 import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { extname, normalize } from "path";
+import { extname as extname2, normalize } from "path";
 function getLanguageId(filePath) {
-  const ext = extname(filePath).toLowerCase();
+  const ext = extname2(filePath).toLowerCase();
   const map = {
     ".ts": "typescript",
     ".tsx": "typescriptreact",
@@ -3841,7 +4067,7 @@ var state = {
 };
 async function getClientForFile(filePath) {
   const normalized = normalizePath(filePath);
-  const ext = extname2(normalized);
+  const ext = extname3(normalized);
   const serverDef = getServerForExtension(ext);
   if (!serverDef) {
     return null;
@@ -3934,7 +4160,7 @@ async function formatDiagnosticsOutput(filePath, options = {}) {
   return formatDiagnosticsForAgent(filePath, diagnostics, options);
 }
 function isSupported(filePath) {
-  const ext = extname2(filePath);
+  const ext = extname3(filePath);
   return getServerForExtension(ext) !== null;
 }
 
@@ -4361,7 +4587,7 @@ Once loaded, a skill's content will be available in the conversation context.`,
 // src/tools/linter.ts
 import { tool as tool6 } from "ai";
 import { z as z7 } from "zod";
-import { resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3, extname as extname4 } from "path";
+import { resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3, extname as extname5 } from "path";
 import { existsSync as existsSync9 } from "fs";
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 var linterInputSchema = z7.object({
@@ -4384,7 +4610,7 @@ async function findSupportedFiles(dir, workingDirectory, maxFiles = 50) {
           }
           await walk(fullPath);
         } else if (entry.isFile()) {
-          const ext = extname4(entry.name);
+          const ext = extname5(entry.name);
           if (supportedExtensions.includes(ext)) {
             files.push(fullPath);
           }
@@ -5721,6 +5947,59 @@ Context: ${context}` : query;
 
 // src/tools/index.ts
 init_semantic_search();
+
+// src/tools/task.ts
+import { tool as tool11 } from "ai";
+import { z as z12 } from "zod";
+import Ajv from "ajv";
+var ajv = new Ajv({ allErrors: true });
+function createCompleteTaskTool(options) {
+  const validate = ajv.compile(options.outputSchema);
+  return tool11({
+    description: "Call this tool when you have completed the task. Pass the result as a JSON object matching the required output schema. If the result does not match the schema, you will receive validation errors and should fix and retry.",
+    inputSchema: z12.object({
+      result: z12.record(z12.string(), z12.unknown()).describe("The task result as a JSON object matching the output schema")
+    }),
+    execute: async (input) => {
+      const valid = validate(input.result);
+      if (!valid) {
+        const errors = validate.errors?.map((e) => ({
+          path: e.instancePath || "/",
+          message: e.message,
+          params: e.params
+        }));
+        return {
+          status: "validation_error",
+          message: "The result does not match the required output schema. Fix the errors and call complete_task again.",
+          errors,
+          expectedSchema: options.outputSchema
+        };
+      }
+      options.onComplete({ status: "completed", result: input.result });
+      return {
+        status: "completed",
+        message: "Task completed successfully."
+      };
+    }
+  });
+}
+function createTaskFailedTool(options) {
+  return tool11({
+    description: "Call this tool if you are unable to complete the task. Provide a clear reason explaining why the task cannot be completed.",
+    inputSchema: z12.object({
+      reason: z12.string().describe("Explanation of why the task cannot be completed")
+    }),
+    execute: async (input) => {
+      options.onComplete({ status: "failed", error: input.reason });
+      return {
+        status: "failed",
+        message: `Task marked as failed: ${input.reason}`
+      };
+    }
+  });
+}
+
+// src/tools/index.ts
 init_semantic();
 init_semantic_search();
 async function createTools(options) {
@@ -5772,6 +6051,10 @@ async function createTools(options) {
     } catch {
     }
   }
+  if (options.taskTools) {
+    tools.complete_task = createCompleteTaskTool(options.taskTools);
+    tools.task_failed = createTaskFailedTool(options.taskTools);
+  }
   return tools;
 }
 
@@ -6089,6 +6372,30 @@ function formatTodosForContext(todos) {
   }
   return lines.join("\n");
 }
+function buildTaskPromptAddendum(outputSchema) {
+  return `
+## Task Mode
+
+You are running in **task mode**. You have been given a specific task to complete autonomously.
+
+### Rules
+1. Work independently \u2014 no human will approve tool calls. All tools run without approval.
+2. Keep working until the task is fully complete.
+3. When done, call the \`complete_task\` tool with a JSON result matching the output schema below.
+4. If you determine the task is impossible or encounter an unrecoverable error, call the \`task_failed\` tool with a clear reason.
+5. Do NOT stop without calling one of these two tools.
+
+### Output Schema
+The \`complete_task\` tool expects a \`result\` object matching this JSON Schema:
+\`\`\`json
+${JSON.stringify(outputSchema, null, 2)}
+\`\`\`
+
+### Completion Tools
+- **\`complete_task({ result: ... })\`** \u2014 Call when the task is done. The result is validated against the schema above. If validation fails you will get errors back \u2014 fix and retry.
+- **\`task_failed({ reason: "..." })\`** \u2014 Call only if the task truly cannot be completed.
+`;
+}
 function createSummaryPrompt(conversationHistory) {
   return `Please provide a concise summary of the following conversation history. Focus on:
 1. The main task or goal being worked on
@@ -6350,6 +6657,25 @@ ${this.summary}`
   }
 };
 
+// src/utils/webhook.ts
+async function sendWebhook(url, event) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-SparkECoder-Event": event.type
+      },
+      body: JSON.stringify(event),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+  } catch {
+  }
+}
+
 // src/agent/index.ts
 var approvalResolvers = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
@@ -6569,6 +6895,145 @@ ${prompt}` });
       steps: result.steps
     };
   }
+  /**
+   * Run the agent in task mode — loops autonomously until the agent calls
+   * complete_task or task_failed (or hits maxIterations).
+   * All tools run without approval. Webhook events are fired throughout.
+   */
+  async runTask(options) {
+    const config = getConfig();
+    const maxIterations = options.taskConfig.maxIterations ?? 50;
+    const webhookUrl = options.taskConfig.webhookUrl;
+    const fireWebhook = (type, data) => {
+      if (!webhookUrl) return;
+      sendWebhook(webhookUrl, {
+        type,
+        taskId: this.session.id,
+        sessionId: this.session.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data
+      });
+    };
+    const completion = { signal: null };
+    const onComplete = (signal) => {
+      completion.signal = signal;
+    };
+    const taskTools = await createTools({
+      sessionId: this.session.id,
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0,
+      onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
+      onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0,
+      taskTools: {
+        outputSchema: options.taskConfig.outputSchema,
+        onComplete
+      }
+    });
+    const baseSystemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id,
+      discoveredSkills: config.discoveredSkills,
+      activeFiles: []
+    });
+    const taskAddendum = buildTaskPromptAddendum(options.taskConfig.outputSchema);
+    const systemPrompt = `${baseSystemPrompt}
+
+${taskAddendum}`;
+    fireWebhook("task.started", { prompt: options.prompt });
+    this.context.addUserMessage(options.prompt);
+    let iteration = 0;
+    while (iteration < maxIterations) {
+      iteration++;
+      if (options.abortSignal?.aborted) {
+        const cancelError = "Task was cancelled";
+        fireWebhook("task.failed", { status: "failed", error: cancelError, iterations: iteration });
+        return { status: "failed", error: cancelError, iterations: iteration };
+      }
+      const messages = await this.context.getMessages();
+      const useAnthropic = isAnthropicModel(this.session.model);
+      const result = await generateText3({
+        model: resolveModel(this.session.model),
+        system: systemPrompt,
+        messages,
+        tools: taskTools,
+        stopWhen: stepCountIs2(500),
+        abortSignal: options.abortSignal,
+        providerOptions: useAnthropic ? {
+          anthropic: {
+            thinking: { type: "enabled", budgetTokens: 1e4 }
+          }
+        } : void 0,
+        onStepFinish: (step) => {
+          options.onStepFinish?.(step);
+          fireWebhook("task.step_finished", { iteration, text: step.text });
+        }
+      });
+      const responseMessages = result.response.messages;
+      this.context.addResponseMessages(responseMessages);
+      if (result.text) {
+        options.onText?.(result.text);
+        fireWebhook("task.message", { iteration, text: result.text });
+      }
+      for (const step of result.steps) {
+        if (step.toolCalls) {
+          for (const tc of step.toolCalls) {
+            options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.args });
+            fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.args });
+          }
+        }
+        if (step.toolResults) {
+          for (const tr of step.toolResults) {
+            options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.result });
+            fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.result });
+          }
+        }
+      }
+      if (completion.signal) {
+        const sig = completion.signal;
+        const finalStatus = sig.status;
+        const eventType = finalStatus === "completed" ? "task.completed" : "task.failed";
+        fireWebhook(eventType, {
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        });
+        const updatedTask2 = {
+          ...options.taskConfig,
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        };
+        await sessionQueries.update(this.session.id, {
+          config: { ...this.session.config, task: updatedTask2 }
+        });
+        return {
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        };
+      }
+      this.context.addUserMessage(
+        "Continue working on the task. When done, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason."
+      );
+    }
+    const timeoutError = `Task did not complete within ${maxIterations} iterations`;
+    fireWebhook("task.failed", { status: "failed", error: timeoutError, iterations: iteration });
+    const updatedTask = {
+      ...options.taskConfig,
+      status: "failed",
+      error: timeoutError,
+      iterations: iteration
+    };
+    await sessionQueries.update(this.session.id, {
+      config: { ...this.session.config, task: updatedTask }
+    });
+    return { status: "failed", error: timeoutError, iterations: iteration };
+  }
   /**
    * Wrap tools to add approval checking
    */
@@ -6582,9 +7047,9 @@ ${prompt}` });
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool11({
+      wrappedTools[name] = tool12({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z12.object({}),
+        inputSchema: originalTool.inputSchema || z13.object({}),
         execute: async (input, toolOptions) => {
           const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
@@ -6725,18 +7190,18 @@ function cleanupPendingInputs() {
     }
   }
 }
-var createSessionSchema = z13.object({
-  name: z13.string().optional(),
-  workingDirectory: z13.string().optional(),
-  model: z13.string().optional(),
-  toolApprovals: z13.record(z13.string(), z13.boolean()).optional()
+var createSessionSchema = z14.object({
+  name: z14.string().optional(),
+  workingDirectory: z14.string().optional(),
+  model: z14.string().optional(),
+  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
 });
-var paginationQuerySchema = z13.object({
-  limit: z13.string().optional(),
-  offset: z13.string().optional()
+var paginationQuerySchema = z14.object({
+  limit: z14.string().optional(),
+  offset: z14.string().optional()
 });
-var messagesQuerySchema = z13.object({
-  limit: z13.string().optional()
+var messagesQuerySchema = z14.object({
+  limit: z14.string().optional()
 });
 sessions.get(
   "/",
@@ -6875,10 +7340,10 @@ sessions.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z13.object({
-  model: z13.string().optional(),
-  name: z13.string().optional(),
-  toolApprovals: z13.record(z13.string(), z13.boolean()).optional()
+var updateSessionSchema = z14.object({
+  model: z14.string().optional(),
+  name: z14.string().optional(),
+  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
 });
 sessions.patch(
   "/:id",
@@ -6948,8 +7413,8 @@ sessions.post("/:id/clear", async (c) => {
   await agent.clearContext();
   return c.json({ success: true, sessionId: id });
 });
-var pendingInputSchema = z13.object({
-  text: z13.string()
+var pendingInputSchema = z14.object({
+  text: z14.string()
 });
 sessions.post(
   "/:id/pending-input",
@@ -6980,13 +7445,13 @@ sessions.get("/:id/pending-input", async (c) => {
     createdAt: pending.createdAt.toISOString()
   });
 });
-var devtoolsContextSchema = z13.object({
-  url: z13.string(),
-  path: z13.string(),
-  pageName: z13.string().optional(),
-  screenWidth: z13.number().optional(),
-  screenHeight: z13.number().optional(),
-  devicePixelRatio: z13.number().optional()
+var devtoolsContextSchema = z14.object({
+  url: z14.string(),
+  path: z14.string(),
+  pageName: z14.string().optional(),
+  screenWidth: z14.number().optional(),
+  screenHeight: z14.number().optional(),
+  devicePixelRatio: z14.number().optional()
 });
 sessions.post(
   "/:id/devtools-context",
@@ -7208,7 +7673,7 @@ sessions.post("/:id/attachments", async (c) => {
       }
       const dir = ensureAttachmentsDir(sessionId);
       const id = nanoid4(10);
-      const ext = extname6(file.name) || "";
+      const ext = extname7(file.name) || "";
       const safeFilename = `${id}_${basename4(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
       const filePath = join5(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
@@ -7234,7 +7699,7 @@ sessions.post("/:id/attachments", async (c) => {
     }
     const dir = ensureAttachmentsDir(sessionId);
     const id = nanoid4(10);
-    const ext = extname6(body.filename) || "";
+    const ext = extname7(body.filename) || "";
     const safeFilename = `${id}_${basename4(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
     const filePath = join5(dir, safeFilename);
     let base64Data = body.data;
@@ -7277,10 +7742,10 @@ sessions.delete("/:id/attachments/:attachmentId", async (c) => {
   unlinkSync(filePath);
   return c.json({ success: true, id: attachmentId });
 });
-var filesQuerySchema = z13.object({
-  query: z13.string().optional(),
+var filesQuerySchema = z14.object({
+  query: z14.string().optional(),
   // Filter query (e.g., "src/com" to match "src/components")
-  limit: z13.string().optional()
+  limit: z14.string().optional()
   // Max results (default 50)
 });
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -7364,7 +7829,7 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const ext = extname6(entry.name).toLowerCase();
+      const ext = extname7(entry.name).toLowerCase();
       if (IGNORED_EXTENSIONS.has(ext)) {
         continue;
       }
@@ -7458,7 +7923,7 @@ sessions.get(
 init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join6 } from "path";
 init_config();
@@ -7623,30 +8088,30 @@ function enrichPromptWithDevtoolsContext(sessionId, prompt) {
 ${prompt}`;
 }
 var agents = new Hono2();
-var attachmentSchema = z14.object({
-  type: z14.enum(["image", "file"]),
-  data: z14.string(),
+var attachmentSchema = z15.object({
+  type: z15.enum(["image", "file"]),
+  data: z15.string(),
   // base64 data URL or raw base64
-  mediaType: z14.string().optional(),
-  filename: z14.string().optional()
+  mediaType: z15.string().optional(),
+  filename: z15.string().optional()
 });
-var runPromptSchema = z14.object({
-  prompt: z14.string(),
+var runPromptSchema = z15.object({
+  prompt: z15.string(),
   // Can be empty if attachments are provided
-  attachments: z14.array(attachmentSchema).optional()
+  attachments: z15.array(attachmentSchema).optional()
 }).refine(
   (data) => data.prompt.trim().length > 0 || data.attachments && data.attachments.length > 0,
   { message: "Either prompt or attachments must be provided" }
 );
-var quickStartSchema = z14.object({
-  prompt: z14.string().min(1),
-  name: z14.string().optional(),
-  workingDirectory: z14.string().optional(),
-  model: z14.string().optional(),
-  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
+var quickStartSchema = z15.object({
+  prompt: z15.string().min(1),
+  name: z15.string().optional(),
+  workingDirectory: z15.string().optional(),
+  model: z15.string().optional(),
+  toolApprovals: z15.record(z15.string(), z15.boolean()).optional()
 });
-var rejectSchema = z14.object({
-  reason: z14.string().optional()
+var rejectSchema = z15.object({
+  reason: z15.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
@@ -8076,7 +8541,7 @@ agents.get("/:id/watch", async (c) => {
       "Cache-Control": "no-cache",
       "Connection": "keep-alive",
       "x-vercel-ai-ui-message-stream": "v1",
-      "x-stream-id": streamId
+      "x-stream-id": streamId ?? ""
     }
   });
 });
@@ -8434,7 +8899,7 @@ agents.post(
 init_config();
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname6, join as join7 } from "path";
@@ -8544,9 +9009,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z15.object({
-  provider: z15.string(),
-  apiKey: z15.string().min(1)
+var setApiKeySchema = z16.object({
+  provider: z16.string(),
+  apiKey: z16.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -8585,13 +9050,13 @@ health.delete("/api-keys/:provider", async (c) => {
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 init_db();
 var terminals = new Hono4();
-var spawnSchema = z16.object({
-  command: z16.string(),
-  cwd: z16.string().optional(),
-  name: z16.string().optional()
+var spawnSchema = z17.object({
+  command: z17.string(),
+  cwd: z17.string().optional(),
+  name: z17.string().optional()
 });
 terminals.post(
   "/:sessionId/terminals",
@@ -8672,8 +9137,8 @@ terminals.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z16.object({
-  tail: z16.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z17.object({
+  tail: z17.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals.get(
   "/:sessionId/terminals/:terminalId/logs",
@@ -8697,8 +9162,8 @@ terminals.get(
     });
   }
 );
-var killSchema = z16.object({
-  signal: z16.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z17.object({
+  signal: z17.enum(["SIGTERM", "SIGKILL"]).optional()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/kill",
@@ -8712,8 +9177,8 @@ terminals.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z16.object({
-  input: z16.string()
+var writeSchema = z17.object({
+  input: z17.string()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/write",
@@ -8894,6 +9359,131 @@ data: ${JSON.stringify({ status: "stopped" })}
   );
 });
 
+// src/server/routes/tasks.ts
+init_db();
+import { Hono as Hono5 } from "hono";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { z as z18 } from "zod";
+init_config();
+var tasks = new Hono5();
+var taskAbortControllers = /* @__PURE__ */ new Map();
+var createTaskSchema = z18.object({
+  prompt: z18.string().min(1),
+  outputSchema: z18.record(z18.string(), z18.unknown()),
+  webhookUrl: z18.string().url().optional(),
+  model: z18.string().optional(),
+  workingDirectory: z18.string().optional(),
+  name: z18.string().optional(),
+  maxIterations: z18.number().int().min(1).max(500).optional()
+});
+tasks.post(
+  "/",
+  zValidator5("json", createTaskSchema),
+  async (c) => {
+    const body = c.req.valid("json");
+    const config = getConfig();
+    const taskConfig = {
+      enabled: true,
+      outputSchema: body.outputSchema,
+      webhookUrl: body.webhookUrl,
+      maxIterations: body.maxIterations ?? 50,
+      status: "running"
+    };
+    const agent = await Agent.create({
+      name: body.name || "Task",
+      workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
+      model: body.model || config.defaultModel,
+      sessionConfig: {
+        toolApprovals: { bash: false, write_file: false, read_file: false },
+        task: taskConfig
+      }
+    });
+    const taskId = agent.sessionId;
+    const abortController = new AbortController();
+    taskAbortControllers.set(taskId, abortController);
+    (async () => {
+      try {
+        await agent.runTask({
+          prompt: body.prompt,
+          taskConfig,
+          abortSignal: abortController.signal
+        });
+      } catch (err) {
+        if (err.name === "AbortError" || abortController.signal.aborted) {
+          console.log(`[TASK] Task ${taskId} was cancelled`);
+        } else {
+          console.error(`[TASK] Error in task ${taskId}:`, err.message);
+          const failedTask = {
+            ...taskConfig,
+            status: "failed",
+            error: err.message || "Unknown error"
+          };
+          await sessionQueries.update(taskId, {
+            config: {
+              toolApprovals: { bash: false, write_file: false, read_file: false },
+              task: failedTask
+            }
+          });
+        }
+      } finally {
+        taskAbortControllers.delete(taskId);
+      }
+    })();
+    return c.json({ taskId, status: "running" }, 201);
+  }
+);
+tasks.get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Task not found" }, 404);
+  }
+  const task = session.config?.task;
+  if (!task?.enabled) {
+    return c.json({ error: "Session is not a task" }, 400);
+  }
+  return c.json({
+    taskId: id,
+    status: task.status,
+    result: task.result,
+    error: task.error,
+    iterations: task.iterations,
+    model: session.model,
+    name: session.name,
+    createdAt: session.createdAt.toISOString(),
+    updatedAt: session.updatedAt.toISOString()
+  });
+});
+tasks.post("/:id/cancel", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Task not found" }, 404);
+  }
+  const task = session.config?.task;
+  if (!task?.enabled) {
+    return c.json({ error: "Session is not a task" }, 400);
+  }
+  if (task.status !== "running") {
+    return c.json({ error: `Task is already ${task.status}` }, 400);
+  }
+  const abortController = taskAbortControllers.get(id);
+  if (abortController) {
+    abortController.abort();
+    taskAbortControllers.delete(id);
+  }
+  const cancelledTask = {
+    ...task,
+    status: "failed",
+    error: "Task cancelled by user"
+  };
+  await sessionQueries.update(id, {
+    config: { ...session.config, task: cancelledTask }
+  });
+  return c.json({ taskId: id, status: "failed", error: "Task cancelled by user" });
+});
+var tasks_default = tasks;
+
 // src/server/index.ts
 init_config();
 init_db();
@@ -8974,6 +9564,43 @@ async function checkDependencies(options = {}) {
   }
   return true;
 }
+async function checkAgentBrowser() {
+  try {
+    const { stdout } = await execAsync5("agent-browser --version", { timeout: 1e4 });
+    const version = stdout.trim();
+    return { available: true, version };
+  } catch {
+    return {
+      available: false,
+      error: "agent-browser is not installed globally",
+      installInstructions: "Install agent-browser globally:\n  npm install -g agent-browser\n  agent-browser install"
+    };
+  }
+}
+async function tryInstallAgentBrowser(options = {}) {
+  try {
+    if (!options.quiet) {
+      console.log("\u{1F4E6} Installing agent-browser globally...");
+    }
+    await execAsync5("npm install -g agent-browser", { timeout: 12e4 });
+    try {
+      if (!options.quiet) {
+        console.log("\u{1F4E6} Installing Chromium for browser automation...");
+      }
+      await execAsync5("agent-browser install", { timeout: 12e4 });
+    } catch {
+    }
+    if (!options.quiet) {
+      console.log("\u2705 agent-browser installed successfully");
+    }
+    return true;
+  } catch (error) {
+    if (!options.quiet) {
+      console.error(`Failed to install agent-browser: ${error.message}`);
+    }
+    return false;
+  }
+}
 async function tryAutoInstallTmux() {
   const os2 = platform2();
   try {
@@ -9018,16 +9645,20 @@ async function tryAutoInstallTmux() {
 async function ensureDependencies(options = {}) {
   const { autoInstall = false, quiet = false } = options;
   const tmuxCheck = await checkTmux();
-  if (tmuxCheck.available) {
-    return;
-  }
-  if (autoInstall) {
-    const installed = await tryAutoInstallTmux();
-    if (installed) {
-      return;
+  if (!tmuxCheck.available) {
+    if (autoInstall) {
+      const installed = await tryAutoInstallTmux();
+      if (!installed) {
+        await checkDependencies({ quiet, exitOnFailure: true });
+      }
+    } else {
+      await checkDependencies({ quiet, exitOnFailure: true });
     }
   }
-  await checkDependencies({ quiet, exitOnFailure: true });
+  const browserCheck = await checkAgentBrowser();
+  if (!browserCheck.available) {
+    await tryInstallAgentBrowser({ quiet });
+  }
 }
 
 // src/server/index.ts
@@ -9285,7 +9916,7 @@ function stopWebUI() {
   }
 }
 async function createApp(options = {}) {
-  const app = new Hono5();
+  const app = new Hono6();
   app.use("*", cors({
     origin: "*",
     // Allow all origins
@@ -9303,6 +9934,7 @@ async function createApp(options = {}) {
   app.route("/agents", agents);
   app.route("/sessions", terminals);
   app.route("/terminals", terminals);
+  app.route("/tasks", tasks_default);
   app.get("/openapi.json", async (c) => {
     return c.json(generateOpenAPISpec());
   });
@@ -9872,7 +10504,7 @@ function generateOpenAPISpec() {
 init_config();
 init_semantic();
 init_db();
-import { writeFileSync as writeFileSync5, existsSync as existsSync16 } from "fs";
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync16 } from "fs";
 import { resolve as resolve11, join as join9 } from "path";
 async function apiRequest(baseUrl, path, options = {}) {
   const url = `${baseUrl}${path}`;
@@ -9912,9 +10544,15 @@ function promptApproval(rl, toolName, input) {
     const inputStr = JSON.stringify(input);
     const truncatedInput = inputStr.length > 100 ? inputStr.slice(0, 100) + "..." : inputStr;
     console.log(chalk.dim(`    Command: ${truncatedInput}`));
-    rl.question(chalk.yellow(`    Approve? [y/n]: `), (answer) => {
-      const approved = answer.toLowerCase().startsWith("y");
-      resolve12(approved);
+    rl.question(chalk.yellow(`    Approve? [y/n/a(lways)]: `), (answer) => {
+      const lower = answer.toLowerCase().trim();
+      if (lower === "a" || lower === "always") {
+        resolve12("always");
+      } else if (lower.startsWith("y")) {
+        resolve12("approve");
+      } else {
+        resolve12("reject");
+      }
     });
   });
 }
@@ -9976,14 +10614,27 @@ async function consumeSSEStream(response, options = {}) {
           }
           if (event.type === "data-approval-required") {
             const approval = event.data;
-            console.log(chalk.yellow(`
+            if (options.skipApprovals && options.baseUrl && options.sessionId) {
+              console.log(chalk.dim(`  \u2713 Auto-approved: ${approval.toolName}`));
+              await apiRequest(options.baseUrl, `/agents/${options.sessionId}/approve/${approval.toolCallId}`, { method: "POST" });
+            } else if (options.interactive && options.baseUrl && options.sessionId && options.readline) {
+              console.log(chalk.yellow(`
 \u26A0\uFE0F  Approval required for: ${approval.toolName}`));
-            if (options.interactive && options.baseUrl && options.sessionId && options.readline) {
-              const approved = await promptApproval(options.readline, approval.toolName, approval.input);
-              const endpoint = approved ? "approve" : "reject";
+              const result = await promptApproval(options.readline, approval.toolName, approval.input);
+              const endpoint = result === "reject" ? "reject" : "approve";
               const apiResponse = await apiRequest(options.baseUrl, `/agents/${options.sessionId}/${endpoint}/${approval.toolCallId}`, { method: "POST" });
               if (apiResponse.ok) {
-                console.log(approved ? chalk.green("    \u2713 Approved") : chalk.red("    \u2717 Rejected"));
+                if (result === "always") {
+                  await apiRequest(options.baseUrl, `/sessions/${options.sessionId}`, {
+                    method: "PATCH",
+                    body: { toolApprovals: { [approval.toolName]: false } }
+                  });
+                  console.log(chalk.green(`    \u2713 Always allowed \u2014 ${approval.toolName} won't ask again this session`));
+                } else if (result === "approve") {
+                  console.log(chalk.green("    \u2713 Approved"));
+                } else {
+                  console.log(chalk.red("    \u2717 Rejected"));
+                }
               } else {
                 console.log(chalk.red(`    Failed to ${endpoint}: ${apiResponse.statusText}`));
               }
@@ -10122,6 +10773,7 @@ async function runChat(options) {
       output: process.stdout
     });
     let sessionId;
+    const skipApprovals = !!options.dangerouslySkipApprovals;
     if (options.session) {
       const response = await apiRequest(baseUrl, `/sessions/${options.session}`);
       if (!response.ok) {
@@ -10131,6 +10783,12 @@ async function runChat(options) {
       const session = await response.json();
       sessionId = session.id;
       console.log(chalk.dim(`Resuming session: ${session.name || sessionId}`));
+      if (skipApprovals) {
+        await apiRequest(baseUrl, `/sessions/${sessionId}`, {
+          method: "PATCH",
+          body: { toolApprovals: { "*": false } }
+        });
+      }
       const streamInfo = await getActiveStream(baseUrl, sessionId);
       if (streamInfo.hasActiveStream && streamInfo.streamId) {
         console.log(chalk.cyan(`
@@ -10141,7 +10799,7 @@ async function runChat(options) {
         try {
           const watchResponse = await fetch(`${baseUrl}/agents/${sessionId}/watch?streamId=${streamInfo.streamId}`);
           if (watchResponse.ok) {
-            await consumeSSEStream(watchResponse, { interactive: true, baseUrl, sessionId, readline: rl });
+            await consumeSSEStream(watchResponse, { interactive: true, skipApprovals, baseUrl, sessionId, readline: rl });
           }
         } catch (err) {
           console.log(chalk.dim("Stream ended or connection lost."));
@@ -10150,13 +10808,17 @@ async function runChat(options) {
       }
     } else {
       const config = loadConfig(options.config, options.workingDir);
+      const sessionBody = {
+        name: options.name || "CLI Chat",
+        workingDirectory: options.workingDir || config.resolvedWorkingDirectory,
+        model: options.model || config.defaultModel
+      };
+      if (skipApprovals) {
+        sessionBody.toolApprovals = { "*": false };
+      }
       const response = await apiRequest(baseUrl, "/sessions", {
         method: "POST",
-        body: {
-          name: options.name || "CLI Chat",
-          workingDirectory: options.workingDir || config.resolvedWorkingDirectory,
-          model: options.model || config.defaultModel
-        }
+        body: sessionBody
       });
       if (!response.ok) {
         const error = await response.json();
@@ -10172,6 +10834,9 @@ async function runChat(options) {
     console.log("");
     console.log(chalk.bold.cyan("\u{1F436} SparkECoder"));
     console.log(chalk.dim(`Working directory: ${workingDir}`));
+    if (skipApprovals) {
+      console.log(chalk.yellow("\u26A1 All tool approvals disabled (--dangerously-skip-approvals)"));
+    }
     console.log(chalk.dim("Commands: /quit, /clear, /session, /tools, /help"));
     console.log("");
     const prompt = () => {
@@ -10200,6 +10865,7 @@ async function runChat(options) {
               console.log(chalk.dim("  /approve <id>      - Approve pending tool call"));
               console.log(chalk.dim("  /reject <id>       - Reject pending tool call"));
               console.log(chalk.dim("  /approvals         - List pending approvals"));
+              console.log(chalk.dim("  /allow <tool>      - Always allow a tool (skip approval)"));
               console.log(chalk.dim("  /help, /?          - Show this help"));
               prompt();
               return;
@@ -10211,7 +10877,7 @@ async function runChat(options) {
                 try {
                   const watchResponse = await fetch(`${baseUrl}/agents/${sessionId}/watch?streamId=${streamInfo.streamId}`);
                   if (watchResponse.ok) {
-                    await consumeSSEStream(watchResponse, { interactive: true, baseUrl, sessionId, readline: rl });
+                    await consumeSSEStream(watchResponse, { interactive: true, skipApprovals, baseUrl, sessionId, readline: rl });
                   } else {
                     console.log(chalk.dim("Failed to connect to stream."));
                   }
@@ -10277,6 +10943,26 @@ async function runChat(options) {
               prompt();
               return;
             }
+            if (cmd.startsWith("/allow ")) {
+              const toolName = trimmed.slice(7).trim();
+              if (!toolName) {
+                console.log(chalk.yellow("Usage: /allow <toolName>  (e.g., /allow bash)"));
+                prompt();
+                return;
+              }
+              const response = await apiRequest(baseUrl, `/sessions/${sessionId}`, {
+                method: "PATCH",
+                body: { toolApprovals: { [toolName]: false } }
+              });
+              if (response.ok) {
+                console.log(chalk.green(`\u2713 ${toolName} will no longer require approval this session`));
+              } else {
+                const error = await response.json();
+                console.log(chalk.red(`Failed: ${error.error || "Unknown error"}`));
+              }
+              prompt();
+              return;
+            }
             if (cmd === "/clear") {
               const response = await apiRequest(baseUrl, `/sessions/${sessionId}/clear`, { method: "POST" });
               if (response.ok) {
@@ -10353,7 +11039,7 @@ async function runChat(options) {
               const error = await response.json();
               throw new Error(error.error || `HTTP ${response.status}`);
             }
-            await consumeSSEStream(response, { interactive: true, baseUrl, sessionId, readline: rl });
+            await consumeSSEStream(response, { interactive: true, skipApprovals, baseUrl, sessionId, readline: rl });
           } catch (error) {
             process.stdout.write("\r" + " ".repeat(20) + "\r");
             console.log(chalk.red(`
@@ -10382,7 +11068,7 @@ Unexpected error: ${outerError.message}`));
   }
 }
 var program = new Command();
-program.name("sparkecoder").description("AI coding agent - just type sparkecoder to start chatting").version("0.1.0").option("-s, --session <id>", "Resume an existing session").option("-n, --name <name>", "Name for the new session").option("-m, --model <model>", "Model to use").option("-w, --working-dir <path>", "Working directory").option("-c, --config <path>", "Path to config file").option("-p, --port <port>", "Server port", "3141").option("-H, --host <host>", "Server host", "127.0.0.1").option("--no-auto-start", "Do not auto-start server if not running").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI when auto-starting server").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").action(async (options) => {
+program.name("sparkecoder").description("AI coding agent - just type sparkecoder to start chatting").version("0.1.0").option("-s, --session <id>", "Resume an existing session").option("-n, --name <name>", "Name for the new session").option("-m, --model <model>", "Model to use").option("-w, --working-dir <path>", "Working directory").option("-c, --config <path>", "Path to config file").option("-p, --port <port>", "Server port", "3141").option("-H, --host <host>", "Server host", "127.0.0.1").option("--no-auto-start", "Do not auto-start server if not running").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI when auto-starting server").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").option("--dangerously-skip-approvals", "Auto-approve all tool calls (no confirmation prompts)").action(async (options) => {
   await runChat(options);
 });
 program.command("server").description("Start the SparkECoder server (API + Web UI)").option("-p, --port <port>", "API server port", "3141").option("-h, --host <host>", "Server host", "127.0.0.1").option("-c, --config <path>", "Path to config file").option("-w, --working-dir <path>", "Working directory").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").action(async (options) => {
@@ -10422,9 +11108,100 @@ program.command("server").description("Start the SparkECoder server (API + Web U
     process.exit(1);
   }
 });
-program.command("chat").description("Start an interactive chat session").option("-s, --session <id>", "Resume an existing session").option("-n, --name <name>", "Name for the new session").option("-m, --model <model>", "Model to use").option("-w, --working-dir <path>", "Working directory").option("-c, --config <path>", "Path to config file").option("-p, --port <port>", "Server port", "3141").option("-H, --host <host>", "Server host", "127.0.0.1").option("--no-auto-start", "Do not auto-start server if not running").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI when auto-starting server").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").action(async (options) => {
+program.command("chat").description("Start an interactive chat session").option("-s, --session <id>", "Resume an existing session").option("-n, --name <name>", "Name for the new session").option("-m, --model <model>", "Model to use").option("-w, --working-dir <path>", "Working directory").option("-c, --config <path>", "Path to config file").option("-p, --port <port>", "Server port", "3141").option("-H, --host <host>", "Server host", "127.0.0.1").option("--no-auto-start", "Do not auto-start server if not running").option("--web-port <port>", "Web UI port", "6969").option("--no-web", "Do not start web UI when auto-starting server").option("--public-url <url>", "Public URL for web UI to connect to API (for Docker/remote access)").option("-v, --verbose", "Enable verbose logging for web server").option("--dangerously-skip-approvals", "Auto-approve all tool calls (no confirmation prompts)").action(async (options) => {
   await runChat(options);
 });
+program.command("task").description("Run an autonomous task that completes without human interaction").requiredOption("--prompt <prompt>", "Task prompt describing what to do").requiredOption("--schema <schema>", "JSON Schema for the output (file path or inline JSON string)").option("--webhook <url>", "Webhook URL to receive task events").option("-m, --model <model>", "Model to use").option("-w, --working-dir <path>", "Working directory").option("-n, --name <name>", "Name for the task").option("--max-iterations <n>", "Maximum agent loop iterations", "50").option("-p, --port <port>", "Server port", "3141").option("-H, --host <host>", "Server host", "127.0.0.1").option("-c, --config <path>", "Path to config file").option("--no-auto-start", "Do not auto-start server if not running").option("--wait", "Block and poll until task completes").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+  await ensureDependencies({ quiet: true });
+  loadApiKeysIntoEnv();
+  const baseUrl = `http://${options.host}:${options.port}`;
+  const running = await isServerRunning(baseUrl);
+  if (!running) {
+    if (options.autoStart === false) {
+      console.error(chalk.red(`Server not running at ${baseUrl}`));
+      process.exit(1);
+    }
+    const spinner2 = ora("Starting server...").start();
+    try {
+      await startServer({
+        port: parseInt(options.port),
+        host: options.host,
+        configPath: options.config,
+        workingDirectory: options.workingDir,
+        quiet: true,
+        webUI: false
+      });
+      spinner2.succeed("Server started");
+    } catch (err) {
+      spinner2.fail(chalk.red(`Failed to start server: ${err.message}`));
+      process.exit(1);
+    }
+  }
+  let outputSchema;
+  try {
+    const schemaStr = options.schema;
+    if (existsSync16(schemaStr)) {
+      outputSchema = JSON.parse(readFileSync6(schemaStr, "utf-8"));
+    } else {
+      outputSchema = JSON.parse(schemaStr);
+    }
+  } catch (err) {
+    console.error(chalk.red(`Invalid schema: ${err.message}`));
+    console.error(chalk.dim("Provide a path to a JSON Schema file or an inline JSON string"));
+    process.exit(1);
+  }
+  const body = {
+    prompt: options.prompt,
+    outputSchema,
+    maxIterations: parseInt(options.maxIterations)
+  };
+  if (options.webhook) body.webhookUrl = options.webhook;
+  if (options.model) body.model = options.model;
+  if (options.workingDir) body.workingDirectory = options.workingDir;
+  if (options.name) body.name = options.name;
+  const spinner = ora("Creating task...").start();
+  const response = await apiRequest(baseUrl, "/tasks", {
+    method: "POST",
+    body
+  });
+  if (!response.ok) {
+    const err = await response.json();
+    spinner.fail(chalk.red(`Failed to create task: ${err.error || "Unknown error"}`));
+    process.exit(1);
+  }
+  const { taskId } = await response.json();
+  spinner.succeed(`Task created: ${chalk.cyan(taskId)}`);
+  if (!options.wait) {
+    console.log("");
+    console.log(chalk.dim("Task is running in the background."));
+    console.log(chalk.dim(`Check status:  sparkecoder task-status ${taskId} --port ${options.port}`));
+    console.log(chalk.dim(`Cancel:        curl -X POST ${baseUrl}/tasks/${taskId}/cancel`));
+    process.exit(0);
+  }
+  console.log(chalk.dim("\nWaiting for task to complete..."));
+  const pollInterval = 3e3;
+  while (true) {
+    await new Promise((r) => setTimeout(r, pollInterval));
+    const statusRes = await apiRequest(baseUrl, `/tasks/${taskId}`);
+    if (!statusRes.ok) {
+      console.error(chalk.red("Failed to check task status"));
+      process.exit(1);
+    }
+    const status = await statusRes.json();
+    if (status.status === "completed") {
+      console.log(chalk.green(`
+Task completed in ${status.iterations} iteration(s).`));
+      console.log(chalk.bold("Result:"));
+      console.log(JSON.stringify(status.result, null, 2));
+      process.exit(0);
+    } else if (status.status === "failed") {
+      console.error(chalk.red(`
+Task failed: ${status.error}`));
+      process.exit(1);
+    }
+    process.stdout.write(chalk.dim("."));
+  }
+});
 program.command("init").description("Create a sparkecoder.config.json file").option("-f, --force", "Overwrite existing config").option("-g, --global", "Create global config in app data directory").action((options) => {
   let configPath;
   let configLocation;