sparkecoder 0.1.21 → 0.1.23

package/dist/server/index.js

@@ -1,25 +1,419 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/config/types.ts
+import { z } from "zod";
+var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, 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)
+    });
+    SparkcoderConfigSchema = z.object({
+      // Default model to use (Vercel AI Gateway format)
+      defaultModel: z.string().default("anthropic/claude-opus-4-5"),
+      // 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
+      databasePath: z.string().optional().default("./sparkecoder.db")
+    });
+  }
+});
+
+// src/skills/index.ts
+var skills_exports = {};
+__export(skills_exports, {
+  formatAgentsMdContent: () => formatAgentsMdContent,
+  formatAlwaysLoadedSkills: () => formatAlwaysLoadedSkills,
+  formatGlobMatchedSkills: () => formatGlobMatchedSkills,
+  formatSkillsForContext: () => formatSkillsForContext,
+  getGlobMatchedSkills: () => getGlobMatchedSkills,
+  loadAgentsMd: () => loadAgentsMd,
+  loadAllSkills: () => loadAllSkills,
+  loadAllSkillsFromDiscovered: () => loadAllSkillsFromDiscovered,
+  loadSkillContent: () => loadSkillContent,
+  loadSkillsFromDirectory: () => loadSkillsFromDirectory
+});
+import { readFile as readFile6, readdir } from "fs/promises";
+import { resolve as resolve6, basename, extname as extname3, relative as relative4 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { minimatch } from "minimatch";
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  try {
+    const lines = frontmatter.split("\n");
+    const data = {};
+    let currentArray = null;
+    let currentArrayKey = null;
+    for (const line of lines) {
+      if (currentArrayKey && line.trim().startsWith("-")) {
+        let value = line.trim().slice(1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        currentArray?.push(value);
+        continue;
+      }
+      if (currentArrayKey && currentArray) {
+        data[currentArrayKey] = currentArray;
+        currentArray = null;
+        currentArrayKey = null;
+      }
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value === "" || value === "[]") {
+          currentArrayKey = key;
+          currentArray = [];
+          continue;
+        }
+        if (value.startsWith("[") && value.endsWith("]")) {
+          const arrayContent = value.slice(1, -1);
+          const items = arrayContent.split(",").map((item) => {
+            let trimmed = item.trim();
+            if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+              trimmed = trimmed.slice(1, -1);
+            }
+            return trimmed;
+          }).filter((item) => item.length > 0);
+          data[key] = items;
+          continue;
+        }
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        if (value === "true") {
+          data[key] = true;
+        } else if (value === "false") {
+          data[key] = false;
+        } else {
+          data[key] = value;
+        }
+      }
+    }
+    if (currentArrayKey && currentArray) {
+      data[currentArrayKey] = currentArray;
+    }
+    const metadata = SkillMetadataSchema.parse(data);
+    return { metadata, body: body.trim() };
+  } catch {
+    return null;
+  }
+}
+function getSkillNameFromPath(filePath) {
+  return basename(filePath, extname3(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function loadSkillsFromDirectory(directory, options = {}) {
+  const {
+    priority = 50,
+    defaultLoadType = "on_demand",
+    forceAlwaysApply = false
+  } = options;
+  if (!existsSync8(directory)) {
+    return [];
+  }
+  const skills = [];
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    let filePath;
+    let fileName;
+    if (entry.isDirectory()) {
+      const skillMdPath = resolve6(directory, entry.name, "SKILL.md");
+      if (existsSync8(skillMdPath)) {
+        filePath = skillMdPath;
+        fileName = entry.name;
+      } else {
+        continue;
+      }
+    } else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdc")) {
+      filePath = resolve6(directory, entry.name);
+      fileName = entry.name;
+    } else {
+      continue;
+    }
+    const content = await readFile6(filePath, "utf-8");
+    const parsed = parseSkillFrontmatter(content);
+    if (parsed) {
+      const alwaysApply = forceAlwaysApply || parsed.metadata.alwaysApply;
+      const loadType = alwaysApply ? "always" : defaultLoadType;
+      skills.push({
+        name: parsed.metadata.name,
+        description: parsed.metadata.description,
+        filePath,
+        alwaysApply,
+        globs: parsed.metadata.globs,
+        loadType,
+        priority,
+        sourceDir: directory
+      });
+    } else {
+      const name = getSkillNameFromPath(filePath);
+      const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
+      skills.push({
+        name,
+        description: firstParagraph.replace(/^#\s*/, "").trim(),
+        filePath,
+        alwaysApply: forceAlwaysApply,
+        globs: [],
+        loadType: forceAlwaysApply ? "always" : defaultLoadType,
+        priority,
+        sourceDir: directory
+      });
+    }
+  }
+  return skills;
+}
+async function loadAllSkills(directories) {
+  const allSkills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const dir of directories) {
+    const skills = await loadSkillsFromDirectory(dir);
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  return allSkills;
+}
+async function loadAllSkillsFromDiscovered(discovered) {
+  const allSkills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const { path, priority } of discovered.alwaysLoadedDirs) {
+    const skills = await loadSkillsFromDirectory(path, {
+      priority,
+      defaultLoadType: "always",
+      forceAlwaysApply: true
+    });
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  for (const { path, priority } of discovered.onDemandDirs) {
+    const skills = await loadSkillsFromDirectory(path, {
+      priority,
+      defaultLoadType: "on_demand",
+      forceAlwaysApply: false
+    });
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  const alwaysSkills = allSkills.filter((s) => s.alwaysApply || s.loadType === "always");
+  const onDemandSkills = allSkills.filter((s) => !s.alwaysApply && s.loadType !== "always");
+  const alwaysWithContent = await Promise.all(
+    alwaysSkills.map(async (skill) => {
+      const content = await readFile6(skill.filePath, "utf-8");
+      const parsed = parseSkillFrontmatter(content);
+      return {
+        ...skill,
+        content: parsed ? parsed.body : content
+      };
+    })
+  );
+  return {
+    always: alwaysWithContent,
+    onDemand: onDemandSkills,
+    all: allSkills
+  };
+}
+async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
+  if (activeFiles.length === 0) {
+    return [];
+  }
+  const relativeFiles = activeFiles.map((f) => {
+    if (f.startsWith(workingDirectory)) {
+      return relative4(workingDirectory, f);
+    }
+    return f;
+  });
+  const matchedSkills = skills.filter((skill) => {
+    if (skill.alwaysApply || skill.loadType === "always") {
+      return false;
+    }
+    if (!skill.globs || skill.globs.length === 0) {
+      return false;
+    }
+    return relativeFiles.some(
+      (file) => skill.globs.some((pattern) => minimatch(file, pattern, { matchBase: true }))
+    );
+  });
+  const matchedWithContent = await Promise.all(
+    matchedSkills.map(async (skill) => {
+      const content = await readFile6(skill.filePath, "utf-8");
+      const parsed = parseSkillFrontmatter(content);
+      return {
+        ...skill,
+        content: parsed ? parsed.body : content,
+        loadType: "glob_matched"
+      };
+    })
+  );
+  return matchedWithContent;
+}
+async function loadAgentsMd(agentsMdPath) {
+  if (!agentsMdPath || !existsSync8(agentsMdPath)) {
+    return null;
+  }
+  const content = await readFile6(agentsMdPath, "utf-8");
+  return content;
+}
+async function loadSkillContent(skillName, directories) {
+  const allSkills = await loadAllSkills(directories);
+  const skill = allSkills.find(
+    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  );
+  if (!skill) {
+    return null;
+  }
+  const content = await readFile6(skill.filePath, "utf-8");
+  const parsed = parseSkillFrontmatter(content);
+  return {
+    ...skill,
+    content: parsed ? parsed.body : content
+  };
+}
+function formatSkillsForContext(skills) {
+  const onDemandSkills = skills.filter((s) => !s.alwaysApply && s.loadType !== "always");
+  if (onDemandSkills.length === 0) {
+    return "No on-demand skills available.";
+  }
+  const lines = ["Available skills (use load_skill tool to load into context):"];
+  for (const skill of onDemandSkills) {
+    const globInfo = skill.globs?.length ? ` [auto-loads for: ${skill.globs.join(", ")}]` : "";
+    lines.push(`- ${skill.name}: ${skill.description}${globInfo}`);
+  }
+  return lines.join("\n");
+}
+function formatAlwaysLoadedSkills(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const sections = [];
+  for (const skill of skills) {
+    sections.push(`### ${skill.name}
+
+${skill.content}`);
+  }
+  return `## Active Rules & Skills (Always Loaded)
+
+${sections.join("\n\n---\n\n")}`;
+}
+function formatGlobMatchedSkills(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const sections = [];
+  for (const skill of skills) {
+    sections.push(`### ${skill.name}
+
+${skill.content}`);
+  }
+  return `## Context-Relevant Skills (Auto-loaded based on active files)
+
+${sections.join("\n\n---\n\n")}`;
+}
+function formatAgentsMdContent(content) {
+  if (!content) {
+    return "";
+  }
+  return `## Project Instructions (AGENTS.md)
+
+${content}`;
+}
+var init_skills = __esm({
+  "src/skills/index.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
 // src/server/index.ts
 import "dotenv/config";
 import { Hono as Hono5 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve8, dirname as dirname6, join as join3 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve9, dirname as dirname7, join as join7 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/server/routes/sessions.ts
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync, unlinkSync } from "fs";
+import { readdir as readdir4 } from "fs/promises";
+import { join as join4, basename as basename2, extname as extname6, relative as relative7 } from "path";
+import { nanoid as nanoid5 } from "nanoid";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -36,6 +430,7 @@ __export(schema_exports, {
   loadedSkills: () => loadedSkills,
   messages: () => messages,
   sessions: () => sessions,
+  subagentExecutions: () => subagentExecutions,
   terminals: () => terminals,
   todoItems: () => todoItems,
   toolExecutions: () => toolExecutions
@@ -139,6 +534,26 @@ var fileBackups = sqliteTable("file_backups", {
   existed: integer("existed", { mode: "boolean" }).notNull().default(true),
   createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
 });
+var subagentExecutions = sqliteTable("subagent_executions", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  toolCallId: text("tool_call_id").notNull(),
+  // The tool call that spawned this subagent
+  subagentType: text("subagent_type").notNull(),
+  // e.g., 'search', 'analyze', etc.
+  task: text("task").notNull(),
+  // The task/query given to the subagent
+  model: text("model").notNull(),
+  // The model used (e.g., 'gemini-2.0-flash')
+  status: text("status", { enum: ["running", "completed", "error", "cancelled"] }).notNull().default("running"),
+  // Steps taken by the subagent (stored as JSON array)
+  steps: text("steps", { mode: "json" }).$type().default([]),
+  // Final result/output
+  result: text("result", { mode: "json" }),
+  error: text("error"),
+  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  completedAt: integer("completed_at", { mode: "timestamp" })
+});
 
 // src/db/index.ts
 var db = null;
@@ -243,6 +658,22 @@ function initDatabase(dbPath) {
       created_at INTEGER NOT NULL
     );
 
+    -- Subagent executions table - tracks subagent runs
+    CREATE TABLE IF NOT EXISTS subagent_executions (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      tool_call_id TEXT NOT NULL,
+      subagent_type TEXT NOT NULL,
+      task TEXT NOT NULL,
+      model TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      steps TEXT DEFAULT '[]',
+      result TEXT,
+      error TEXT,
+      started_at INTEGER NOT NULL,
+      completed_at INTEGER
+    );
+
     CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
     CREATE INDEX IF NOT EXISTS idx_tool_executions_session ON tool_executions(session_id);
     CREATE INDEX IF NOT EXISTS idx_todo_items_session ON todo_items(session_id);
@@ -252,6 +683,8 @@ function initDatabase(dbPath) {
     CREATE INDEX IF NOT EXISTS idx_checkpoints_session ON checkpoints(session_id);
     CREATE INDEX IF NOT EXISTS idx_file_backups_checkpoint ON file_backups(checkpoint_id);
     CREATE INDEX IF NOT EXISTS idx_file_backups_session ON file_backups(session_id);
+    CREATE INDEX IF NOT EXISTS idx_subagent_executions_session ON subagent_executions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_subagent_executions_tool_call ON subagent_executions(tool_call_id);
   `);
   return db;
 }
@@ -645,85 +1078,149 @@ var fileBackupQueries = {
     return result.changes;
   }
 };
+var subagentQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(subagentExecutions).values({
+      id,
+      sessionId: data.sessionId,
+      toolCallId: data.toolCallId,
+      subagentType: data.subagentType,
+      task: data.task,
+      model: data.model,
+      status: "running",
+      steps: [],
+      startedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.id, id)).get();
+  },
+  getByToolCallId(toolCallId) {
+    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.toolCallId, toolCallId)).get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).orderBy(desc(subagentExecutions.startedAt)).all();
+  },
+  addStep(id, step) {
+    const existing = this.getById(id);
+    if (!existing) return void 0;
+    const currentSteps = existing.steps || [];
+    const newSteps = [...currentSteps, step];
+    return getDb().update(subagentExecutions).set({ steps: newSteps }).where(eq(subagentExecutions.id, id)).returning().get();
+  },
+  complete(id, result) {
+    return getDb().update(subagentExecutions).set({
+      status: "completed",
+      result,
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(subagentExecutions.id, id)).returning().get();
+  },
+  markError(id, error) {
+    return getDb().update(subagentExecutions).set({
+      status: "error",
+      error,
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(subagentExecutions.id, id)).returning().get();
+  },
+  cancel(id) {
+    return getDb().update(subagentExecutions).set({
+      status: "cancelled",
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(subagentExecutions.id, id)).returning().get();
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(subagentExecutions).where(eq(subagentExecutions.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
 
 // src/agent/index.ts
 import {
-  streamText,
-  generateText as generateText2,
-  tool as tool7,
-  stepCountIs
+  streamText as streamText2,
+  generateText as generateText3,
+  tool as tool9,
+  stepCountIs as stepCountIs2
 } from "ai";
-import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { z as z8 } from "zod";
-import { nanoid as nanoid3 } from "nanoid";
+
+// src/agent/model.ts
+import { gateway } from "@ai-sdk/gateway";
+var ANTHROPIC_PREFIX = "anthropic/";
+function isAnthropicModel(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  return normalized.startsWith(ANTHROPIC_PREFIX) || normalized.startsWith("claude-");
+}
+function resolveModel(modelId) {
+  return gateway(modelId.trim());
+}
+var SUBAGENT_MODELS = {
+  search: "google/gemini-2.0-flash",
+  analyze: "google/gemini-2.0-flash",
+  default: "google/gemini-2.0-flash"
+};
+
+// src/agent/index.ts
+import { z as z10 } from "zod";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/config/index.ts
+init_types();
+init_types();
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { homedir, platform } from "os";
-
-// src/config/types.ts
-import { z } from "zod";
-var 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)
-});
-var SkillMetadataSchema = z.object({
-  name: z.string(),
-  description: z.string()
-});
-var 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)
-});
-var SparkcoderConfigSchema = z.object({
-  // Default model to use (Vercel AI Gateway format)
-  defaultModel: z.string().default("anthropic/claude-opus-4-5"),
-  // 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
-  databasePath: z.string().optional().default("./sparkecoder.db")
-});
-
-// src/config/index.ts
 var CONFIG_FILE_NAMES = [
   "sparkecoder.config.json",
   "sparkecoder.json",
   ".sparkecoder.json"
 ];
+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()) {
@@ -803,20 +1300,12 @@ function loadConfig(configPath, workingDirectory) {
   } else {
     resolvedWorkingDirectory = process.cwd();
   }
+  const discovered = discoverSkillDirectories(resolvedWorkingDirectory);
+  const additionalDirs = (config.skills?.additionalDirectories || []).map((dir) => resolve(configDir, dir)).filter((dir) => existsSync(dir));
   const resolvedSkillsDirectories = [
-    resolve(configDir, config.skills?.directory || "./skills"),
-    // Built-in skills
-    resolve(dirname(import.meta.url.replace("file://", "")), "../skills/default"),
-    ...(config.skills?.additionalDirectories || []).map(
-      (dir) => resolve(configDir, dir)
-    )
-  ].filter((dir) => {
-    try {
-      return existsSync(dir);
-    } catch {
-      return false;
-    }
-  });
+    ...discovered.allDirectories,
+    ...additionalDirs
+  ];
   let resolvedDatabasePath;
   if (config.databasePath && config.databasePath !== "./sparkecoder.db") {
     resolvedDatabasePath = resolve(configDir, config.databasePath);
@@ -833,7 +1322,8 @@ function loadConfig(configPath, workingDirectory) {
     },
     resolvedWorkingDirectory,
     resolvedSkillsDirectories,
-    resolvedDatabasePath
+    resolvedDatabasePath,
+    discoveredSkills: discovered
   };
   cachedConfig = resolved;
   return resolved;
@@ -1234,8 +1724,8 @@ async function listSessionTerminals(sessionId, workingDirectory) {
   const terminalsDir = join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals");
   const terminals3 = [];
   try {
-    const { readdir: readdir3 } = await import("fs/promises");
-    const entries = await readdir3(terminalsDir, { withFileTypes: true });
+    const { readdir: readdir5 } = await import("fs/promises");
+    const entries = await readdir5(terminalsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const meta = await getMeta(entry.name, workingDirectory, sessionId);
@@ -1839,12 +2329,12 @@ function findNearestRoot(startDir, markers) {
 }
 async function commandExists(cmd) {
   try {
-    const { exec: exec5 } = await import("child_process");
-    const { promisify: promisify5 } = await import("util");
-    const execAsync5 = promisify5(exec5);
+    const { exec: exec6 } = await import("child_process");
+    const { promisify: promisify6 } = await import("util");
+    const execAsync6 = promisify6(exec6);
     const isWindows = process.platform === "win32";
     const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
-    await execAsync5(checkCmd);
+    await execAsync6(checkCmd);
     return true;
   } catch {
     return false;
@@ -2134,7 +2624,7 @@ async function createClient(serverId, handle, root) {
     },
     async waitForDiagnostics(filePath, timeoutMs = 5e3) {
       const normalized = normalizePath(filePath);
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
@@ -2153,7 +2643,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup();
-          resolve9(diagnostics.get(normalized) || []);
+          resolve10(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -2311,6 +2801,7 @@ function isSupported(filePath) {
 }
 
 // src/tools/write-file.ts
+var MAX_PROGRESS_CHUNK_SIZE = 16 * 1024;
 var writeFileInputSchema = z4.object({
   path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
   mode: z4.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
@@ -2354,24 +2845,76 @@ Working directory: ${options.workingDirectory}`,
               error: 'Content is required for "full" mode'
             };
           }
+          const existed = existsSync7(absolutePath);
+          const action = existed ? "replaced" : "created";
+          console.log("[WRITE-FILE] onProgress callback exists:", !!options.onProgress);
+          console.log("[WRITE-FILE] Emitting started event for:", relativePath);
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "full",
+            status: "started",
+            action,
+            totalLength: content.length
+          });
+          if (content.length <= MAX_PROGRESS_CHUNK_SIZE) {
+            options.onProgress?.({
+              path: absolutePath,
+              relativePath,
+              mode: "full",
+              status: "content",
+              content,
+              action,
+              totalLength: content.length
+            });
+          } else {
+            const chunkCount = Math.ceil(content.length / MAX_PROGRESS_CHUNK_SIZE);
+            for (let i = 0; i < chunkCount; i += 1) {
+              const chunkStart = i * MAX_PROGRESS_CHUNK_SIZE;
+              const chunk = content.slice(chunkStart, chunkStart + MAX_PROGRESS_CHUNK_SIZE);
+              options.onProgress?.({
+                path: absolutePath,
+                relativePath,
+                mode: "full",
+                status: "content",
+                content: chunk,
+                action,
+                totalLength: content.length,
+                chunkIndex: i,
+                chunkCount,
+                chunkStart,
+                isChunked: true
+              });
+              if (chunkCount > 1) {
+                await new Promise((resolve10) => setTimeout(resolve10, 0));
+              }
+            }
+          }
           await backupFile(options.sessionId, options.workingDirectory, absolutePath);
           const dir = dirname5(absolutePath);
           if (!existsSync7(dir)) {
             await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync7(absolutePath);
           await writeFile3(absolutePath, content, "utf-8");
           let diagnosticsOutput = "";
           if (options.enableLSP !== false && isSupported(absolutePath)) {
             await touchFile(absolutePath, true);
             diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
           }
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "full",
+            status: "completed",
+            action,
+            totalLength: content.length
+          });
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative3(options.workingDirectory, absolutePath),
+            relativePath,
             mode: "full",
-            action: existed ? "replaced" : "created",
+            action,
             bytesWritten: Buffer.byteLength(content, "utf-8"),
             lineCount: content.split("\n").length,
             ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
@@ -2389,6 +2932,22 @@ Working directory: ${options.workingDirectory}`,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "started",
+            action: "edited"
+          });
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "content",
+            oldString: old_string,
+            newString: new_string,
+            action: "edited"
+          });
           await backupFile(options.sessionId, options.workingDirectory, absolutePath);
           const currentContent = await readFile5(absolutePath, "utf-8");
           if (!currentContent.includes(old_string)) {
@@ -2419,10 +2978,17 @@ Working directory: ${options.workingDirectory}`,
             await touchFile(absolutePath, true);
             diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
           }
