sparkecoder 0.1.59 → 0.1.61

package/dist/index.js

@@ -8,590 +8,251 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/db/remote.ts
-function initRemoteDatabase(serverUrl, key) {
-  remoteServerUrl = serverUrl.replace(/\/$/, "");
-  authKey = key;
+// src/config/types.ts
+import { z } from "zod";
+var ToolApprovalConfigSchema, SkillMetadataSchema, TaskConfigSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
+var init_types = __esm({
+  "src/config/types.ts"() {
+    "use strict";
+    ToolApprovalConfigSchema = z.object({
+      bash: z.boolean().optional().default(true),
+      write_file: z.boolean().optional().default(false),
+      read_file: z.boolean().optional().default(false),
+      load_skill: z.boolean().optional().default(false),
+      todo: z.boolean().optional().default(false)
+    });
+    SkillMetadataSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      // Whether to always inject this skill into context (vs on-demand loading)
+      alwaysApply: z.boolean().optional().default(false),
+      // 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),
+      task: TaskConfigSchema.optional()
+    });
+    VectorGatewayConfigSchema = z.object({
+      // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
+      redisUrl: z.string().optional(),
+      // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
+      httpUrl: z.string().optional(),
+      // Embedding model to use (default: text-embedding-3-small)
+      embeddingModel: z.string().default("gemini-embedding-001"),
+      // Custom namespace override (auto-generated from git remote if not set)
+      namespace: z.string().optional(),
+      // File patterns to include in indexing
+      include: z.array(z.string()).optional().default([
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx",
+        "**/*.py",
+        "**/*.go",
+        "**/*.rs",
+        "**/*.java",
+        "**/*.md",
+        "**/*.mdx",
+        "**/*.txt"
+      ]),
+      // File patterns to exclude from indexing
+      exclude: z.array(z.string()).optional().default([
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/.next/**",
+        "**/*.min.js",
+        "**/*.bundle.js",
+        "**/pnpm-lock.yaml",
+        "**/package-lock.json",
+        "**/yarn.lock",
+        "**/.test-workspace/**",
+        "**/.semantic-test-workspace/**",
+        "**/.semantic-integration-test/**"
+      ])
+    }).optional();
+    RemoteServerConfigSchema = z.object({
+      // URL of the remote server (e.g., https://agent.sparkecode.com)
+      url: z.string().url().optional(),
+      // Auth key for the remote server (auto-generated on first use if not set)
+      // Can also be set via SPARKECODER_AUTH_KEY env var
+      authKey: z.string().optional()
+    }).optional();
+    SparkcoderConfigSchema = z.object({
+      // Default model to use (Vercel AI Gateway format)
+      defaultModel: z.string().default("anthropic/claude-opus-4-6"),
+      // Working directory for file operations
+      workingDirectory: z.string().optional(),
+      // Tool approval settings
+      toolApprovals: ToolApprovalConfigSchema.optional().default({}),
+      // Approval webhook URL (called when approval is needed)
+      approvalWebhook: z.string().url().optional(),
+      // Skills configuration
+      skills: z.object({
+        // Directory containing skill files
+        directory: z.string().optional().default("./skills"),
+        // Additional skill directories to include
+        additionalDirectories: z.array(z.string()).optional().default([])
+      }).optional().default({}),
+      // Context management
+      context: z.object({
+        // Maximum context size before summarization (in characters)
+        maxChars: z.number().optional().default(2e5),
+        // Enable automatic summarization
+        autoSummarize: z.boolean().optional().default(true),
+        // Number of recent messages to keep after summarization
+        keepRecentMessages: z.number().optional().default(10)
+      }).optional().default({}),
+      // Server configuration
+      server: z.object({
+        port: z.number().default(3141),
+        host: z.string().default("127.0.0.1"),
+        // Public URL for web UI to connect to API (for Docker/remote access)
+        // If not set, defaults to http://{host}:{port}
+        publicUrl: z.string().url().optional()
+      }).default({ port: 3141, host: "127.0.0.1" }),
+      // Database path (used for local SQLite - ignored if remoteServer is configured)
+      databasePath: z.string().optional().default("./sparkecoder.db"),
+      // Remote server configuration (for centralized storage)
+      // If configured, uses remote MongoDB instead of local SQLite
+      remoteServer: RemoteServerConfigSchema,
+      // Vector Gateway configuration for semantic search
+      vectorGateway: VectorGatewayConfigSchema
+    });
+  }
+});
+
+// src/config/index.ts
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir, platform } from "os";
+function discoverSkillDirectories(workingDir) {
+  const alwaysLoadedDirs = [];
+  const onDemandDirs = [];
+  const allDirectories = [];
+  let agentsMdPath = null;
+  const sparkRulesDir = join(workingDir, ".sparkecoder", "rules");
+  if (existsSync(sparkRulesDir)) {
+    alwaysLoadedDirs.push({ path: sparkRulesDir, priority: 1 });
+    allDirectories.push(sparkRulesDir);
+  }
+  const sparkSkillsDir = join(workingDir, ".sparkecoder", "skills");
+  if (existsSync(sparkSkillsDir)) {
+    onDemandDirs.push({ path: sparkSkillsDir, priority: 2 });
+    allDirectories.push(sparkSkillsDir);
+  }
+  const cursorRulesDir = join(workingDir, ".cursor", "rules");
+  if (existsSync(cursorRulesDir)) {
+    onDemandDirs.push({ path: cursorRulesDir, priority: 3 });
+    allDirectories.push(cursorRulesDir);
+  }
+  const claudeSkillsDir = join(workingDir, ".claude", "skills");
+  if (existsSync(claudeSkillsDir)) {
+    onDemandDirs.push({ path: claudeSkillsDir, priority: 4 });
+    allDirectories.push(claudeSkillsDir);
+  }
+  const legacySkillsDir = join(workingDir, "skills");
+  if (existsSync(legacySkillsDir)) {
+    onDemandDirs.push({ path: legacySkillsDir, priority: 5 });
+    allDirectories.push(legacySkillsDir);
+  }
+  const agentsMd = join(workingDir, "AGENTS.md");
+  if (existsSync(agentsMd)) {
+    agentsMdPath = agentsMd;
+  }
+  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);
+  }
+  return {
+    alwaysLoadedDirs,
+    onDemandDirs,
+    agentsMdPath,
+    allDirectories
+  };
 }
