sparkecoder 0.1.22 → 0.1.23

package/dist/agent/index.js

@@ -1,13 +1,426 @@
+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/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/db/index.ts
 import Database from "better-sqlite3";
@@ -115,6 +528,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;
@@ -420,69 +853,70 @@ 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/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
 function getAppDataDirectory() {
   const appName = "sparkecoder";
   switch (platform()) {
@@ -1228,12 +1662,12 @@ function findNearestRoot(startDir, markers) {
 }
 async function commandExists(cmd) {
   try {
-    const { exec: exec4 } = await import("child_process");
-    const { promisify: promisify4 } = await import("util");
-    const execAsync4 = promisify4(exec4);
+    const { exec: exec5 } = await import("child_process");
+    const { promisify: promisify5 } = await import("util");
+    const execAsync5 = promisify5(exec5);
     const isWindows = process.platform === "win32";
     const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
-    await execAsync4(checkCmd);
+    await execAsync5(checkCmd);
     return true;
   } catch {
     return false;
@@ -1523,7 +1957,7 @@ async function createClient(serverId, handle, root) {
     },
     async waitForDiagnostics(filePath, timeoutMs = 5e3) {
       const normalized = normalizePath(filePath);
-      return new Promise((resolve8) => {
+      return new Promise((resolve9) => {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
@@ -1542,7 +1976,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup();
-          resolve8(diagnostics.get(normalized) || []);
+          resolve9(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -1700,6 +2134,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'),
@@ -1743,24 +2178,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((resolve9) => setTimeout(resolve9, 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 }
@@ -1778,6 +2265,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)) {
@@ -1808,10 +2311,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,
@@ -1959,112 +2469,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')
@@ -2147,7 +2554,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({
@@ -2264,7 +2671,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) => {
@@ -2337,6 +2744,621 @@ ${file.relativePath}:`);
   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((resolve9) => {
+          resolveNext = resolve9;
+        });
+        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
 function createTools(options) {
   return {
@@ -2352,7 +3374,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
@@ -2363,15 +3386,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 platform2 = process.platform;
@@ -2390,9 +3418,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 platform2 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
@@ -2413,6 +3465,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.
@@ -2489,6 +3542,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:
@@ -2500,6 +3556,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:
@@ -2522,11 +3602,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.
@@ -2539,8 +3619,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}
@@ -2635,8 +3721,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;
@@ -2706,7 +3792,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
     });
   }
   /**
@@ -2815,28 +3903,33 @@ ${prompt}` });
     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);
       },
@@ -2866,26 +3959,29 @@ ${prompt}` });
     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);
@@ -2907,11 +4003,11 @@ ${prompt}` });
         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,
@@ -2923,8 +4019,8 @@ ${prompt}` });
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve8) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve8, sessionId: this.session.id });
+          const approved = await new Promise((resolve9) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve9, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);