+          options.onProgress?.({
+            path: absolutePath,
+            relativePath,
+            mode: "str_replace",
+            status: "completed",
+            action: "edited"
+          });
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative3(options.workingDirectory, absolutePath),
+            relativePath,
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
@@ -2570,112 +3136,9 @@ function formatTodoItem(item) {
 }
 
 // src/tools/load-skill.ts
+init_skills();
 import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
-
-// src/skills/index.ts
-import { readFile as readFile6, readdir } from "fs/promises";
-import { resolve as resolve6, basename, extname as extname3 } from "path";
-import { existsSync as existsSync8 } from "fs";
-function parseSkillFrontmatter(content) {
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!frontmatterMatch) {
-    return null;
-  }
-  const [, frontmatter, body] = frontmatterMatch;
-  try {
-    const lines = frontmatter.split("\n");
-    const data = {};
-    for (const line of lines) {
-      const colonIndex = line.indexOf(":");
-      if (colonIndex > 0) {
-        const key = line.slice(0, colonIndex).trim();
-        let value = line.slice(colonIndex + 1).trim();
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
-        }
-        data[key] = value;
-      }
-    }
-    const metadata = SkillMetadataSchema.parse(data);
-    return { metadata, body: body.trim() };
-  } catch {
-    return null;
-  }
-}
-function getSkillNameFromPath(filePath) {
-  return basename(filePath, extname3(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-async function loadSkillsFromDirectory(directory) {
-  if (!existsSync8(directory)) {
-    return [];
-  }
-  const skills = [];
-  const files = await readdir(directory);
-  for (const file of files) {
-    if (!file.endsWith(".md")) continue;
-    const filePath = resolve6(directory, file);
-    const content = await readFile6(filePath, "utf-8");
-    const parsed = parseSkillFrontmatter(content);
-    if (parsed) {
-      skills.push({
-        name: parsed.metadata.name,
-        description: parsed.metadata.description,
-        filePath
-      });
-    } else {
-      const name = getSkillNameFromPath(filePath);
-      const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
-      skills.push({
-        name,
-        description: firstParagraph.replace(/^#\s*/, "").trim(),
-        filePath
-      });
-    }
-  }
-  return skills;
-}
-async function loadAllSkills(directories) {
-  const allSkills = [];
-  const seenNames = /* @__PURE__ */ new Set();
-  for (const dir of directories) {
-    const skills = await loadSkillsFromDirectory(dir);
-    for (const skill of skills) {
-      if (!seenNames.has(skill.name.toLowerCase())) {
-        seenNames.add(skill.name.toLowerCase());
-        allSkills.push(skill);
-      }
-    }
-  }
-  return allSkills;
-}
-async function loadSkillContent(skillName, directories) {
-  const allSkills = await loadAllSkills(directories);
-  const skill = allSkills.find(
-    (s) => s.name.toLowerCase() === skillName.toLowerCase()
-  );
-  if (!skill) {
-    return null;
-  }
-  const content = await readFile6(skill.filePath, "utf-8");
-  const parsed = parseSkillFrontmatter(content);
-  return {
-    ...skill,
-    content: parsed ? parsed.body : content
-  };
-}
-function formatSkillsForContext(skills) {
-  if (skills.length === 0) {
-    return "No skills available.";
-  }
-  const lines = ["Available skills (use load_skill tool to load into context):"];
-  for (const skill of skills) {
-    lines.push(`- ${skill.name}: ${skill.description}`);
-  }
-  return lines.join("\n");
-}
-
-// src/tools/load-skill.ts
 var loadSkillInputSchema = z6.object({
   action: z6.enum(["list", "load"]).describe('Action to perform: "list" to see available skills, "load" to load a skill'),
   skillName: z6.string().optional().describe('For "load" action: The name of the skill to load')
@@ -2758,7 +3221,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 relative4, isAbsolute as isAbsolute3, extname as extname4 } from "path";
+import { resolve as resolve7, relative as relative5, isAbsolute as isAbsolute3, extname as extname4 } from "path";
 import { existsSync as existsSync9 } from "fs";
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 var linterInputSchema = z7.object({
@@ -2875,7 +3338,7 @@ function formatDiagnosticsResult(diagnosticsMap, workingDirectory) {
   let totalInfo = 0;
   const files = [];
   for (const [filePath, diagnostics] of Object.entries(diagnosticsMap)) {
-    const relativePath = relative4(workingDirectory, filePath);
+    const relativePath = relative5(workingDirectory, filePath);
     let fileErrors = 0;
     let fileWarnings = 0;
     const formattedDiagnostics = diagnostics.map((d) => {
@@ -2945,7 +3408,622 @@ ${file.relativePath}:`);
       lines.push(`  ... and ${file.diagnostics.length - 10} more`);
     }
   }
-  return lines.join("\n");
+  return lines.join("\n");
+}
+
+// src/tools/search.ts
+import { tool as tool8 } from "ai";
+import { z as z9 } from "zod";
+
+// src/agent/subagent.ts
+import {
+  generateText,
+  stepCountIs
+} from "ai";
+import { nanoid as nanoid3 } from "nanoid";
+var Subagent = class {
+  /** Model to use (defaults to gemini-2.0-flash) */
+  model;
+  /** Maximum steps before stopping */
+  maxSteps = 20;
+  constructor(model) {
+    this.model = model || SUBAGENT_MODELS.default;
+  }
+  /**
+   * Parse the final result from the subagent's output.
+   * Override this to structure the result for your subagent type.
+   */
+  parseResult(text2, steps) {
+    return { text: text2, steps };
+  }
+  /**
+   * Run the subagent with streaming progress updates
+   */
+  async run(options) {
+    const { task, sessionId, toolCallId, onProgress, abortSignal } = options;
+    const steps = [];
+    const execution = subagentQueries.create({
+      sessionId,
+      toolCallId,
+      subagentType: this.type,
+      task,
+      model: this.model
+    });
+    const addStep = async (step) => {
+      const fullStep = {
+        id: nanoid3(8),
+        timestamp: Date.now(),
+        ...step
+      };
+      steps.push(fullStep);
+      subagentQueries.addStep(execution.id, fullStep);
+      await onProgress?.({
+        type: "step",
+        subagentId: execution.id,
+        subagentType: this.type,
+        step: fullStep
+      });
+    };
+    try {
+      const tools = this.getTools(options);
+      const systemPrompt = this.getSystemPrompt(options);
+      const result = await generateText({
+        model: resolveModel(this.model),
+        system: systemPrompt,
+        messages: [
+          { role: "user", content: task }
+        ],
+        tools,
+        stopWhen: stepCountIs(this.maxSteps),
+        abortSignal,
+        onStepFinish: async (step) => {
+          if (step.text) {
+            await addStep({
+              type: "text",
+              content: step.text
+            });
+            await onProgress?.({
+              type: "text",
+              subagentId: execution.id,
+              subagentType: this.type,
+              text: step.text
+            });
+          }
+          if (step.toolCalls) {
+            for (const toolCall of step.toolCalls) {
+              await addStep({
+                type: "tool_call",
+                content: `Calling ${toolCall.toolName}`,
+                toolName: toolCall.toolName,
+                toolInput: toolCall.input
+              });
+              await onProgress?.({
+                type: "tool_call",
+                subagentId: execution.id,
+                subagentType: this.type,
+                toolName: toolCall.toolName,
+                toolInput: toolCall.input
+              });
+            }
+          }
+          if (step.toolResults) {
+            for (const toolResult of step.toolResults) {
+              await addStep({
+                type: "tool_result",
+                content: `Result from ${toolResult.toolName}`,
+                toolName: toolResult.toolName,
+                toolOutput: toolResult.output
+              });
+              await onProgress?.({
+                type: "tool_result",
+                subagentId: execution.id,
+                subagentType: this.type,
+                toolName: toolResult.toolName,
+                toolOutput: toolResult.output
+              });
+            }
+          }
+        }
+      });
+      const parsedResult = this.parseResult(result.text, steps);
+      subagentQueries.complete(execution.id, parsedResult);
+      await onProgress?.({
+        type: "complete",
+        subagentId: execution.id,
+        subagentType: this.type,
+        result: parsedResult
+      });
+      return {
+        success: true,
+        result: parsedResult,
+        steps,
+        executionId: execution.id
+      };
+    } catch (error) {
+      const errorMessage = error.message || "Unknown error";
+      subagentQueries.markError(execution.id, errorMessage);
+      await onProgress?.({
+        type: "error",
+        subagentId: execution.id,
+        subagentType: this.type,
+        error: errorMessage
+      });
+      return {
+        success: false,
+        error: errorMessage,
+        steps,
+        executionId: execution.id
+      };
+    }
+  }
+  /**
+   * Run with streaming (for real-time progress in UI)
+   */
+  async *stream(options) {
+    const events = [];
+    let resolveNext = null;
+    let done = false;
+    const eventQueue = [];
+    const runPromise = this.run({
+      ...options,
+      onProgress: async (event) => {
+        eventQueue.push(event);
+        if (resolveNext) {
+          resolveNext(eventQueue.shift());
+          resolveNext = null;
+        }
+      }
+    }).then((result) => {
+      done = true;
+      if (resolveNext) {
+        resolveNext(null);
+      }
+      return result;
+    });
+    while (!done || eventQueue.length > 0) {
+      if (eventQueue.length > 0) {
+        yield eventQueue.shift();
+      } else if (!done) {
+        const event = await new Promise((resolve10) => {
+          resolveNext = resolve10;
+        });
+        if (event) {
+          yield event;
+        }
+      }
+    }
+    await runPromise;
+  }
+};
+
+// src/agent/subagents/search.ts
+import { tool as tool7 } from "ai";
+import { z as z8 } from "zod";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { readFile as readFile7, stat as stat3, readdir as readdir3 } from "fs/promises";
+import { resolve as resolve8, relative as relative6, isAbsolute as isAbsolute4 } from "path";
+import { existsSync as existsSync10 } from "fs";
+var execAsync4 = promisify4(exec4);
+var MAX_OUTPUT_CHARS4 = 2e4;
+var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
+var SearchSubagent = class extends Subagent {
+  type = "search";
+  name = "Search Agent";
+  constructor(model) {
+    super(model || SUBAGENT_MODELS.search);
+    this.maxSteps = 15;
+  }
+  getSystemPrompt(options) {
+    return `You are a specialized search agent for exploring codebases. Your job is to find relevant code, files, and patterns based on the user's query.
+
+Working Directory: ${options.workingDirectory}
+
+You have these tools available:
+- grep: Search for patterns in files using ripgrep (rg)
+- glob: Find files matching a pattern
+- read_file: Read contents of a specific file
+- list_dir: List directory contents
+
+## Strategy - Search in Parallel
+
+IMPORTANT: When searching, run MULTIPLE searches in PARALLEL to cover different variations and related terms. Don't search sequentially - batch your searches together!
+
+For example, if asked "how does authentication work":
+- Search for "auth", "login", "session", "jwt", "token" all at once
+- Search in different likely directories: src/auth/, lib/auth/, services/auth/
+- Look for common patterns: AuthProvider, useAuth, authenticate, isAuthenticated
+
+**Parallel Search Patterns:**
+1. Try multiple naming conventions at once:
+   - camelCase: "getUserData", "handleAuth"
+   - snake_case: "get_user_data", "handle_auth"
+   - PascalCase: "UserService", "AuthProvider"
+
+2. Search for related concepts together:
+   - For "database": search "db", "database", "query", "model", "schema"
+   - For "api": search "endpoint", "route", "handler", "controller", "api"
+
+3. Use glob AND grep together:
+   - Find files: \`*.auth.ts\`, \`*Auth*.tsx\`, \`auth/*.ts\`
+   - Search content: patterns, function names, class names
+
+## Execution Flow
+1. First, run 2-4 parallel searches covering different angles of the query
+2. Review results and identify the most relevant files
+3. Read the key files to understand the full context
+4. Provide a clear summary with exact file paths and line numbers
+
+Be efficient - you have limited steps. Maximize coverage with parallel tool calls.
+
+## Output Format
+When done, provide a summary with:
+- Key files/locations found (with full paths)
+- Relevant code snippets showing the important parts
+- How the pieces connect together
+
+Keep your responses concise and focused on actionable information.`;
+  }
+  getTools(options) {
+    const workingDirectory = options.workingDirectory;
+    return {
+      grep: tool7({
+        description: "Search for patterns in files using ripgrep. Returns matching lines with file paths and line numbers.",
+        inputSchema: z8.object({
+          pattern: z8.string().describe("The regex pattern to search for"),
+          path: z8.string().optional().describe("Subdirectory or file to search in (relative to working directory)"),
+          fileType: z8.string().optional().describe('File type to filter (e.g., "ts", "js", "py")'),
+          maxResults: z8.number().optional().default(50).describe("Maximum number of results to return")
+        }),
+        execute: async ({ pattern, path, fileType, maxResults }) => {
+          try {
+            const searchPath = path ? resolve8(workingDirectory, path) : workingDirectory;
+            let args = ["rg", "--line-number", "--no-heading"];
+            if (fileType) {
+              args.push("--type", fileType);
+            }
+            args.push("--max-count", String(maxResults || 50));
+            args.push("--", pattern, searchPath);
+            const { stdout, stderr } = await execAsync4(args.join(" "), {
+              cwd: workingDirectory,
+              maxBuffer: 5 * 1024 * 1024,
+              timeout: 3e4
+            });
+            const output = truncateOutput(stdout || "No matches found", MAX_OUTPUT_CHARS4);
+            const matchCount = (stdout || "").split("\n").filter(Boolean).length;
+            return {
+              success: true,
+              output,
+              matchCount,
+              pattern
+            };
+          } catch (error) {
+            if (error.code === 1 && !error.stderr) {
+              return {
+                success: true,
+                output: "No matches found",
+                matchCount: 0,
+                pattern
+              };
+            }
+            return {
+              success: false,
+              error: error.message,
+              pattern
+            };
+          }
+        }
+      }),
+      glob: tool7({
+        description: "Find files matching a glob pattern. Returns list of matching file paths.",
+        inputSchema: z8.object({
+          pattern: z8.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.tsx", "*.json")'),
+          maxResults: z8.number().optional().default(100).describe("Maximum number of files to return")
+        }),
+        execute: async ({ pattern, maxResults }) => {
+          try {
+            const { stdout } = await execAsync4(
+              `find . -type f -name "${pattern.replace("**/", "")}" 2>/dev/null | head -n ${maxResults || 100}`,
+              {
+                cwd: workingDirectory,
+                timeout: 3e4
+              }
+            );
+            const files = stdout.trim().split("\n").filter(Boolean);
+            return {
+              success: true,
+              files,
+              count: files.length,
+              pattern
+            };
+          } catch (error) {
+            return {
+              success: false,
+              error: error.message,
+              pattern
+            };
+          }
+        }
+      }),
+      read_file: tool7({
+        description: "Read the contents of a file. Use this to examine specific files found in search.",
+        inputSchema: z8.object({
+          path: z8.string().describe("Path to the file (relative to working directory or absolute)"),
+          startLine: z8.number().optional().describe("Start reading from this line (1-indexed)"),
+          endLine: z8.number().optional().describe("Stop reading at this line (1-indexed, inclusive)")
+        }),
+        execute: async ({ path, startLine, endLine }) => {
+          try {
+            const absolutePath = isAbsolute4(path) ? path : resolve8(workingDirectory, path);
+            if (!existsSync10(absolutePath)) {
+              return {
+                success: false,
+                error: `File not found: ${path}`
+              };
+            }
+            const stats = await stat3(absolutePath);
+            if (stats.size > MAX_FILE_SIZE2) {
+              return {
+                success: false,
+                error: `File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Use startLine/endLine to read portions.`
+              };
+            }
+            let content = await readFile7(absolutePath, "utf-8");
+            if (startLine !== void 0 || endLine !== void 0) {
+              const lines = content.split("\n");
+              const start = (startLine ?? 1) - 1;
+              const end = endLine ?? lines.length;
+              content = lines.slice(start, end).join("\n");
+            }
+            return {
+              success: true,
+              path: relative6(workingDirectory, absolutePath),
+              content: truncateOutput(content, MAX_OUTPUT_CHARS4),
+              lineCount: content.split("\n").length
+            };
+          } catch (error) {
+            return {
+              success: false,
+              error: error.message
+            };
+          }
+        }
+      }),
+      list_dir: tool7({
+        description: "List contents of a directory. Shows files and subdirectories.",
+        inputSchema: z8.object({
+          path: z8.string().optional().default(".").describe("Directory path (relative to working directory)"),
+          recursive: z8.boolean().optional().default(false).describe("List recursively (be careful with large directories)"),
+          maxDepth: z8.number().optional().default(2).describe("Maximum depth for recursive listing")
+        }),
+        execute: async ({ path, recursive, maxDepth }) => {
+          try {
+            const absolutePath = isAbsolute4(path) ? path : resolve8(workingDirectory, path);
+            if (!existsSync10(absolutePath)) {
+              return {
+                success: false,
+                error: `Directory not found: ${path}`
+              };
+            }
+            const stats = await stat3(absolutePath);
+            if (!stats.isDirectory()) {
+              return {
+                success: false,
+                error: `Not a directory: ${path}`
+              };
+            }
+            if (recursive) {
+              const { stdout } = await execAsync4(
+                `find . -maxdepth ${maxDepth} -type f 2>/dev/null | head -n 200`,
+                {
+                  cwd: absolutePath,
+                  timeout: 1e4
+                }
+              );
+              const files = stdout.trim().split("\n").filter(Boolean);
+              return {
+                success: true,
+                path: relative6(workingDirectory, absolutePath) || ".",
+                files,
+                count: files.length,
+                recursive: true
+              };
+            } else {
+              const entries = await readdir3(absolutePath, { withFileTypes: true });
+              const items = entries.slice(0, 200).map((e) => ({
+                name: e.name,
+                type: e.isDirectory() ? "directory" : "file"
+              }));
+              return {
+                success: true,
+                path: relative6(workingDirectory, absolutePath) || ".",
+                items,
+                count: items.length
+              };
+            }
+          } catch (error) {
+            return {
+              success: false,
+              error: error.message
+            };
+          }
+        }
+      })
+    };
+  }
+  parseResult(text2, steps) {
+    const findings = [];
+    let filesSearched = 0;
+    let matchCount = 0;
+    for (const step of steps) {
+      if (step.type === "tool_result" && step.toolOutput) {
+        const output = step.toolOutput;
+        if (step.toolName === "grep" && output.success) {
+          matchCount += output.matchCount || 0;
+          const lines = (output.output || "").split("\n").filter(Boolean).slice(0, 10);
+          for (const line of lines) {
+            const match = line.match(/^([^:]+):(\d+):(.*)$/);
+            if (match) {
+              findings.push({
+                type: "match",
+                path: match[1],
+                lineNumber: parseInt(match[2], 10),
+                content: match[3].trim(),
+                relevance: "high"
+              });
+            }
+          }
+        } else if (step.toolName === "glob" && output.success) {
+          filesSearched += output.count || 0;
+          for (const file of (output.files || []).slice(0, 5)) {
+            findings.push({
+              type: "file",
+              path: file,
+              relevance: "medium"
+            });
+          }
+        } else if (step.toolName === "read_file" && output.success) {
+          findings.push({
+            type: "file",
+            path: output.path,
+            relevance: "high",
+            context: `${output.lineCount} lines`
+          });
+        }
+      }
+    }
+    const query = steps.length > 0 ? steps.find((s) => s.type === "text")?.content || "" : "";
+    return {
+      query,
+      summary: text2,
+      findings: findings.slice(0, 20),
+      // Limit findings
+      filesSearched,
+      matchCount
+    };
+  }
+};
+function createSearchSubagent(model) {
+  return new SearchSubagent(model);
+}
+
+// src/tools/search.ts
+var MAX_RESULT_CHARS = 8e3;
+function createSearchTool(options) {
+  return tool8({
+    description: `Delegate a search task to a specialized search agent. Use this when you need to:
+- Find files or code matching a pattern
+- Explore the codebase structure
+- Search for specific functions, classes, or variables
+- Understand how a feature is implemented
+
+The search agent will explore the codebase and return a summary of findings.
+This is more thorough than a simple grep because it can follow references and understand context.
+
+Examples:
+- "Find all React components that use the useState hook"
+- "Where is the authentication logic implemented?"
+- "Find all API routes and their handlers"
+- "Search for usages of the UserService class"`,
+    inputSchema: z9.object({
+      query: z9.string().describe("What to search for. Be specific about what you're looking for."),
+      context: z9.string().optional().describe("Optional additional context about why you need this information.")
+    }),
+    execute: async ({ query, context }, toolOptions) => {
+      const toolCallId = toolOptions.toolCallId || `search_${Date.now()}`;
+      await options.onProgress?.({
+        status: "started",
+        subagentId: toolCallId
+      });
+      try {
+        const subagent = createSearchSubagent();
+        const fullTask = context ? `${query}
+
+Context: ${context}` : query;
+        const result = await subagent.run({
+          task: fullTask,
+          sessionId: options.sessionId,
+          toolCallId,
+          workingDirectory: options.workingDirectory,
+          onProgress: async (event) => {
+            if (event.type === "step" && event.step) {
+              await options.onProgress?.({
+                status: "step",
+                subagentId: event.subagentId,
+                stepType: event.step.type,
+                stepContent: event.step.content,
+                toolName: event.step.toolName,
+                toolInput: event.step.toolInput,
+                toolOutput: event.step.toolOutput
+              });
+            } else if (event.type === "complete") {
+              await options.onProgress?.({
+                status: "complete",
+                subagentId: event.subagentId,
+                result: event.result
+              });
+            } else if (event.type === "error") {
+              await options.onProgress?.({
+                status: "error",
+                subagentId: event.subagentId,
+                error: event.error
+              });
+            }
+          }
+        });
+        if (!result.success) {
+          return {
+            success: false,
+            error: result.error || "Search failed",
+            executionId: result.executionId
+          };
+        }
+        const searchResult = result.result;
+        let formattedResult = `## Search Results
+
+`;
+        formattedResult += `**Summary:** ${searchResult.summary}
+
+`;
+        if (searchResult.findings.length > 0) {
+          formattedResult += `### Key Findings (${searchResult.findings.length} items)
+
+`;
+          for (const finding of searchResult.findings) {
+            if (finding.type === "match") {
+              formattedResult += `- **${finding.path}:${finding.lineNumber}** - ${truncateOutput(finding.content || "", 200)}
+`;
+            } else if (finding.type === "file") {
+              formattedResult += `- **${finding.path}** ${finding.context ? `(${finding.context})` : ""}
+`;
+            }
+          }
+        }
+        formattedResult += `
+**Stats:** ${searchResult.matchCount} matches across ${searchResult.filesSearched} files searched`;
+        return {
+          success: true,
+          query: searchResult.query,
+          summary: searchResult.summary,
+          findings: searchResult.findings,
+          matchCount: searchResult.matchCount,
+          filesSearched: searchResult.filesSearched,
+          formattedResult: truncateOutput(formattedResult, MAX_RESULT_CHARS),
+          executionId: result.executionId,
+          stepsCount: result.steps.length
+        };
+      } catch (error) {
+        await options.onProgress?.({
+          status: "error",
+          error: error.message
+        });
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
 }
 
 // src/tools/index.ts
@@ -2963,7 +4041,8 @@ function createTools(options) {
     write_file: createWriteFileTool({
       workingDirectory: options.workingDirectory,
       sessionId: options.sessionId,
-      enableLSP: options.enableLSP ?? true
+      enableLSP: options.enableLSP ?? true,
+      onProgress: options.onWriteFileProgress
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -2974,15 +4053,20 @@ function createTools(options) {
     }),
     linter: createLinterTool({
       workingDirectory: options.workingDirectory
+    }),
+    search: createSearchTool({
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory,
+      onProgress: options.onSearchProgress
     })
   };
 }
 
 // src/agent/context.ts
-import { generateText } from "ai";
-import { gateway } from "@ai-sdk/gateway";
+import { generateText as generateText2 } from "ai";
 
 // src/agent/prompts.ts
+init_skills();
 import os from "os";
 function getSearchInstructions() {
   const platform3 = process.platform;
@@ -3001,9 +4085,33 @@ function getSearchInstructions() {
 - **If ripgrep (\`rg\`) is installed**: \`rg "pattern" -t ts src/\` - faster and respects .gitignore`;
 }
 async function buildSystemPrompt(options) {
-  const { workingDirectory, skillsDirectories, sessionId, customInstructions } = options;
-  const skills = await loadAllSkills(skillsDirectories);
-  const skillsContext = formatSkillsForContext(skills);
+  const {
+    workingDirectory,
+    skillsDirectories,
+    sessionId,
+    discoveredSkills,
+    activeFiles = [],
+    customInstructions
+  } = options;
+  let alwaysLoadedContent = "";
+  let globMatchedContent = "";
+  let agentsMdContent = "";
+  let onDemandSkillsContext = "";
+  if (discoveredSkills) {
+    const { always, onDemand, all } = await loadAllSkillsFromDiscovered(discoveredSkills);
+    alwaysLoadedContent = formatAlwaysLoadedSkills(always);
+    onDemandSkillsContext = formatSkillsForContext(onDemand);
+    const agentsMd = await loadAgentsMd(discoveredSkills.agentsMdPath);
+    agentsMdContent = formatAgentsMdContent(agentsMd);
+    if (activeFiles.length > 0) {
+      const globMatched = await getGlobMatchedSkills(all, activeFiles, workingDirectory);
+      globMatchedContent = formatGlobMatchedSkills(globMatched);
+    }
+  } else {
+    const { loadAllSkills: loadAllSkills2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
+    const skills = await loadAllSkills2(skillsDirectories);
+    onDemandSkillsContext = formatSkillsForContext(skills);
+  }
   const todos = todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
   const platform3 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
@@ -3024,6 +4132,7 @@ You have access to powerful tools for:
 - **linter**: Check files for type errors and lint issues (TypeScript, JavaScript, TSX, JSX)
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
+- **search**: Semantic search using a subagent - for exploratory questions and finding code by meaning
 
 
 IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
@@ -3100,6 +4209,9 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
 - Use \`write_file\` with mode "full" only for new files or complete rewrites
 - After making changes, use the \`linter\` tool to check for type errors and lint issues
 - The \`write_file\` tool automatically shows lint errors in its output for TypeScript/JavaScript files
+- If the user asks to write/create a file, always use \`write_file\` rather than printing the full contents
+- If the user requests a file but does not provide a path, choose a sensible default (e.g. \`index.html\`) and proceed
+- For large content (hundreds of lines), avoid placing it in chat output; write to a file instead
 
 ### Linter Tool
 The linter tool uses Language Server Protocol (LSP) to detect type errors and lint issues:
@@ -3111,6 +4223,30 @@ linter({ paths: ["src/"] })          // Check all files in a directory
 Use this proactively after making code changes to catch errors early.
 
 ### Searching and Exploration
+
+**Choose the right search approach:**
+
+1. **Use the \`search\` tool (subagent)** for:
+   - Semantic/exploratory questions: "How does authentication work?", "Where is user data processed?"
+   - Finding code by meaning or concept, not exact text
+   - Understanding how features are implemented across multiple files
+   - Exploring unfamiliar parts of the codebase
+   - Questions like "where", "how", "what does X do"
+   
+   The search subagent is a mini-agent that intelligently explores the codebase, reads relevant files, and returns a summary of what it found. It's best for understanding and discovery.
+
+2. **Use direct commands (grep/rg, find)** for:
+   - Exact string matches: \`rg "functionName"\`, \`rg "class MyClass"\`
+   - Finding files by name: \`find . -name "*.config.ts"\`
+   - Simple pattern matching when you know exactly what you're looking for
+   - Counting occurrences or listing all matches
+
+**Examples:**
+- "Where is the API authentication handled?" \u2192 Use \`search\` tool
+- "Find all usages of getUserById" \u2192 Use \`rg "getUserById"\`
+- "How does the payment flow work?" \u2192 Use \`search\` tool
+- "Find files named config" \u2192 Use \`find . -name "*config*"\`
+
 ${searchInstructions}
 
 ###Follow these principles when designing and implementing software:
@@ -3133,11 +4269,11 @@ ${searchInstructions}
 16. **Diversity** \u2014 Distrust all claims for "one true way"
 17. **Extensibility** \u2014 Design for the future, because it will be here sooner than you think
 
-###Follow these ruls to be a good agent for the user:
+### Follow these rules to be a good agent for the user:
 
-1. Understand first - Read relevant files before making any changes. Use search tools to explore the codebase and understand the existing patterns and structure.
+1. Understand first - Read relevant files before making any changes. Use the \`search\` tool for exploratory questions about how things work, and direct searches (grep/rg) for finding exact strings or file names.
 2. Plan for complexity - If the task involves 3+ steps or has meaningful trade-offs, create a todo list to track progress before implementing.
-3. Use the right tools - Have specialized tools for reading files, editing code, searching by pattern , running terminal commands, and more. Prefer these over raw shell commands.
+3. Use the right tools - Have specialized tools for reading files, editing code, semantic search via subagents, and running terminal commands. Prefer these over raw shell commands.
 4. Work efficiently - When need to do multiple independent things (like reading several files), do them in parallel rather than one at a time.
 5. Be direct - Focus on technical accuracy rather than validation. If see issues with an approach or need clarification, say so.
 6. Verify my work - After making changes, check for linter errors and fix any introduced.
@@ -3150,8 +4286,14 @@ ${searchInstructions}
 - Ask clarifying questions when requirements are ambiguous
 - Report progress on multi-step tasks
 
-## Skills
-${skillsContext}
+${agentsMdContent}
+
+${alwaysLoadedContent}
+
+${globMatchedContent}
+
+## On-Demand Skills
+${onDemandSkillsContext}
 
 ## Current Task List
 ${todosContext}
@@ -3246,8 +4388,8 @@ ${this.summary}`
     try {
       const config = getConfig();
       const summaryPrompt = createSummaryPrompt(historyText);
-      const result = await generateText({
-        model: gateway(config.defaultModel),
+      const result = await generateText2({
+        model: resolveModel(config.defaultModel),
         prompt: summaryPrompt
       });
       this.summary = result.text;
@@ -3260,11 +4402,12 @@ ${this.summary}`
   }
   /**
    * Add a user message to the context
+   * Content can be a string or an array of content parts (for messages with images/files)
    */
-  addUserMessage(text2) {
+  addUserMessage(content) {
     const userMessage = {
       role: "user",
-      content: text2
+      content
     };
     messageQueries.create(this.sessionId, userMessage);
   }
@@ -3316,7 +4459,9 @@ var Agent = class _Agent {
       sessionId: this.session.id,
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
-      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0
+      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: "search", data: progress }) : void 0
     });
   }
   /**
@@ -3364,40 +4509,94 @@ var Agent = class _Agent {
   getSession() {
     return this.session;
   }
+  /**
+   * Build user message content from prompt and attachments
+   */
+  buildUserMessageContent(prompt, attachments) {
+    if (!attachments || attachments.length === 0) {
+      return prompt;
+    }
+    const contentParts = [];
+    const attachmentDescriptions = attachments.map((a, i) => {
+      const name = a.filename || `attachment_${i + 1}`;
+      const typeLabel = a.type === "image" ? "Image" : "File";
+      const location = a.savedPath || "(path unknown)";
+      return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+    }).join("\n");
+    contentParts.push({
+      type: "text",
+      text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+    });
+    if (prompt) {
+      contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+    }
+    for (const attachment of attachments) {
+      if (attachment.type === "image") {
+        contentParts.push({
+          type: "image",
+          image: attachment.data,
+          // base64 data URL or raw base64
+          mediaType: attachment.mediaType,
+          filename: attachment.filename,
+          savedPath: attachment.savedPath
+        });
+      } else {
+        contentParts.push({
+          type: "file",
+          data: attachment.data,
+          mediaType: attachment.mediaType || "application/octet-stream",
+          filename: attachment.filename,
+          savedPath: attachment.savedPath
+        });
+      }
+    }
+    return contentParts;
+  }
   /**
    * Run the agent with a prompt (streaming)
    */
   async stream(options) {
     const config = getConfig();
+    const userContent = this.buildUserMessageContent(options.prompt, options.attachments);
     if (!options.skipSaveUserMessage) {
-      this.context.addUserMessage(options.prompt);
+      this.context.addUserMessage(userContent);
     }
     sessionQueries.updateStatus(this.session.id, "active");
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
-      sessionId: this.session.id
+      sessionId: this.session.id,
+      discoveredSkills: config.discoveredSkills,
+      // TODO: Pass activeFiles from client for glob matching
+      activeFiles: []
     });
     const messages2 = await this.context.getMessages();
     const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
     const wrappedTools = this.wrapToolsWithApproval(options, tools);
-    const stream = streamText({
-      model: gateway2(this.session.model),
+    const useAnthropic = isAnthropicModel(this.session.model);
+    const stream = streamText2({
+      model: resolveModel(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(500),
+      stopWhen: stepCountIs2(500),
       // Forward abort signal if provided
       abortSignal: options.abortSignal,
       // Enable extended thinking/reasoning for models that support it
-      providerOptions: {
+      providerOptions: useAnthropic ? {
         anthropic: {
+          toolStreaming: true,
           thinking: {
             type: "enabled",
             budgetTokens: 1e4
           }
         }
-      },
+      } : void 0,
       onStepFinish: async (step) => {
         options.onStepFinish?.(step);
       },
@@ -3427,26 +4626,29 @@ var Agent = class _Agent {
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
-      sessionId: this.session.id
+      sessionId: this.session.id,
+      discoveredSkills: config.discoveredSkills,
+      activeFiles: []
     });
     const messages2 = await this.context.getMessages();
     const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
     const wrappedTools = this.wrapToolsWithApproval(options, tools);
-    const result = await generateText2({
-      model: gateway2(this.session.model),
+    const useAnthropic = isAnthropicModel(this.session.model);
+    const result = await generateText3({
+      model: resolveModel(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(500),
+      stopWhen: stepCountIs2(500),
       // Enable extended thinking/reasoning for models that support it
-      providerOptions: {
+      providerOptions: useAnthropic ? {
         anthropic: {
           thinking: {
             type: "enabled",
             budgetTokens: 1e4
           }
         }
-      }
+      } : void 0
     });
     const responseMessages = result.response.messages;
     this.context.addResponseMessages(responseMessages);
@@ -3468,11 +4670,11 @@ var Agent = class _Agent {
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool7({
+      wrappedTools[name] = tool9({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z8.object({}),
+        inputSchema: originalTool.inputSchema || z10.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid3();
+          const toolCallId = toolOptions.toolCallId || nanoid4();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -3484,8 +4686,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve9) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve9, sessionId: this.session.id });
+          const approved = await new Promise((resolve10) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve10, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
@@ -3580,18 +4782,18 @@ var Agent = class _Agent {
 
 // src/server/routes/sessions.ts
 var sessions2 = new Hono();
-var createSessionSchema = z9.object({
-  name: z9.string().optional(),
-  workingDirectory: z9.string().optional(),
-  model: z9.string().optional(),
-  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
+var createSessionSchema = z11.object({
+  name: z11.string().optional(),
+  workingDirectory: z11.string().optional(),
+  model: z11.string().optional(),
+  toolApprovals: z11.record(z11.string(), z11.boolean()).optional()
 });
-var paginationQuerySchema = z9.object({
-  limit: z9.string().optional(),
-  offset: z9.string().optional()
+var paginationQuerySchema = z11.object({
+  limit: z11.string().optional(),
+  offset: z11.string().optional()
 });
-var messagesQuerySchema = z9.object({
-  limit: z9.string().optional()
+var messagesQuerySchema = z11.object({
+  limit: z11.string().optional()
 });
 sessions2.get(
   "/",
@@ -3730,10 +4932,10 @@ sessions2.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z9.object({
-  model: z9.string().optional(),
-  name: z9.string().optional(),
-  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
+var updateSessionSchema = z11.object({
+  model: z11.string().optional(),
+  name: z11.string().optional(),
+  toolApprovals: z11.record(z11.string(), z11.boolean()).optional()
 });
 sessions2.patch(
   "/:id",
@@ -3930,11 +5132,275 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
     currentContent: fileDiff.currentContent
   });
 });
+function getAttachmentsDir(sessionId) {
+  const appDataDir = getAppDataDirectory();
+  return join4(appDataDir, "attachments", sessionId);
+}
+function ensureAttachmentsDir(sessionId) {
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync11(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+sessions2.get("/:id/attachments", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync11(dir)) {
+    return c.json({ sessionId, attachments: [], count: 0 });
+  }
+  const files = readdirSync(dir);
+  const attachments = files.map((filename) => {
+    const filePath = join4(dir, filename);
+    const stats = statSync(filePath);
+    return {
+      id: filename.split("_")[0],
+      // Extract the nanoid prefix
+      filename,
+      path: filePath,
+      size: stats.size,
+      createdAt: stats.birthtime.toISOString()
+    };
+  });
+  return c.json({
+    sessionId,
+    attachments,
+    count: attachments.length
+  });
+});
+sessions2.post("/:id/attachments", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const contentType = c.req.header("content-type") || "";
+  if (contentType.includes("multipart/form-data")) {
+    try {
+      const formData = await c.req.formData();
+      const file = formData.get("file");
+      if (!file || !(file instanceof File)) {
+        return c.json({ error: "No file provided" }, 400);
+      }
+      const dir = ensureAttachmentsDir(sessionId);
+      const id = nanoid5(10);
+      const ext = extname6(file.name) || "";
+      const safeFilename = `${id}_${basename2(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+      const filePath = join4(dir, safeFilename);
+      const arrayBuffer = await file.arrayBuffer();
+      writeFileSync2(filePath, Buffer.from(arrayBuffer));
+      return c.json({
+        id,
+        filename: file.name,
+        storedAs: safeFilename,
+        path: filePath,
+        size: file.size,
+        mediaType: file.type,
+        sessionId
+      }, 201);
+    } catch (err) {
+      console.error("Failed to upload attachment:", err);
+      return c.json({ error: "Failed to upload file" }, 500);
+    }
+  }
+  try {
+    const body = await c.req.json();
+    if (!body.filename || !body.data) {
+      return c.json({ error: "Missing filename or data" }, 400);
+    }
+    const dir = ensureAttachmentsDir(sessionId);
+    const id = nanoid5(10);
+    const ext = extname6(body.filename) || "";
+    const safeFilename = `${id}_${basename2(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+    const filePath = join4(dir, safeFilename);
+    let base64Data = body.data;
+    if (base64Data.includes(",")) {
+      base64Data = base64Data.split(",")[1];
+    }
+    const buffer = Buffer.from(base64Data, "base64");
+    writeFileSync2(filePath, buffer);
+    return c.json({
+      id,
+      filename: body.filename,
+      storedAs: safeFilename,
+      path: filePath,
+      size: buffer.length,
+      mediaType: body.mediaType,
+      sessionId
+    }, 201);
+  } catch (err) {
+    console.error("Failed to upload attachment:", err);
+    return c.json({ error: "Failed to upload file" }, 500);
+  }
+});
+sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
+  const sessionId = c.req.param("id");
+  const attachmentId = c.req.param("attachmentId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync11(dir)) {
+    return c.json({ error: "Attachment not found" }, 404);
+  }
+  const files = readdirSync(dir);
+  const file = files.find((f) => f.startsWith(attachmentId + "_"));
+  if (!file) {
+    return c.json({ error: "Attachment not found" }, 404);
+  }
+  const filePath = join4(dir, file);
+  unlinkSync(filePath);
+  return c.json({ success: true, id: attachmentId });
+});
+var filesQuerySchema = z11.object({
+  query: z11.string().optional(),
+  // Filter query (e.g., "src/com" to match "src/components")
+  limit: z11.string().optional()
+  // Max results (default 50)
+});
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".turbo",
+  ".cache",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  "target",
+  // Rust
+  ".idea",
+  ".vscode"
+]);
+var IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".o",
+  ".obj",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib"
+]);
+async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = []) {
+  if (results.length >= limit) {
+    return results;
+  }
+  try {
+    const entries = await readdir4(currentDir, { withFileTypes: true });
+    const queryLower = query.toLowerCase();
+    for (const entry of entries) {
+      if (results.length >= limit) break;
+      const fullPath = join4(currentDir, entry.name);
+      const relativePath = relative7(baseDir, fullPath);
+      if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const ext = extname6(entry.name).toLowerCase();
+      if (IGNORED_EXTENSIONS.has(ext)) {
+        continue;
+      }
+      const matchesQuery = !query || relativePath.toLowerCase().includes(queryLower) || entry.name.toLowerCase().includes(queryLower);
+      if (entry.isDirectory()) {
+        if (matchesQuery) {
+          results.push({
+            path: relativePath,
+            name: entry.name,
+            type: "folder"
+          });
+        }
+        const shouldRecurse = !query || relativePath.toLowerCase().startsWith(queryLower) || queryLower.startsWith(relativePath.toLowerCase());
+        if (shouldRecurse && results.length < limit) {
+          await listWorkspaceFiles(baseDir, fullPath, query, limit, results);
+        }
+      } else if (entry.isFile()) {
+        if (matchesQuery) {
+          results.push({
+            path: relativePath,
+            name: entry.name,
+            type: "file",
+            extension: ext || void 0
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+sessions2.get(
+  "/:id/files",
+  zValidator("query", filesQuerySchema),
+  async (c) => {
+    const sessionId = c.req.param("id");
+    const { query = "", limit: limitStr = "50" } = c.req.valid("query");
+    const limit = Math.min(parseInt(limitStr) || 50, 100);
+    const session = sessionQueries.getById(sessionId);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const workingDirectory = session.workingDirectory;
+    if (!existsSync11(workingDirectory)) {
+      return c.json({
+        sessionId,
+        workingDirectory,
+        files: [],
+        count: 0,
+        error: "Working directory does not exist"
+      });
+    }
+    try {
+      const files = await listWorkspaceFiles(
+        workingDirectory,
+        workingDirectory,
+        query,
+        limit
+      );
+      files.sort((a, b) => {
+        if (a.type !== b.type) {
+          return a.type === "folder" ? -1 : 1;
+        }
+        return a.path.localeCompare(b.path);
+      });
+      return c.json({
+        sessionId,
+        workingDirectory,
+        files,
+        count: files.length,
+        query
+      });
+    } catch (err) {
+      console.error("Failed to list workspace files:", err);
+      return c.json({
+        error: "Failed to list files",
+        sessionId,
+        workingDirectory,
+        files: [],
+        count: 0
+      }, 500);
+    }
+  }
+);
 
 // src/server/routes/agents.ts
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/server/resumable-stream.ts
 import { createResumableStreamContext } from "resumable-stream/generic";
@@ -4009,27 +5475,152 @@ var streamContext = createResumableStreamContext({
 });
 
 // src/server/routes/agents.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
+var MAX_TOOL_INPUT_LENGTH = 8 * 1024;
+var MAX_TOOL_INPUT_PREVIEW = 2 * 1024;
+var MAX_TOOL_ARGS_CHUNK = 2 * 1024;
+function sanitizeToolInput(toolName, input) {
+  if (toolName !== "write_file" || !input || typeof input !== "object") {
+    return input;
+  }
+  const data = input;
+  let changed = false;
+  const next = { ...data };
+  const content = typeof data.content === "string" ? data.content : void 0;
+  if (content && content.length > MAX_TOOL_INPUT_LENGTH) {
+    next.content = `${content.slice(0, MAX_TOOL_INPUT_PREVIEW)}
+... (truncated)`;
+    next.contentLength = content.length;
+    next.contentTruncated = true;
+    changed = true;
+  }
+  const oldString = typeof data.old_string === "string" ? data.old_string : void 0;
+  if (oldString && oldString.length > MAX_TOOL_INPUT_LENGTH) {
+    next.old_string = `${oldString.slice(0, MAX_TOOL_INPUT_PREVIEW)}
+... (truncated)`;
+    next.oldStringLength = oldString.length;
+    next.oldStringTruncated = true;
+    changed = true;
+  }
+  const newString = typeof data.new_string === "string" ? data.new_string : void 0;
+  if (newString && newString.length > MAX_TOOL_INPUT_LENGTH) {
+    next.new_string = `${newString.slice(0, MAX_TOOL_INPUT_PREVIEW)}
+... (truncated)`;
+    next.newStringLength = newString.length;
+    next.newStringTruncated = true;
+    changed = true;
+  }
+  if (changed) {
+    console.log("[TOOL-INPUT] Truncated write_file input for streaming payload size");
+  }
+  return changed ? next : input;
+}
+function buildToolArgsText(input) {
+  try {
+    return JSON.stringify(input ?? {});
+  } catch {
+    return "{}";
+  }
+}
+async function emitSyntheticToolStreaming(writeSSE, toolCallStarts, toolCallId, toolName, input) {
+  if (toolCallStarts.has(toolCallId)) return;
+  toolCallStarts.add(toolCallId);
+  await writeSSE(JSON.stringify({
+    type: "tool-input-start",
+    toolCallId,
+    toolName
+  }));
+  if (toolName !== "write_file") return;
+  const argsText = buildToolArgsText(input);
+  for (let i = 0; i < argsText.length; i += MAX_TOOL_ARGS_CHUNK) {
+    const chunk = argsText.slice(i, i + MAX_TOOL_ARGS_CHUNK);
+    await writeSSE(JSON.stringify({
+      type: "tool-input-delta",
+      toolCallId,
+      argsTextDelta: chunk
+    }));
+    await new Promise((resolve10) => setTimeout(resolve10, 0));
+  }
+}
 var agents = new Hono2();
-var runPromptSchema = z10.object({
-  prompt: z10.string().min(1)
+var attachmentSchema = z12.object({
+  type: z12.enum(["image", "file"]),
+  data: z12.string(),
+  // base64 data URL or raw base64
+  mediaType: z12.string().optional(),
+  filename: z12.string().optional()
 });
-var quickStartSchema = z10.object({
-  prompt: z10.string().min(1),
-  name: z10.string().optional(),
-  workingDirectory: z10.string().optional(),
-  model: z10.string().optional(),
-  toolApprovals: z10.record(z10.string(), z10.boolean()).optional()
+var runPromptSchema = z12.object({
+  prompt: z12.string(),
+  // Can be empty if attachments are provided
+  attachments: z12.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 = z12.object({
+  prompt: z12.string().min(1),
+  name: z12.string().optional(),
+  workingDirectory: z12.string().optional(),
+  model: z12.string().optional(),
+  toolApprovals: z12.record(z12.string(), z12.boolean()).optional()
 });
-var rejectSchema = z10.object({
-  reason: z10.string().optional()
+var rejectSchema = z12.object({
+  reason: z12.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
-function createAgentStreamProducer(sessionId, prompt, streamId) {
+function getAttachmentsDirectory(sessionId) {
+  const appDataDir = getAppDataDirectory();
+  return join5(appDataDir, "attachments", sessionId);
+}
+function saveAttachmentToDisk(sessionId, attachment, index) {
+  const attachmentsDir = getAttachmentsDirectory(sessionId);
+  if (!existsSync12(attachmentsDir)) {
+    mkdirSync4(attachmentsDir, { recursive: true });
+  }
+  let filename = attachment.filename;
+  if (!filename) {
+    const ext = getExtensionFromMediaType(attachment.mediaType, attachment.type);
+    filename = `attachment_${index + 1}${ext}`;
+  }
+  let base64Data = attachment.data;
+  if (base64Data.includes(",")) {
+    base64Data = base64Data.split(",")[1];
+  }
+  const filePath = join5(attachmentsDir, filename);
+  const buffer = Buffer.from(base64Data, "base64");
+  writeFileSync3(filePath, buffer);
+  return filePath;
+}
+function getExtensionFromMediaType(mediaType, type) {
+  if (!mediaType) {
+    return type === "image" ? ".png" : ".bin";
+  }
+  const mimeToExt = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/svg+xml": ".svg",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "application/json": ".json",
+    "application/javascript": ".js",
+    "text/javascript": ".js",
+    "text/typescript": ".ts",
+    "text/html": ".html",
+    "text/css": ".css"
+  };
+  return mimeToExt[mediaType] || ".bin";
+}
+function createAgentStreamProducer(sessionId, prompt, streamId, attachments) {
   return () => {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
     let writerClosed = false;
+    const toolCallStarts = /* @__PURE__ */ new Set();
     const abortController = new AbortController();
     streamAbortControllers.set(streamId, abortController);
     const writeSSE = async (data) => {
@@ -4058,9 +5649,53 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
       try {
         const agent = await Agent.create({ sessionId });
         await writeSSE(JSON.stringify({ type: "data-stream-id", streamId }));
+        let broadcastContent;
+        if (attachments && attachments.length > 0) {
+          const contentParts = [];
+          const attachmentDescriptions = attachments.map((a, i) => {
+            const name = a.filename || `attachment_${i + 1}`;
+            const typeLabel = a.type === "image" ? "Image" : "File";
+            const location = a.savedPath || "(path unknown)";
+            return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+          }).join("\n");
+          contentParts.push({
+            type: "text",
+            text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+          });
+          if (prompt) {
+            contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+          }
+          for (const attachment of attachments) {
+            if (attachment.type === "image") {
+              contentParts.push({
+                type: "image",
+                image: attachment.data,
+                mediaType: attachment.mediaType,
+                filename: attachment.filename,
+                savedPath: attachment.savedPath
+              });
+            } else {
+              contentParts.push({
+                type: "file",
+                data: attachment.data,
+                mediaType: attachment.mediaType || "application/octet-stream",
+                filename: attachment.filename,
+                savedPath: attachment.savedPath
+              });
+            }
+          }
+          broadcastContent = contentParts;
+        } else {
+          broadcastContent = prompt;
+        }
         await writeSSE(JSON.stringify({
           type: "data-user-message",
-          data: { id: `user_${Date.now()}`, content: prompt }
+          data: { id: `user_${Date.now()}`, content: broadcastContent }
         }));
         const messageId = `msg_${Date.now()}`;
         await writeSSE(JSON.stringify({ type: "start", messageId }));
@@ -4068,6 +5703,8 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
         let textStarted = false;
         const result = await agent.stream({
           prompt,
+          attachments,
+          // Pass attachments to agent
           abortSignal: abortController.signal,
           // Use our managed abort controller, NOT client signal
           skipSaveUserMessage: true,
@@ -4092,11 +5729,32 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
             }));
           },
           onToolProgress: async (progress) => {
+            const status = progress.data?.status || "no-status";
+            const contentLength = typeof progress.data?.content === "string" ? progress.data.content.length : void 0;
+            const chunkIndex = progress.data?.chunkIndex;
+            const chunkCount = progress.data?.chunkCount;
+            console.log(
+              "[TOOL-PROGRESS] Sending:",
+              progress.toolName,
+              status,
+              contentLength !== void 0 ? `contentLength=${contentLength}` : "",
+              chunkIndex !== void 0 || chunkCount !== void 0 ? `chunk=${chunkIndex}/${chunkCount}` : ""
+            );
             await writeSSE(JSON.stringify({
               type: "tool-progress",
               toolName: progress.toolName,
               data: progress.data
             }));
+            if (progress.toolName === "write_file" && status === "content") {
+              await writeSSE(JSON.stringify({
+                type: "debug",
+                label: "write-file-progress",
+                contentLength,
+                chunkIndex,
+                chunkCount
+              }));
+              await new Promise((resolve10) => setTimeout(resolve10, 0));
+            }
           },
           onStepFinish: async () => {
             await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -4138,6 +5796,7 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
               toolCallId: p.toolCallId,
               toolName: p.toolName
             }));
+            toolCallStarts.add(p.toolCallId);
           } else if (part.type === "tool-call-delta") {
             const p = part;
             await writeSSE(JSON.stringify({
@@ -4146,11 +5805,23 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
               argsTextDelta: p.argsTextDelta
             }));
           } else if (part.type === "tool-call") {
+            await emitSyntheticToolStreaming(
+              writeSSE,
+              toolCallStarts,
+              part.toolCallId,
+              part.toolName,
+              part.input
+            );
             await writeSSE(JSON.stringify({
               type: "tool-input-available",
               toolCallId: part.toolCallId,
               toolName: part.toolName,
-              input: part.input
+              input: sanitizeToolInput(part.toolName, part.input)
+            }));
+            await writeSSE(JSON.stringify({
+              type: "debug",
+              label: "tool-input-available",
+              toolName: part.toolName
             }));
           } else if (part.type === "tool-result") {
             await writeSSE(JSON.stringify({
@@ -4177,14 +5848,20 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
         } else {
           await writeSSE(JSON.stringify({ type: "finish" }));
         }
-        activeStreamQueries.finish(streamId);
+        try {
+          activeStreamQueries.finish(streamId);
+        } catch {
+        }
       } catch (error) {
         if (error.name === "AbortError" || error.message?.includes("aborted")) {
           await writeSSE(JSON.stringify({ type: "abort" }));
         } else {
           console.error("Agent error:", error);
           await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
-          activeStreamQueries.markError(streamId);
+          try {
+            activeStreamQueries.markError(streamId);
+          } catch {
+          }
         }
       } finally {
         cleanupAbortController();
@@ -4200,19 +5877,74 @@ agents.post(
   zValidator2("json", runPromptSchema),
   async (c) => {
     const id = c.req.param("id");
-    const { prompt } = c.req.valid("json");
+    const { prompt, attachments } = c.req.valid("json");
     const session = sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
     const nextSequence = messageQueries.getNextSequence(id);
     await createCheckpoint(id, session.workingDirectory, nextSequence);
-    messageQueries.create(id, { role: "user", content: prompt });
-    const streamId = `stream_${id}_${nanoid4(10)}`;
+    let userMessageContent;
+    const streamAttachments = attachments;
+    if (streamAttachments && streamAttachments.length > 0) {
+      for (let i = 0; i < streamAttachments.length; i++) {
+        const attachment = streamAttachments[i];
+        try {
+          const savedPath = saveAttachmentToDisk(id, attachment, i);
+          attachment.savedPath = savedPath;
+        } catch (err) {
+          console.error(`Failed to save attachment ${i}:`, err);
+        }
+      }
+      const contentParts = [];
+      const attachmentDescriptions = streamAttachments.map((a, i) => {
+        const name = a.filename || `attachment_${i + 1}`;
+        const typeLabel = a.type === "image" ? "Image" : "File";
+        const location = a.savedPath || "(path unknown)";
+        return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+      }).join("\n");
+      contentParts.push({
+        type: "text",
+        text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+      });
+      if (prompt) {
+        contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+      }
+      for (const attachment of streamAttachments) {
+        if (attachment.type === "image") {
+          contentParts.push({
+            type: "image",
+            image: attachment.data,
+            // base64 data URL or raw base64
+            mediaType: attachment.mediaType,
+            filename: attachment.filename,
+            savedPath: attachment.savedPath
+          });
+        } else {
+          contentParts.push({
+            type: "file",
+            data: attachment.data,
+            mediaType: attachment.mediaType || "application/octet-stream",
+            filename: attachment.filename,
+            savedPath: attachment.savedPath
+          });
+        }
+      }
+      userMessageContent = contentParts;
+    } else {
+      userMessageContent = prompt;
+    }
+    messageQueries.create(id, { role: "user", content: userMessageContent });
+    const streamId = `stream_${id}_${nanoid6(10)}`;
     activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
-      createAgentStreamProducer(id, prompt, streamId)
+      createAgentStreamProducer(id, prompt, streamId, streamAttachments)
     );
     if (!stream) {
       return c.json({ error: "Failed to create stream" }, 500);
@@ -4405,13 +6137,14 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
-    const streamId = `stream_${session.id}_${nanoid4(10)}`;
+    const streamId = `stream_${session.id}_${nanoid6(10)}`;
     await createCheckpoint(session.id, session.workingDirectory, 0);
     activeStreamQueries.create(session.id, streamId);
     const createQuickStreamProducer = () => {
       const { readable, writable } = new TransformStream();
       const writer = writable.getWriter();
       let writerClosed = false;
+      const toolCallStarts = /* @__PURE__ */ new Set();
       const abortController = new AbortController();
       streamAbortControllers.set(streamId, abortController);
       const writeSSE = async (data) => {
@@ -4457,11 +6190,32 @@ agents.post(
             abortSignal: abortController.signal,
             // Use our managed abort controller, NOT client signal
             onToolProgress: async (progress) => {
+              const status = progress.data?.status || "no-status";
+              const contentLength = typeof progress.data?.content === "string" ? progress.data.content.length : void 0;
+              const chunkIndex = progress.data?.chunkIndex;
+              const chunkCount = progress.data?.chunkCount;
+              console.log(
+                "[TOOL-PROGRESS] Sending:",
+                progress.toolName,
+                status,
+                contentLength !== void 0 ? `contentLength=${contentLength}` : "",
+                chunkIndex !== void 0 || chunkCount !== void 0 ? `chunk=${chunkIndex}/${chunkCount}` : ""
+              );
               await writeSSE(JSON.stringify({
                 type: "tool-progress",
                 toolName: progress.toolName,
                 data: progress.data
               }));
+              if (progress.toolName === "write_file" && status === "content") {
+                await writeSSE(JSON.stringify({
+                  type: "debug",
+                  label: "write-file-progress",
+                  contentLength,
+                  chunkIndex,
+                  chunkCount
+                }));
+                await new Promise((resolve10) => setTimeout(resolve10, 0));
+              }
             },
             onStepFinish: async () => {
               await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -4503,6 +6257,7 @@ agents.post(
                 toolCallId: p.toolCallId,
                 toolName: p.toolName
               }));
+              toolCallStarts.add(p.toolCallId);
             } else if (part.type === "tool-call-delta") {
               const p = part;
               await writeSSE(JSON.stringify({
@@ -4511,11 +6266,23 @@ agents.post(
                 argsTextDelta: p.argsTextDelta
               }));
             } else if (part.type === "tool-call") {
+              await emitSyntheticToolStreaming(
+                writeSSE,
+                toolCallStarts,
+                part.toolCallId,
+                part.toolName,
+                part.input
+              );
               await writeSSE(JSON.stringify({
                 type: "tool-input-available",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                input: part.input
+                input: sanitizeToolInput(part.toolName, part.input)
+              }));
+              await writeSSE(JSON.stringify({
+                type: "debug",
+                label: "tool-input-available",
+                toolName: part.toolName
               }));
             } else if (part.type === "tool-result") {
               await writeSSE(JSON.stringify({
@@ -4583,7 +6350,28 @@ agents.post(
 // src/server/routes/health.ts
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname6, join as join6 } from "path";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname6(__filename);
+var packageJsonPath = join6(__dirname, "../../../package.json");
+var currentVersion = "0.0.0";
+var packageName = "sparkecoder";
+try {
+  const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+  currentVersion = packageJson.version || "0.0.0";
+  packageName = packageJson.name || "sparkecoder";
+} catch {
+  try {
+    const devPackageJsonPath = join6(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync3(devPackageJsonPath, "utf-8"));
+    currentVersion = packageJson.version || "0.0.0";
+    packageName = packageJson.name || "sparkecoder";
+  } catch {
+  }
+}
 var health = new Hono3();
 health.get("/", async (c) => {
   const config = getConfig();
@@ -4592,7 +6380,7 @@ health.get("/", async (c) => {
   const hasApiKey = gatewayKey?.configured ?? false;
   return c.json({
     status: "ok",
-    version: "0.1.0",
+    version: currentVersion,
     uptime: process.uptime(),
     apiKeyConfigured: hasApiKey,
     config: {
@@ -4604,6 +6392,42 @@ health.get("/", async (c) => {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
 });
+health.get("/version", async (c) => {
+  let latestVersion = currentVersion;
+  let updateAvailable = false;
+  let error;
+  try {
+    const npmResponse = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { "Accept": "application/json" },
+      signal: AbortSignal.timeout(5e3)
+      // 5 second timeout
+    });
+    if (npmResponse.ok) {
+      const npmData = await npmResponse.json();
+      latestVersion = npmData.version || currentVersion;
+      const parseVersion = (v) => {
+        const parts = v.replace(/^v/, "").split(".").map(Number);
+        return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 };
+      };
+      const current = parseVersion(currentVersion);
+      const latest = parseVersion(latestVersion);
+      updateAvailable = latest.major > current.major || latest.major === current.major && latest.minor > current.minor || latest.major === current.major && latest.minor === current.minor && latest.patch > current.patch;
+    } else {
+      error = `npm registry returned ${npmResponse.status}`;
+    }
+  } catch (err) {
+    error = err instanceof Error ? err.message : "Failed to check for updates";
+  }
+  return c.json({
+    packageName,
+    currentVersion,
+    latestVersion,
+    updateAvailable,
+    updateCommand: updateAvailable ? `npm install -g ${packageName}@latest` : null,
+    error,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
 health.get("/ready", async (c) => {
   try {
     getConfig();
@@ -4629,9 +6453,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z11.object({
-  provider: z11.string(),
-  apiKey: z11.string().min(1)
+var setApiKeySchema = z13.object({
+  provider: z13.string(),
+  apiKey: z13.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -4670,12 +6494,12 @@ 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 z12 } from "zod";
+import { z as z14 } from "zod";
 var terminals2 = new Hono4();
-var spawnSchema = z12.object({
-  command: z12.string(),
-  cwd: z12.string().optional(),
-  name: z12.string().optional()
+var spawnSchema = z14.object({
+  command: z14.string(),
+  cwd: z14.string().optional(),
+  name: z14.string().optional()
 });
 terminals2.post(
   "/:sessionId/terminals",
@@ -4756,8 +6580,8 @@ terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z12.object({
-  tail: z12.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z14.object({
+  tail: z14.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals2.get(
   "/:sessionId/terminals/:terminalId/logs",
@@ -4781,8 +6605,8 @@ terminals2.get(
     });
   }
 );
-var killSchema = z12.object({
-  signal: z12.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z14.object({
+  signal: z14.enum(["SIGTERM", "SIGKILL"]).optional()
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/kill",
@@ -4796,8 +6620,8 @@ terminals2.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z12.object({
-  input: z12.string()
+var writeSchema = z14.object({
+  input: z14.string()
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/write",
@@ -4979,10 +6803,10 @@ data: ${JSON.stringify({ status: "stopped" })}
 });
 
 // src/utils/dependencies.ts
-import { exec as exec4 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
 import { platform as platform2 } from "os";
-var execAsync4 = promisify4(exec4);
+var execAsync5 = promisify5(exec5);
 function getInstallInstructions() {
   const os2 = platform2();
   if (os2 === "darwin") {
@@ -5015,7 +6839,7 @@ Install tmux:
 }
 async function checkTmux() {
   try {
-    const { stdout } = await execAsync4("tmux -V", { timeout: 5e3 });
+    const { stdout } = await execAsync5("tmux -V", { timeout: 5e3 });
     const version = stdout.trim();
     return {
       available: true,
@@ -5062,13 +6886,13 @@ var DEFAULT_WEB_PORT = 6969;
 var WEB_PORT_SEQUENCE = [6969, 6970, 6971, 6972, 6973, 6974, 6975, 6976, 6977, 6978];
 function getWebDirectory() {
   try {
-    const currentDir = dirname6(fileURLToPath2(import.meta.url));
-    const webDir = resolve8(currentDir, "..", "web");
-    if (existsSync10(webDir) && existsSync10(join3(webDir, "package.json"))) {
+    const currentDir = dirname7(fileURLToPath3(import.meta.url));
+    const webDir = resolve9(currentDir, "..", "web");
+    if (existsSync13(webDir) && existsSync13(join7(webDir, "package.json"))) {
       return webDir;
     }
-    const altWebDir = resolve8(currentDir, "..", "..", "web");
-    if (existsSync10(altWebDir) && existsSync10(join3(altWebDir, "package.json"))) {
+    const altWebDir = resolve9(currentDir, "..", "..", "web");
+    if (existsSync13(altWebDir) && existsSync13(join7(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -5091,18 +6915,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve9(true);
+        resolve10(true);
       } else {
-        resolve9(false);
+        resolve10(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve9(false);
+      resolve10(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -5126,30 +6950,30 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join3(webDir, ".next", "BUILD_ID");
-  return existsSync10(buildIdPath);
+  const buildIdPath = join7(webDir, ".next", "BUILD_ID");
+  return existsSync13(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join3(webDir, "src", "app");
-  const pagesDir = join3(webDir, "src", "pages");
-  const rootAppDir = join3(webDir, "app");
-  const rootPagesDir = join3(webDir, "pages");
-  return existsSync10(appDir) || existsSync10(pagesDir) || existsSync10(rootAppDir) || existsSync10(rootPagesDir);
+  const appDir = join7(webDir, "src", "app");
+  const pagesDir = join7(webDir, "src", "pages");
+  const rootAppDir = join7(webDir, "app");
+  const rootPagesDir = join7(webDir, "pages");
+  return existsSync13(appDir) || existsSync13(pagesDir) || existsSync13(rootAppDir) || existsSync13(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths = [
-    join3(webDir, ".next", "standalone", "server.js"),
-    join3(webDir, ".next", "standalone", "web", "server.js")
+    join7(webDir, ".next", "standalone", "server.js"),
+    join7(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths) {
-    if (existsSync10(serverPath)) {
+    if (existsSync13(serverPath)) {
       return serverPath;
     }
   }
   return null;
 }
 function runCommand(command, args, cwd, env) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -5164,10 +6988,10 @@ function runCommand(command, args, cwd, env) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve9({ success: code === 0, output });
+      resolve10({ success: code === 0, output });
     });
     child.on("error", (err) => {
-      resolve9({ success: false, output: err.message });
+      resolve10({ success: false, output: err.message });
     });
   });
 }
@@ -5182,15 +7006,15 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync10(join3(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync10(join3(webDir, "package-lock.json"));
+  const usePnpm = existsSync13(join7(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync13(join7(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
   const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join3(webDir, "runtime-config.json");
+  const runtimeConfigPath = join7(webDir, "runtime-config.json");
   try {
-    writeFileSync2(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
+    writeFileSync4(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
   } catch (err) {
     if (!quiet) console.warn(`  \u26A0 Could not write runtime config: ${err}`);
@@ -5210,13 +7034,13 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   if (standaloneServerPath) {
     command = "node";
     args = ["server.js"];
-    cwd = dirname6(standaloneServerPath);
+    cwd = dirname7(standaloneServerPath);
     webEnv.PORT = String(actualPort);
     webEnv.HOSTNAME = "0.0.0.0";
     if (!quiet) console.log("  \u{1F4E6} Starting Web UI from standalone build...");
   } else if (hasBuild && (isProduction || !hasSource)) {
     command = pkgManager;
-    args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start", "--", "-p", String(actualPort)];
+    args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start"];
   } else if (hasSource) {
     if (isProduction && !hasBuild) {
       if (!quiet) console.log("  \u{1F4E6} Building Web UI for production...");
@@ -5228,10 +7052,10 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
       }
       if (!quiet) console.log("  \u2713 Web UI build complete");
       command = pkgManager;
-      args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start", "--", "-p", String(actualPort)];
+      args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start"];
     } else {
       command = pkgManager;
-      args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev", "--", "-p", String(actualPort)];
+      args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev"];
     }
   } else {
     if (!quiet) {
@@ -5251,37 +7075,43 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   let started = false;
   let exited = false;
   let exitCode = null;
-  const startedPromise = new Promise((resolve9) => {
+  const startedPromise = new Promise((resolve10) => {
     const timeout = setTimeout(() => {
       if (!started && !exited) {
-        resolve9(false);
+        resolve10(false);
       }
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
       const output = data.toString();
+      if (!quiet) {
+        const lines = output.trim().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          console.log(`  Web UI: ${line}`);
+        }
+      }
       if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
         started = true;
         clearTimeout(timeout);
-        resolve9(true);
+        resolve10(true);
       }
     });
     child.stderr?.on("data", (data) => {
-      const output = data.toString();
-      if (output.toLowerCase().includes("error")) {
-        if (!quiet) console.error(`  Web UI error: ${output.trim().slice(0, 200)}`);
+      const output = data.toString().trim();
+      if (!quiet && output) {
+        console.error(`  Web UI: ${output.slice(0, 500)}`);
       }
     });
     child.on("error", (err) => {
       if (!quiet) console.error(`  \u274C Web UI spawn error: ${err.message}`);
       clearTimeout(timeout);
-      resolve9(false);
+      resolve10(false);
     });
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
       if (!started) {
         clearTimeout(timeout);
-        resolve9(false);
+        resolve10(false);
       }
       webUIProcess = null;
     });
@@ -5374,8 +7204,8 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync10(config.resolvedWorkingDirectory)) {
-    mkdirSync3(config.resolvedWorkingDirectory, { recursive: true });
+  if (!existsSync13(config.resolvedWorkingDirectory)) {
+    mkdirSync5(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   initDatabase(config.resolvedDatabasePath);