-function closeRemoteDatabase() {
-  remoteServerUrl = null;
-  authKey = null;
+function getAppDataDirectory() {
+  const appName = "sparkecoder";
+  switch (platform()) {
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", appName);
+    case "win32":
+      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
+    default:
+      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
+  }
 }
-function parseDates(obj) {
-  if (obj === null || obj === void 0) return obj;
-  if (Array.isArray(obj)) return obj.map(parseDates);
-  if (typeof obj !== "object" || obj instanceof Date) return obj;
-  const result = { ...obj };
-  for (const key of Object.keys(result)) {
-    if (MODEL_MESSAGE_FIELDS.includes(key)) {
-      continue;
+function ensureAppDataDirectory() {
+  const dir = getAppDataDirectory();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function findConfigFile(startDir) {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = resolve(currentDir, fileName);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
     }
-    if (DATE_FIELDS.includes(key) && typeof result[key] === "string") {
-      result[key] = new Date(result[key]);
-    } else if (typeof result[key] === "object") {
-      result[key] = parseDates(result[key]);
+    currentDir = dirname(currentDir);
+  }
+  const appDataDir = getAppDataDirectory();
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = join(appDataDir, fileName);
+    if (existsSync(configPath)) {
+      return configPath;
     }
   }
-  return result;
+  return null;
 }
-async function api(path, options = {}) {
-  if (!remoteServerUrl || !authKey) {
-    throw new Error("Remote database not initialized");
-  }
-  const url = `${remoteServerUrl}/db${path}`;
-  const init = {
-    method: options.method || "GET",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${authKey}`
+function loadConfig(configPath, workingDirectory) {
+  const cwd = workingDirectory || process.cwd();
+  let rawConfig = {};
+  let configDir = cwd;
+  if (configPath) {
+    if (!existsSync(configPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    const content = readFileSync(configPath, "utf-8");
+    rawConfig = JSON.parse(content);
+    configDir = dirname(resolve(configPath));
+  } else {
+    const foundPath = findConfigFile(cwd);
+    if (foundPath) {
+      const content = readFileSync(foundPath, "utf-8");
+      rawConfig = JSON.parse(content);
+      configDir = dirname(foundPath);
     }
-  };
-  if (options.body) {
-    init.body = JSON.stringify(options.body);
   }
-  const response = await fetch(url, init);
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ error: "Unknown error" }));
-    throw new Error(error.error || `HTTP ${response.status}`);
-  }
-  const text = await response.text();
-  if (!text || text === "null") {
-    return null;
-  }
-  const parsed = JSON.parse(text);
-  if (options.skipParseDates) {
-    return parsed;
-  }
-  return parseDates(parsed);
-}
-var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, remoteSessionQueries, remoteMessageQueries, remoteToolExecutionQueries, remoteTodoQueries, remoteSkillQueries, remoteActiveStreamQueries, remoteCheckpointQueries, remoteFileBackupQueries, remoteSubagentQueries, remoteIndexStatusQueries;
-var init_remote = __esm({
-  "src/db/remote.ts"() {
-    "use strict";
-    remoteServerUrl = null;
-    authKey = null;
-    DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
-    MODEL_MESSAGE_FIELDS = ["modelMessage", "modelMessages"];
-    remoteSessionQueries = {
-      create(data) {
-        return api("/sessions", { method: "POST", body: data });
-      },
-      getById(id) {
-        return api(`/sessions/${id}`).catch(() => void 0);
-      },
-      list(limit = 50, offset = 0) {
-        return api(`/sessions?limit=${limit}&offset=${offset}`);
-      },
-      updateStatus(id, status) {
-        return api(`/sessions/${id}`, { method: "PATCH", body: { status } });
-      },
-      updateModel(id, model) {
-        return api(`/sessions/${id}`, { method: "PATCH", body: { model } });
-      },
-      update(id, updates) {
-        return api(`/sessions/${id}`, { method: "PATCH", body: updates });
-      },
-      delete(id) {
-        return api(`/sessions/${id}`, { method: "DELETE" }).then((r) => r?.success ?? false);
-      }
-    };
-    remoteMessageQueries = {
-      async getNextSequence(sessionId) {
-        const result = await api(`/messages/session/${sessionId}/next-sequence`);
-        return result.nextSequence;
-      },
-      create(sessionId, modelMessage) {
-        return api("/messages", { method: "POST", body: { sessionId, modelMessage } });
-      },
-      addMany(sessionId, modelMessages) {
-        return api("/messages/batch", { method: "POST", body: { sessionId, modelMessages } });
-      },
-      getBySession(sessionId) {
-        return api(`/messages/session/${sessionId}`);
-      },
-      getModelMessages(sessionId) {
-        return api(`/messages/session/${sessionId}/model-messages`, { skipParseDates: true });
-      },
-      async getRecentBySession(sessionId, limit = 50) {
-        const messages = await api(`/messages/session/${sessionId}`);
-        return messages.slice(-limit);
-      },
-      async countBySession(sessionId) {
-        const result = await api(`/messages/session/${sessionId}/count`);
-        return result.count;
-      },
-      async deleteBySession(sessionId) {
-        const result = await api(`/messages/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      },
-      async deleteFromSequence(sessionId, fromSequence) {
-        const result = await api(
-          `/messages/session/${sessionId}/from-sequence/${fromSequence}`,
-          { method: "DELETE" }
-        );
-        return result.deleted;
-      }
-    };
-    remoteToolExecutionQueries = {
-      create(data) {
-        return api("/tool-executions", { method: "POST", body: data });
-      },
-      getById(id) {
-        return api(`/tool-executions/${id}`).catch(() => void 0);
-      },
-      getByToolCallId(toolCallId) {
-        return api(`/tool-executions/by-tool-call-id/${toolCallId}`).catch(() => void 0);
-      },
-      getPendingApprovals(sessionId) {
-        return api(`/tool-executions/session/${sessionId}/pending`);
-      },
-      approve(id) {
-        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "approved" } });
-      },
-      reject(id) {
-        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "rejected" } });
-      },
-      complete(id, output, error) {
-        return api(`/tool-executions/${id}`, {
-          method: "PATCH",
-          body: { status: error ? "error" : "completed", output, error }
-        });
-      },
-      getBySession(sessionId) {
-        return api(`/tool-executions/session/${sessionId}`);
-      },
-      async deleteAfterTime(sessionId, afterTime) {
-        const timestamp = afterTime instanceof Date ? afterTime.getTime() : new Date(afterTime).getTime();
-        const result = await api(
-          `/tool-executions/session/${sessionId}/after/${timestamp}`,
-          { method: "DELETE" }
-        );
-        return result.deleted;
-      }
-    };
-    remoteTodoQueries = {
-      create(data) {
-        return api("/todos", { method: "POST", body: data });
-      },
-      createMany(sessionId, items) {
-        return api("/todos/batch", { method: "POST", body: { sessionId, items } });
-      },
-      getBySession(sessionId) {
-        return api(`/todos/session/${sessionId}`);
-      },
-      updateStatus(id, status) {
-        return api(`/todos/${id}`, { method: "PATCH", body: { status } });
-      },
-      async delete(id) {
-        const result = await api(`/todos/${id}`, { method: "DELETE" });
-        return result?.success ?? false;
-      },
-      async clearSession(sessionId) {
-        const result = await api(`/todos/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      }
-    };
-    remoteSkillQueries = {
-      load(sessionId, skillName) {
-        return api("/skills", { method: "POST", body: { sessionId, skillName } });
-      },
-      getBySession(sessionId) {
-        return api(`/skills/session/${sessionId}`);
-      },
-      async isLoaded(sessionId, skillName) {
-        const result = await api(`/skills/session/${sessionId}/is-loaded/${skillName}`);
-        return result.isLoaded;
-      }
-    };
-    remoteActiveStreamQueries = {
-      create(sessionId, streamId) {
-        return api("/streams", { method: "POST", body: { sessionId, streamId } });
-      },
-      getBySessionId(sessionId) {
-        return api(`/streams/session/${sessionId}`).then((r) => r ?? void 0);
-      },
-      getByStreamId(streamId) {
-        return api(`/streams/by-stream-id/${streamId}`).catch(() => void 0);
-      },
-      finish(streamId) {
-        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "finished" } });
-      },
-      markError(streamId) {
-        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "error" } });
-      },
-      async deleteBySession(sessionId) {
-        const result = await api(`/streams/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      }
-    };
-    remoteCheckpointQueries = {
-      create(data) {
-        return api("/checkpoints", { method: "POST", body: data });
-      },
-      getById(id) {
-        return api(`/checkpoints/${id}`).catch(() => void 0);
-      },
-      getBySession(sessionId) {
-        return api(`/checkpoints/session/${sessionId}`);
-      },
-      getByMessageSequence(sessionId, messageSequence) {
-        return api(`/checkpoints/session/${sessionId}/by-sequence/${messageSequence}`).then((r) => r ?? void 0);
-      },
-      getLatest(sessionId) {
-        return api(`/checkpoints/session/${sessionId}/latest`).then((r) => r ?? void 0);
-      },
-      async deleteAfterSequence(sessionId, messageSequence) {
-        const result = await api(
-          `/checkpoints/session/${sessionId}/after-sequence/${messageSequence}`,
-          { method: "DELETE" }
-        );
-        return result.deleted;
-      },
-      async deleteBySession(sessionId) {
-        const result = await api(`/checkpoints/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      }
-    };
-    remoteFileBackupQueries = {
-      create(data) {
-        return api("/file-backups", { method: "POST", body: data });
-      },
-      getByCheckpoint(checkpointId) {
-        return api(`/file-backups/checkpoint/${checkpointId}`);
-      },
-      getBySession(sessionId) {
-        return api(`/file-backups/session/${sessionId}`);
-      },
-      getFromSequence(sessionId, messageSequence) {
-        return api(`/file-backups/session/${sessionId}/from-sequence/${messageSequence}`);
-      },
-      async hasBackup(checkpointId, filePath) {
-        const result = await api(
-          `/file-backups/checkpoint/${checkpointId}/has-backup/${encodeURIComponent(filePath)}`
-        );
-        return result.hasBackup;
-      },
-      async deleteBySession(sessionId) {
-        const result = await api(`/file-backups/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      }
-    };
-    remoteSubagentQueries = {
-      create(data) {
-        return api("/subagents", { method: "POST", body: data });
-      },
-      getById(id) {
-        return api(`/subagents/${id}`).catch(() => void 0);
-      },
-      getByToolCallId(toolCallId) {
-        return api(`/subagents/by-tool-call-id/${toolCallId}`).catch(() => void 0);
-      },
-      getBySession(sessionId) {
-        return api(`/subagents/session/${sessionId}`);
-      },
-      addStep(id, step) {
-        return api(`/subagents/${id}/add-step`, { method: "POST", body: { step } }).catch(() => void 0);
-      },
-      complete(id, result) {
-        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "completed", result } }).catch(() => void 0);
-      },
-      markError(id, error) {
-        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "error", error } }).catch(() => void 0);
-      },
-      cancel(id) {
-        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "cancelled" } }).catch(() => void 0);
-      },
-      async deleteBySession(sessionId) {
-        const result = await api(`/subagents/session/${sessionId}`, { method: "DELETE" });
-        return result.deleted;
-      }
-    };
-    remoteIndexStatusQueries = {
-      upsert(_db, data) {
-        return api("/index-status", {
-          method: "POST",
-          body: {
-            ...data,
-            lastFullIndex: data.lastFullIndex?.toISOString(),
-            lastIncrementalIndex: data.lastIncrementalIndex?.toISOString()
-          }
-        });
-      },
-      get(_db, namespace) {
-        return api(`/index-status/namespace/${namespace}`).then((r) => r ?? void 0);
-      },
-      async delete(_db, namespace) {
-        const result = await api(`/index-status/namespace/${namespace}`, { method: "DELETE" });
-        return result?.success ?? false;
-      },
-      list(_db) {
-        return api("/index-status");
-      }
-    };
-  }
-});
-
-// src/db/index.ts
-function initDatabase(config) {
-  initRemoteDatabase(config.url, config.authKey);
-  initialized = true;
-}
-function getDb() {
-  if (!initialized) {
-    throw new Error("Database not initialized. Call initDatabase first.");
-  }
-  return {};
-}
-function closeDatabase() {
-  closeRemoteDatabase();
-  initialized = false;
-}
-var initialized, sessionQueries, messageQueries, toolExecutionQueries, todoQueries, skillQueries, activeStreamQueries, checkpointQueries, fileBackupQueries, subagentQueries, indexStatusQueries;
-var init_db = __esm({
-  "src/db/index.ts"() {
-    "use strict";
-    init_remote();
-    initialized = false;
-    sessionQueries = remoteSessionQueries;
-    messageQueries = remoteMessageQueries;
-    toolExecutionQueries = remoteToolExecutionQueries;
-    todoQueries = remoteTodoQueries;
-    skillQueries = remoteSkillQueries;
-    activeStreamQueries = remoteActiveStreamQueries;
-    checkpointQueries = remoteCheckpointQueries;
-    fileBackupQueries = remoteFileBackupQueries;
-    subagentQueries = remoteSubagentQueries;
-    indexStatusQueries = remoteIndexStatusQueries;
-  }
-});
-
-// src/config/types.ts
-import { z } from "zod";
-var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
-var init_types = __esm({
-  "src/config/types.ts"() {
-    "use strict";
-    ToolApprovalConfigSchema = z.object({
-      bash: z.boolean().optional().default(true),
-      write_file: z.boolean().optional().default(false),
-      read_file: z.boolean().optional().default(false),
-      load_skill: z.boolean().optional().default(false),
-      todo: z.boolean().optional().default(false)
-    });
-    SkillMetadataSchema = z.object({
-      name: z.string(),
-      description: z.string(),
-      // Whether to always inject this skill into context (vs on-demand loading)
-      alwaysApply: z.boolean().optional().default(false),
-      // Glob patterns - auto-inject when working with matching files
-      globs: z.array(z.string()).optional().default([])
-    });
-    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)
-    });
-    VectorGatewayConfigSchema = z.object({
-      // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
-      redisUrl: z.string().optional(),
-      // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
-      httpUrl: z.string().optional(),
-      // Embedding model to use (default: text-embedding-3-small)
-      embeddingModel: z.string().default("gemini-embedding-001"),
-      // Custom namespace override (auto-generated from git remote if not set)
-      namespace: z.string().optional(),
-      // File patterns to include in indexing
-      include: z.array(z.string()).optional().default([
-        "**/*.ts",
-        "**/*.tsx",
-        "**/*.js",
-        "**/*.jsx",
-        "**/*.py",
-        "**/*.go",
-        "**/*.rs",
-        "**/*.java",
-        "**/*.md",
-        "**/*.mdx",
-        "**/*.txt"
-      ]),
-      // File patterns to exclude from indexing
-      exclude: z.array(z.string()).optional().default([
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.git/**",
-        "**/.next/**",
-        "**/*.min.js",
-        "**/*.bundle.js",
-        "**/pnpm-lock.yaml",
-        "**/package-lock.json",
-        "**/yarn.lock",
-        "**/.test-workspace/**",
-        "**/.semantic-test-workspace/**",
-        "**/.semantic-integration-test/**"
-      ])
-    }).optional();
-    RemoteServerConfigSchema = z.object({
-      // URL of the remote server (e.g., https://agent.sparkecode.com)
-      url: z.string().url().optional(),
-      // Auth key for the remote server (auto-generated on first use if not set)
-      // Can also be set via SPARKECODER_AUTH_KEY env var
-      authKey: z.string().optional()
-    }).optional();
-    SparkcoderConfigSchema = z.object({
-      // Default model to use (Vercel AI Gateway format)
-      defaultModel: z.string().default("anthropic/claude-opus-4-6"),
-      // Working directory for file operations
-      workingDirectory: z.string().optional(),
-      // Tool approval settings
-      toolApprovals: ToolApprovalConfigSchema.optional().default({}),
-      // Approval webhook URL (called when approval is needed)
-      approvalWebhook: z.string().url().optional(),
-      // Skills configuration
-      skills: z.object({
-        // Directory containing skill files
-        directory: z.string().optional().default("./skills"),
-        // Additional skill directories to include
-        additionalDirectories: z.array(z.string()).optional().default([])
-      }).optional().default({}),
-      // Context management
-      context: z.object({
-        // Maximum context size before summarization (in characters)
-        maxChars: z.number().optional().default(2e5),
-        // Enable automatic summarization
-        autoSummarize: z.boolean().optional().default(true),
-        // Number of recent messages to keep after summarization
-        keepRecentMessages: z.number().optional().default(10)
-      }).optional().default({}),
-      // Server configuration
-      server: z.object({
-        port: z.number().default(3141),
-        host: z.string().default("127.0.0.1"),
-        // Public URL for web UI to connect to API (for Docker/remote access)
-        // If not set, defaults to http://{host}:{port}
-        publicUrl: z.string().url().optional()
-      }).default({ port: 3141, host: "127.0.0.1" }),
-      // Database path (used for local SQLite - ignored if remoteServer is configured)
-      databasePath: z.string().optional().default("./sparkecoder.db"),
-      // Remote server configuration (for centralized storage)
-      // If configured, uses remote MongoDB instead of local SQLite
-      remoteServer: RemoteServerConfigSchema,
-      // Vector Gateway configuration for semantic search
-      vectorGateway: VectorGatewayConfigSchema
-    });
-  }
-});
-
-// src/config/index.ts
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { resolve, dirname, join } from "path";
-import { homedir, platform } from "os";
-function discoverSkillDirectories(workingDir) {
-  const alwaysLoadedDirs = [];
-  const onDemandDirs = [];
-  const allDirectories = [];
-  let agentsMdPath = null;
-  const sparkRulesDir = join(workingDir, ".sparkecoder", "rules");
-  if (existsSync(sparkRulesDir)) {
-    alwaysLoadedDirs.push({ path: sparkRulesDir, priority: 1 });
-    allDirectories.push(sparkRulesDir);
-  }
-  const sparkSkillsDir = join(workingDir, ".sparkecoder", "skills");
-  if (existsSync(sparkSkillsDir)) {
-    onDemandDirs.push({ path: sparkSkillsDir, priority: 2 });
-    allDirectories.push(sparkSkillsDir);
-  }
-  const cursorRulesDir = join(workingDir, ".cursor", "rules");
-  if (existsSync(cursorRulesDir)) {
-    onDemandDirs.push({ path: cursorRulesDir, priority: 3 });
-    allDirectories.push(cursorRulesDir);
-  }
-  const claudeSkillsDir = join(workingDir, ".claude", "skills");
-  if (existsSync(claudeSkillsDir)) {
-    onDemandDirs.push({ path: claudeSkillsDir, priority: 4 });
-    allDirectories.push(claudeSkillsDir);
-  }
-  const legacySkillsDir = join(workingDir, "skills");
-  if (existsSync(legacySkillsDir)) {
-    onDemandDirs.push({ path: legacySkillsDir, priority: 5 });
-    allDirectories.push(legacySkillsDir);
-  }
-  const agentsMd = join(workingDir, "AGENTS.md");
-  if (existsSync(agentsMd)) {
-    agentsMdPath = agentsMd;
-  }
-  const builtInSkillsDir = resolve(dirname(import.meta.url.replace("file://", "")), "../skills/default");
-  if (existsSync(builtInSkillsDir)) {
-    onDemandDirs.push({ path: builtInSkillsDir, priority: 100 });
-    allDirectories.push(builtInSkillsDir);
-  }
-  return {
-    alwaysLoadedDirs,
-    onDemandDirs,
-    agentsMdPath,
-    allDirectories
-  };
-}
-function getAppDataDirectory() {
-  const appName = "sparkecoder";
-  switch (platform()) {
-    case "darwin":
-      return join(homedir(), "Library", "Application Support", appName);
-    case "win32":
-      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
-    default:
-      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
-  }
-}
-function ensureAppDataDirectory() {
-  const dir = getAppDataDirectory();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function findConfigFile(startDir) {
-  let currentDir = startDir;
-  while (currentDir !== dirname(currentDir)) {
-    for (const fileName of CONFIG_FILE_NAMES) {
-      const configPath = resolve(currentDir, fileName);
-      if (existsSync(configPath)) {
-        return configPath;
-      }
-    }
-    currentDir = dirname(currentDir);
-  }
-  const appDataDir = getAppDataDirectory();
-  for (const fileName of CONFIG_FILE_NAMES) {
-    const configPath = join(appDataDir, fileName);
-    if (existsSync(configPath)) {
-      return configPath;
-    }
-  }
-  return null;
-}
-function loadConfig(configPath, workingDirectory) {
-  const cwd = workingDirectory || process.cwd();
-  let rawConfig = {};
-  let configDir = cwd;
-  if (configPath) {
-    if (!existsSync(configPath)) {
-      throw new Error(`Config file not found: ${configPath}`);
-    }
-    const content = readFileSync(configPath, "utf-8");
-    rawConfig = JSON.parse(content);
-    configDir = dirname(resolve(configPath));
-  } else {
-    const foundPath = findConfigFile(cwd);
-    if (foundPath) {
-      const content = readFileSync(foundPath, "utf-8");
-      rawConfig = JSON.parse(content);
-      configDir = dirname(foundPath);
-    }
-  }
-  if (process.env.SPARKECODER_MODEL) {
-    rawConfig.defaultModel = process.env.SPARKECODER_MODEL;
+  if (process.env.SPARKECODER_MODEL) {
+    rawConfig.defaultModel = process.env.SPARKECODER_MODEL;
   }
   if (process.env.SPARKECODER_PORT) {
     rawConfig.server = {
@@ -691,6 +352,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];
   }
@@ -814,48 +478,405 @@ function getApiKeyStatus() {
       } else {
         source = "env";
       }
-      value = envValue;
-    } else if (storedValue) {
-      source = "storage";
-      value = storedValue;
-    }
-    return {
-      provider,
-      envVar,
-      configured: !!value,
-      source,
-      maskedKey: value ? maskApiKey(value) : null
+      value = envValue;
+    } else if (storedValue) {
+      source = "storage";
+      value = storedValue;
+    }
+    return {
+      provider,
+      envVar,
+      configured: !!value,
+      source,
+      maskedKey: value ? maskApiKey(value) : null
+    };
+  });
+}
+function maskApiKey(key) {
+  if (key.length <= 12) {
+    return "****" + key.slice(-4);
+  }
+  return key.slice(0, 4) + "..." + key.slice(-4);
+}
+var CONFIG_FILE_NAMES, cachedConfig, AUTH_KEY_FILE, API_KEYS_FILE, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_types();
+    init_types();
+    CONFIG_FILE_NAMES = [
+      "sparkecoder.config.json",
+      "sparkecoder.json",
+      ".sparkecoder.json"
+    ];
+    cachedConfig = null;
+    AUTH_KEY_FILE = "auth-key.json";
+    API_KEYS_FILE = "api-keys.json";
+    PROVIDER_ENV_MAP = {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY",
+      xai: "XAI_API_KEY",
+      "ai-gateway": "AI_GATEWAY_API_KEY"
+    };
+    SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
+  }
+});
+
+// src/db/remote.ts
+function initRemoteDatabase(serverUrl, key) {
+  remoteServerUrl = serverUrl.replace(/\/$/, "");
+  authKey = key;
+}
+function closeRemoteDatabase() {
+  remoteServerUrl = null;
+  authKey = null;
+}
+function parseDates(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(parseDates);
+  if (typeof obj !== "object" || obj instanceof Date) return obj;
+  const result = { ...obj };
+  for (const key of Object.keys(result)) {
+    if (MODEL_MESSAGE_FIELDS.includes(key)) {
+      continue;
+    }
+    if (DATE_FIELDS.includes(key) && typeof result[key] === "string") {
+      result[key] = new Date(result[key]);
+    } else if (typeof result[key] === "object") {
+      result[key] = parseDates(result[key]);
+    }
+  }
+  return result;
+}
+async function api(path, options = {}) {
+  if (!remoteServerUrl || !authKey) {
+    throw new Error("Remote database not initialized");
+  }
+  const url = `${remoteServerUrl}/db${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+  const text = await response.text();
+  if (!text || text === "null") {
+    return null;
+  }
+  const parsed = JSON.parse(text);
+  if (options.skipParseDates) {
+    return parsed;
+  }
+  return parseDates(parsed);
+}
+var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, remoteSessionQueries, remoteMessageQueries, remoteToolExecutionQueries, remoteTodoQueries, remoteSkillQueries, remoteActiveStreamQueries, remoteCheckpointQueries, remoteFileBackupQueries, remoteSubagentQueries, remoteIndexStatusQueries;
+var init_remote = __esm({
+  "src/db/remote.ts"() {
+    "use strict";
+    remoteServerUrl = null;
+    authKey = null;
+    DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
+    MODEL_MESSAGE_FIELDS = ["modelMessage", "modelMessages"];
+    remoteSessionQueries = {
+      create(data) {
+        return api("/sessions", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/sessions/${id}`).catch(() => void 0);
+      },
+      list(limit = 50, offset = 0) {
+        return api(`/sessions?limit=${limit}&offset=${offset}`);
+      },
+      updateStatus(id, status) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: { status } });
+      },
+      updateModel(id, model) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: { model } });
+      },
+      update(id, updates) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: updates });
+      },
+      delete(id) {
+        return api(`/sessions/${id}`, { method: "DELETE" }).then((r) => r?.success ?? false);
+      }
+    };
+    remoteMessageQueries = {
+      async getNextSequence(sessionId) {
+        const result = await api(`/messages/session/${sessionId}/next-sequence`);
+        return result.nextSequence;
+      },
+      create(sessionId, modelMessage) {
+        return api("/messages", { method: "POST", body: { sessionId, modelMessage } });
+      },
+      addMany(sessionId, modelMessages) {
+        return api("/messages/batch", { method: "POST", body: { sessionId, modelMessages } });
+      },
+      getBySession(sessionId) {
+        return api(`/messages/session/${sessionId}`);
+      },
+      getModelMessages(sessionId) {
+        return api(`/messages/session/${sessionId}/model-messages`, { skipParseDates: true });
+      },
+      async getRecentBySession(sessionId, limit = 50) {
+        const messages = await api(`/messages/session/${sessionId}`);
+        return messages.slice(-limit);
+      },
+      async countBySession(sessionId) {
+        const result = await api(`/messages/session/${sessionId}/count`);
+        return result.count;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/messages/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      },
+      async deleteFromSequence(sessionId, fromSequence) {
+        const result = await api(
+          `/messages/session/${sessionId}/from-sequence/${fromSequence}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      }
     };
-  });
+    remoteToolExecutionQueries = {
+      create(data) {
+        return api("/tool-executions", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/tool-executions/${id}`).catch(() => void 0);
+      },
+      getByToolCallId(toolCallId) {
+        return api(`/tool-executions/by-tool-call-id/${toolCallId}`).catch(() => void 0);
+      },
+      getPendingApprovals(sessionId) {
+        return api(`/tool-executions/session/${sessionId}/pending`);
+      },
+      approve(id) {
+        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "approved" } });
+      },
+      reject(id) {
+        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "rejected" } });
+      },
+      complete(id, output, error) {
+        return api(`/tool-executions/${id}`, {
+          method: "PATCH",
+          body: { status: error ? "error" : "completed", output, error }
+        });
+      },
+      getBySession(sessionId) {
+        return api(`/tool-executions/session/${sessionId}`);
+      },
+      async deleteAfterTime(sessionId, afterTime) {
+        const timestamp = afterTime instanceof Date ? afterTime.getTime() : new Date(afterTime).getTime();
+        const result = await api(
+          `/tool-executions/session/${sessionId}/after/${timestamp}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      }
+    };
+    remoteTodoQueries = {
+      create(data) {
+        return api("/todos", { method: "POST", body: data });
+      },
+      createMany(sessionId, items) {
+        return api("/todos/batch", { method: "POST", body: { sessionId, items } });
+      },
+      getBySession(sessionId) {
+        return api(`/todos/session/${sessionId}`);
+      },
+      updateStatus(id, status) {
+        return api(`/todos/${id}`, { method: "PATCH", body: { status } });
+      },
+      async delete(id) {
+        const result = await api(`/todos/${id}`, { method: "DELETE" });
+        return result?.success ?? false;
+      },
+      async clearSession(sessionId) {
+        const result = await api(`/todos/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteSkillQueries = {
+      load(sessionId, skillName) {
+        return api("/skills", { method: "POST", body: { sessionId, skillName } });
+      },
+      getBySession(sessionId) {
+        return api(`/skills/session/${sessionId}`);
+      },
+      async isLoaded(sessionId, skillName) {
+        const result = await api(`/skills/session/${sessionId}/is-loaded/${skillName}`);
+        return result.isLoaded;
+      }
+    };
+    remoteActiveStreamQueries = {
+      create(sessionId, streamId) {
+        return api("/streams", { method: "POST", body: { sessionId, streamId } });
+      },
+      getBySessionId(sessionId) {
+        return api(`/streams/session/${sessionId}`).then((r) => r ?? void 0);
+      },
+      getByStreamId(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`).catch(() => void 0);
+      },
+      finish(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "finished" } });
+      },
+      markError(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "error" } });
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/streams/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteCheckpointQueries = {
+      create(data) {
+        return api("/checkpoints", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/checkpoints/${id}`).catch(() => void 0);
+      },
+      getBySession(sessionId) {
+        return api(`/checkpoints/session/${sessionId}`);
+      },
+      getByMessageSequence(sessionId, messageSequence) {
+        return api(`/checkpoints/session/${sessionId}/by-sequence/${messageSequence}`).then((r) => r ?? void 0);
+      },
+      getLatest(sessionId) {
+        return api(`/checkpoints/session/${sessionId}/latest`).then((r) => r ?? void 0);
+      },
+      async deleteAfterSequence(sessionId, messageSequence) {
+        const result = await api(
+          `/checkpoints/session/${sessionId}/after-sequence/${messageSequence}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/checkpoints/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteFileBackupQueries = {
+      create(data) {
+        return api("/file-backups", { method: "POST", body: data });
+      },
+      getByCheckpoint(checkpointId) {
+        return api(`/file-backups/checkpoint/${checkpointId}`);
+      },
+      getBySession(sessionId) {
+        return api(`/file-backups/session/${sessionId}`);
+      },
+      getFromSequence(sessionId, messageSequence) {
+        return api(`/file-backups/session/${sessionId}/from-sequence/${messageSequence}`);
+      },
+      async hasBackup(checkpointId, filePath) {
+        const result = await api(
+          `/file-backups/checkpoint/${checkpointId}/has-backup/${encodeURIComponent(filePath)}`
+        );
+        return result.hasBackup;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/file-backups/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteSubagentQueries = {
+      create(data) {
+        return api("/subagents", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/subagents/${id}`).catch(() => void 0);
+      },
+      getByToolCallId(toolCallId) {
+        return api(`/subagents/by-tool-call-id/${toolCallId}`).catch(() => void 0);
+      },
+      getBySession(sessionId) {
+        return api(`/subagents/session/${sessionId}`);
+      },
+      addStep(id, step) {
+        return api(`/subagents/${id}/add-step`, { method: "POST", body: { step } }).catch(() => void 0);
+      },
+      complete(id, result) {
+        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "completed", result } }).catch(() => void 0);
+      },
+      markError(id, error) {
+        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "error", error } }).catch(() => void 0);
+      },
+      cancel(id) {
+        return api(`/subagents/${id}`, { method: "PATCH", body: { status: "cancelled" } }).catch(() => void 0);
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/subagents/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteIndexStatusQueries = {
+      upsert(_db, data) {
+        return api("/index-status", {
+          method: "POST",
+          body: {
+            ...data,
+            lastFullIndex: data.lastFullIndex?.toISOString(),
+            lastIncrementalIndex: data.lastIncrementalIndex?.toISOString()
+          }
+        });
+      },
+      get(_db, namespace) {
+        return api(`/index-status/namespace/${namespace}`).then((r) => r ?? void 0);
+      },
+      async delete(_db, namespace) {
+        const result = await api(`/index-status/namespace/${namespace}`, { method: "DELETE" });
+        return result?.success ?? false;
+      },
+      list(_db) {
+        return api("/index-status");
+      }
+    };
+  }
+});
+
+// src/db/index.ts
+function initDatabase(config) {
+  initRemoteDatabase(config.url, config.authKey);
+  initialized = true;
 }
-function maskApiKey(key) {
-  if (key.length <= 12) {
-    return "****" + key.slice(-4);
+function getDb() {
+  if (!initialized) {
+    throw new Error("Database not initialized. Call initDatabase first.");
   }
-  return key.slice(0, 4) + "..." + key.slice(-4);
+  return {};
 }
-var CONFIG_FILE_NAMES, cachedConfig, AUTH_KEY_FILE, API_KEYS_FILE, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
-var init_config = __esm({
-  "src/config/index.ts"() {
-    "use strict";
-    init_types();
-    init_types();
-    CONFIG_FILE_NAMES = [
-      "sparkecoder.config.json",
-      "sparkecoder.json",
-      ".sparkecoder.json"
-    ];
-    cachedConfig = null;
-    AUTH_KEY_FILE = "auth-key.json";
-    API_KEYS_FILE = "api-keys.json";
-    PROVIDER_ENV_MAP = {
-      anthropic: "ANTHROPIC_API_KEY",
-      openai: "OPENAI_API_KEY",
-      google: "GOOGLE_GENERATIVE_AI_API_KEY",
-      xai: "XAI_API_KEY",
-      "ai-gateway": "AI_GATEWAY_API_KEY"
-    };
-    SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
+function closeDatabase() {
+  closeRemoteDatabase();
+  initialized = false;
+}
+var initialized, sessionQueries, messageQueries, toolExecutionQueries, todoQueries, skillQueries, activeStreamQueries, checkpointQueries, fileBackupQueries, subagentQueries, indexStatusQueries;
+var init_db = __esm({
+  "src/db/index.ts"() {
+    "use strict";
+    init_remote();
+    initialized = false;
+    sessionQueries = remoteSessionQueries;
+    messageQueries = remoteMessageQueries;
+    toolExecutionQueries = remoteToolExecutionQueries;
+    todoQueries = remoteTodoQueries;
+    skillQueries = remoteSkillQueries;
+    activeStreamQueries = remoteActiveStreamQueries;
+    checkpointQueries = remoteCheckpointQueries;
+    fileBackupQueries = remoteFileBackupQueries;
+    subagentQueries = remoteSubagentQueries;
+    indexStatusQueries = remoteIndexStatusQueries;
   }
 });
 
@@ -874,7 +895,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) {
@@ -945,7 +966,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 {
@@ -1250,7 +1271,7 @@ 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";
 var init_chunker = __esm({
   "src/semantic/chunker.ts"() {
     "use strict";
@@ -1600,18 +1621,176 @@ var init_semantic_search = __esm({
 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 = {
@@ -1623,7 +1802,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
@@ -2221,26 +2400,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.",
@@ -2250,22 +2444,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
           };
         }
@@ -2281,9 +2496,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;
@@ -2310,6 +2523,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 };
     }
   });
 }
@@ -2510,7 +2736,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";
@@ -2633,9 +2859,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",
@@ -3023,7 +3249,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;
@@ -3116,7 +3342,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;
 }
 
@@ -3543,7 +3769,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({
@@ -3566,7 +3792,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);
           }
@@ -4903,6 +5129,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) {
@@ -4954,6 +5233,10 @@ async function createTools(options) {
     } catch {
     }
   }
+  if (options.taskTools) {
+    tools.complete_task = createCompleteTaskTool(options.taskTools);
+    tools.task_failed = createTaskFailedTool(options.taskTools);
+  }
   return tools;
 }
 
@@ -5271,6 +5554,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
@@ -5532,6 +5839,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 {
@@ -5751,6 +6077,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
    */
@@ -5764,9 +6229,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({
@@ -5877,7 +6342,7 @@ ${prompt}` });
 
 // 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";
@@ -5891,10 +6356,10 @@ 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";
 init_config();
 
@@ -5927,18 +6392,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(
   "/",
@@ -6077,10 +6542,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",
@@ -6150,8 +6615,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",
@@ -6182,13 +6647,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",
@@ -6410,7 +6875,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();
@@ -6436,7 +6901,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;
@@ -6479,10 +6944,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([
@@ -6566,7 +7031,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;
       }
@@ -6660,7 +7125,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();
@@ -6825,30 +7290,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) {
@@ -7278,7 +7743,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 ?? ""
     }
   });
 });
@@ -7636,7 +8101,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";
@@ -7746,9 +8211,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",
@@ -7787,13 +8252,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",
@@ -7874,8 +8339,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",
@@ -7899,8 +8364,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",
@@ -7914,8 +8379,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",
@@ -8096,6 +8561,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();
@@ -8432,7 +9022,7 @@ function stopWebUI() {
   }
 }
 async function createApp(options = {}) {
-  const app = new Hono5();
+  const app = new Hono6();
   app.use("*", cors({
     origin: "*",
     // Allow all origins
@@ -8450,6 +9040,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());
   });