sparkecoder 0.1.22 → 0.1.23

package/dist/cli.js

@@ -1,10 +1,400 @@
 #!/usr/bin/env node
 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/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
@@ -18,19 +408,20 @@ 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 existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve8, dirname as dirname6, join as join5 } 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 { existsSync as existsSync10, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync, unlinkSync } from "fs";
-import { join as join3, basename as basename2, extname as extname5 } from "path";
-import { nanoid as nanoid4 } from "nanoid";
+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";
@@ -47,6 +438,7 @@ __export(schema_exports, {
   loadedSkills: () => loadedSkills,
   messages: () => messages,
   sessions: () => sessions,
+  subagentExecutions: () => subagentExecutions,
   terminals: () => terminals,
   todoItems: () => todoItems,
   toolExecutions: () => toolExecutions
@@ -150,6 +542,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;
@@ -254,6 +666,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);
@@ -263,6 +691,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;
 }
@@ -656,85 +1086,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()) {
@@ -814,20 +1308,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);
@@ -844,7 +1330,8 @@ function loadConfig(configPath, workingDirectory) {
     },
     resolvedWorkingDirectory,
     resolvedSkillsDirectories,
-    resolvedDatabasePath
+    resolvedDatabasePath,
+    discoveredSkills: discovered
   };
   cachedConfig = resolved;
   return resolved;
@@ -1272,8 +1759,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);
@@ -1877,12 +2364,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;
@@ -2172,7 +2659,7 @@ async function createClient(serverId, handle, root) {
     },
     async waitForDiagnostics(filePath, timeoutMs = 5e3) {
       const normalized = normalizePath(filePath);
-      return new Promise((resolve10) => {
+      return new Promise((resolve11) => {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
@@ -2191,7 +2678,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup();
-          resolve10(diagnostics.get(normalized) || []);
+          resolve11(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -2349,6 +2836,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'),
@@ -2392,24 +2880,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((resolve11) => setTimeout(resolve11, 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 }
@@ -2427,6 +2967,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)) {
@@ -2457,10 +3013,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,
@@ -2608,112 +3171,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')
@@ -2796,7 +3256,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({
@@ -2868,37 +3328,730 @@ Working directory: ${options.workingDirectory}`,
           if (!existsSync9(absolutePath)) {
             continue;
           }
-          const stats = await stat2(absolutePath);
-          if (stats.isDirectory()) {
-            const dirFiles = await findSupportedFiles(absolutePath, options.workingDirectory);
-            filesToCheck.push(...dirFiles);
-          } else if (stats.isFile()) {
-            if (isSupported(absolutePath)) {
-              filesToCheck.push(absolutePath);
+          const stats = await stat2(absolutePath);
+          if (stats.isDirectory()) {
+            const dirFiles = await findSupportedFiles(absolutePath, options.workingDirectory);
+            filesToCheck.push(...dirFiles);
+          } else if (stats.isFile()) {
+            if (isSupported(absolutePath)) {
+              filesToCheck.push(absolutePath);
+            }
+          }
+        }
+        if (filesToCheck.length === 0) {
+          return {
+            success: true,
+            message: "No supported files found to check. Supported extensions: " + getSupportedExtensions().join(", "),
+            files: [],
+            totalErrors: 0,
+            totalWarnings: 0
+          };
+        }
+        await Promise.all(
+          filesToCheck.map((file) => touchFile(file, true))
+        );
+        const diagnosticsMap = {};
+        for (const file of filesToCheck) {
+          const diagnostics = await getDiagnostics(file);
+          if (diagnostics.length > 0) {
+            diagnosticsMap[file] = diagnostics;
+          }
+        }
+        return formatDiagnosticsResult(diagnosticsMap, options.workingDirectory);
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatDiagnosticsResult(diagnosticsMap, workingDirectory) {
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalInfo = 0;
+  const files = [];
+  for (const [filePath, diagnostics] of Object.entries(diagnosticsMap)) {
+    const relativePath = relative5(workingDirectory, filePath);
+    let fileErrors = 0;
+    let fileWarnings = 0;
+    const formattedDiagnostics = diagnostics.map((d) => {
+      const severity = getSeverityString(d.severity);
+      if (d.severity === 1 /* Error */) {
+        fileErrors++;
+        totalErrors++;
+      } else if (d.severity === 2 /* Warning */) {
+        fileWarnings++;
+        totalWarnings++;
+      } else {
+        totalInfo++;
+      }
+      return {
+        severity,
+        line: d.range.start.line + 1,
+        column: d.range.start.character + 1,
+        message: d.message,
+        source: d.source,
+        code: d.code
+      };
+    });
+    files.push({
+      path: filePath,
+      relativePath,
+      errors: fileErrors,
+      warnings: fileWarnings,
+      diagnostics: formattedDiagnostics
+    });
+  }
+  files.sort((a, b) => b.errors - a.errors);
+  const hasIssues = totalErrors > 0 || totalWarnings > 0;
+  return {
+    success: true,
+    message: hasIssues ? `Found ${totalErrors} error(s) and ${totalWarnings} warning(s) in ${files.length} file(s).` : `No lint errors found in ${Object.keys(diagnosticsMap).length || "any"} file(s).`,
+    files,
+    totalErrors,
+    totalWarnings,
+    totalInfo,
+    summary: hasIssues ? formatSummary(files) : void 0
+  };
+}
+function getSeverityString(severity) {
+  switch (severity) {
+    case 1 /* Error */:
+      return "error";
+    case 2 /* Warning */:
+      return "warning";
+    case 3 /* Information */:
+      return "info";
+    case 4 /* Hint */:
+      return "hint";
+    default:
+      return "error";
+  }
+}
+function formatSummary(files) {
+  const lines = [];
+  for (const file of files) {
+    lines.push(`
+${file.relativePath}:`);
+    for (const d of file.diagnostics.slice(0, 10)) {
+      const prefix = d.severity === "error" ? "\u274C" : d.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+      lines.push(`  ${prefix} [${d.line}:${d.column}] ${d.message}`);
+    }
+    if (file.diagnostics.length > 10) {
+      lines.push(`  ... and ${file.diagnostics.length - 10} more`);
+    }
+  }
+  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((resolve11) => {
+          resolveNext = resolve11;
+        });
+        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`
+          });
         }
-        if (filesToCheck.length === 0) {
+      }
+    }
+    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: true,
-            message: "No supported files found to check. Supported extensions: " + getSupportedExtensions().join(", "),
-            files: [],
-            totalErrors: 0,
-            totalWarnings: 0
+            success: false,
+            error: result.error || "Search failed",
+            executionId: result.executionId
           };
         }
-        await Promise.all(
-          filesToCheck.map((file) => touchFile(file, true))
-        );
-        const diagnosticsMap = {};
-        for (const file of filesToCheck) {
-          const diagnostics = await getDiagnostics(file);
-          if (diagnostics.length > 0) {
-            diagnosticsMap[file] = diagnostics;
+        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})` : ""}
+`;
+            }
           }
         }
-        return formatDiagnosticsResult(diagnosticsMap, options.workingDirectory);
+        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
@@ -2907,84 +4060,6 @@ Working directory: ${options.workingDirectory}`,
     }
   });
 }
-function formatDiagnosticsResult(diagnosticsMap, workingDirectory) {
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  let totalInfo = 0;
-  const files = [];
-  for (const [filePath, diagnostics] of Object.entries(diagnosticsMap)) {
-    const relativePath = relative4(workingDirectory, filePath);
-    let fileErrors = 0;
-    let fileWarnings = 0;
-    const formattedDiagnostics = diagnostics.map((d) => {
-      const severity = getSeverityString(d.severity);
-      if (d.severity === 1 /* Error */) {
-        fileErrors++;
-        totalErrors++;
-      } else if (d.severity === 2 /* Warning */) {
-        fileWarnings++;
-        totalWarnings++;
-      } else {
-        totalInfo++;
-      }
-      return {
-        severity,
-        line: d.range.start.line + 1,
-        column: d.range.start.character + 1,
-        message: d.message,
-        source: d.source,
-        code: d.code
-      };
-    });
-    files.push({
-      path: filePath,
-      relativePath,
-      errors: fileErrors,
-      warnings: fileWarnings,
-      diagnostics: formattedDiagnostics
-    });
-  }
-  files.sort((a, b) => b.errors - a.errors);
-  const hasIssues = totalErrors > 0 || totalWarnings > 0;
-  return {
-    success: true,
-    message: hasIssues ? `Found ${totalErrors} error(s) and ${totalWarnings} warning(s) in ${files.length} file(s).` : `No lint errors found in ${Object.keys(diagnosticsMap).length || "any"} file(s).`,
-    files,
-    totalErrors,
-    totalWarnings,
-    totalInfo,
-    summary: hasIssues ? formatSummary(files) : void 0
-  };
-}
-function getSeverityString(severity) {
-  switch (severity) {
-    case 1 /* Error */:
-      return "error";
-    case 2 /* Warning */:
-      return "warning";
-    case 3 /* Information */:
-      return "info";
-    case 4 /* Hint */:
-      return "hint";
-    default:
-      return "error";
-  }
-}
-function formatSummary(files) {
-  const lines = [];
-  for (const file of files) {
-    lines.push(`
-${file.relativePath}:`);
-    for (const d of file.diagnostics.slice(0, 10)) {
-      const prefix = d.severity === "error" ? "\u274C" : d.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
-      lines.push(`  ${prefix} [${d.line}:${d.column}] ${d.message}`);
-    }
-    if (file.diagnostics.length > 10) {
-      lines.push(`  ... and ${file.diagnostics.length - 10} more`);
-    }
-  }
-  return lines.join("\n");
-}
 
 // src/tools/index.ts
 function createTools(options) {
@@ -3001,7 +4076,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
@@ -3012,15 +4088,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;
@@ -3039,9 +4120,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";
@@ -3062,6 +4167,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.
@@ -3138,6 +4244,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:
@@ -3149,6 +4258,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:
@@ -3171,11 +4304,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.
@@ -3188,8 +4321,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}
@@ -3284,8 +4423,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;
@@ -3355,7 +4494,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
     });
   }
   /**
@@ -3464,28 +4605,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);
       },
@@ -3515,26 +4661,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);
@@ -3556,11 +4705,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,
@@ -3572,8 +4721,8 @@ ${prompt}` });
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve10) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve10, sessionId: this.session.id });
+          const approved = await new Promise((resolve11) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve11, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
@@ -3668,18 +4817,18 @@ ${prompt}` });
 
 // 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(
   "/",
@@ -3818,10 +4967,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",
@@ -4020,11 +5169,11 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
 });
 function getAttachmentsDir(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join3(appDataDir, "attachments", sessionId);
+  return join4(appDataDir, "attachments", sessionId);
 }
 function ensureAttachmentsDir(sessionId) {
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   return dir;
@@ -4036,12 +5185,12 @@ sessions2.get("/:id/attachments", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     return c.json({ sessionId, attachments: [], count: 0 });
   }
   const files = readdirSync(dir);
   const attachments = files.map((filename) => {
-    const filePath = join3(dir, filename);
+    const filePath = join4(dir, filename);
     const stats = statSync(filePath);
     return {
       id: filename.split("_")[0],
@@ -4073,10 +5222,10 @@ sessions2.post("/:id/attachments", async (c) => {
         return c.json({ error: "No file provided" }, 400);
       }
       const dir = ensureAttachmentsDir(sessionId);
-      const id = nanoid4(10);
-      const ext = extname5(file.name) || "";
+      const id = nanoid5(10);
+      const ext = extname6(file.name) || "";
       const safeFilename = `${id}_${basename2(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const filePath = join3(dir, safeFilename);
+      const filePath = join4(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
       writeFileSync2(filePath, Buffer.from(arrayBuffer));
       return c.json({
@@ -4099,10 +5248,10 @@ sessions2.post("/:id/attachments", async (c) => {
       return c.json({ error: "Missing filename or data" }, 400);
     }
     const dir = ensureAttachmentsDir(sessionId);
-    const id = nanoid4(10);
-    const ext = extname5(body.filename) || "";
+    const id = nanoid5(10);
+    const ext = extname6(body.filename) || "";
     const safeFilename = `${id}_${basename2(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-    const filePath = join3(dir, safeFilename);
+    const filePath = join4(dir, safeFilename);
     let base64Data = body.data;
     if (base64Data.includes(",")) {
       base64Data = base64Data.split(",")[1];
@@ -4131,7 +5280,7 @@ sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     return c.json({ error: "Attachment not found" }, 404);
   }
   const files = readdirSync(dir);
@@ -4139,17 +5288,154 @@ sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
   if (!file) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const filePath = join3(dir, file);
+  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 { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+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";
@@ -4224,41 +5510,107 @@ var streamContext = createResumableStreamContext({
 });
 
 // src/server/routes/agents.ts
-import { nanoid as nanoid5 } 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((resolve11) => setTimeout(resolve11, 0));
+  }
+}
 var agents = new Hono2();
-var attachmentSchema = z10.object({
-  type: z10.enum(["image", "file"]),
-  data: z10.string(),
+var attachmentSchema = z12.object({
+  type: z12.enum(["image", "file"]),
+  data: z12.string(),
   // base64 data URL or raw base64
-  mediaType: z10.string().optional(),
-  filename: z10.string().optional()
+  mediaType: z12.string().optional(),
+  filename: z12.string().optional()
 });
-var runPromptSchema = z10.object({
-  prompt: z10.string(),
+var runPromptSchema = z12.object({
+  prompt: z12.string(),
   // Can be empty if attachments are provided
-  attachments: z10.array(attachmentSchema).optional()
+  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 = 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 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 getAttachmentsDirectory(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join4(appDataDir, "attachments", sessionId);
+  return join5(appDataDir, "attachments", sessionId);
 }
 function saveAttachmentToDisk(sessionId, attachment, index) {
   const attachmentsDir = getAttachmentsDirectory(sessionId);
-  if (!existsSync11(attachmentsDir)) {
+  if (!existsSync12(attachmentsDir)) {
     mkdirSync4(attachmentsDir, { recursive: true });
   }
   let filename = attachment.filename;
@@ -4270,7 +5622,7 @@ function saveAttachmentToDisk(sessionId, attachment, index) {
   if (base64Data.includes(",")) {
     base64Data = base64Data.split(",")[1];
   }
-  const filePath = join4(attachmentsDir, filename);
+  const filePath = join5(attachmentsDir, filename);
   const buffer = Buffer.from(base64Data, "base64");
   writeFileSync3(filePath, buffer);
   return filePath;
@@ -4303,6 +5655,7 @@ function createAgentStreamProducer(sessionId, prompt, streamId, attachments) {
     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) => {
@@ -4411,11 +5764,32 @@ ${prompt}` });
             }));
           },
           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((resolve11) => setTimeout(resolve11, 0));
+            }
           },
           onStepFinish: async () => {
             await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -4457,6 +5831,7 @@ ${prompt}` });
               toolCallId: p.toolCallId,
               toolName: p.toolName
             }));
+            toolCallStarts.add(p.toolCallId);
           } else if (part.type === "tool-call-delta") {
             const p = part;
             await writeSSE(JSON.stringify({
@@ -4465,11 +5840,23 @@ ${prompt}` });
               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({
@@ -4588,7 +5975,7 @@ ${prompt}` });
       userMessageContent = prompt;
     }
     messageQueries.create(id, { role: "user", content: userMessageContent });
-    const streamId = `stream_${id}_${nanoid5(10)}`;
+    const streamId = `stream_${id}_${nanoid6(10)}`;
     activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
@@ -4785,13 +6172,14 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
-    const streamId = `stream_${session.id}_${nanoid5(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) => {
@@ -4837,11 +6225,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((resolve11) => setTimeout(resolve11, 0));
+              }
             },
             onStepFinish: async () => {
               await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -4883,6 +6292,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({
@@ -4891,11 +6301,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({
@@ -4963,7 +6385,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();
@@ -4972,7 +6415,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: {
@@ -4984,6 +6427,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();
@@ -5009,9 +6488,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",
@@ -5050,12 +6529,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",
@@ -5136,8 +6615,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",
@@ -5161,8 +6640,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",
@@ -5176,8 +6655,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",
@@ -5359,10 +6838,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") {
@@ -5395,7 +6874,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,
@@ -5439,21 +6918,21 @@ async function tryAutoInstallTmux() {
   try {
     if (os2 === "darwin") {
       try {
-        await execAsync4("which brew", { timeout: 5e3 });
+        await execAsync5("which brew", { timeout: 5e3 });
       } catch {
         return false;
       }
       console.log("\u{1F4E6} Installing tmux via Homebrew...");
-      await execAsync4("brew install tmux", { timeout: 3e5 });
+      await execAsync5("brew install tmux", { timeout: 3e5 });
       console.log("\u2705 tmux installed successfully");
       return true;
     }
     if (os2 === "linux") {
       try {
-        await execAsync4("which apt-get", { timeout: 5e3 });
+        await execAsync5("which apt-get", { timeout: 5e3 });
         console.log("\u{1F4E6} Installing tmux via apt-get...");
         console.log("   (This may require sudo password)");
-        await execAsync4("sudo apt-get update && sudo apt-get install -y tmux", {
+        await execAsync5("sudo apt-get update && sudo apt-get install -y tmux", {
           timeout: 3e5
         });
         console.log("\u2705 tmux installed successfully");
@@ -5461,9 +6940,9 @@ async function tryAutoInstallTmux() {
       } catch {
       }
       try {
-        await execAsync4("which dnf", { timeout: 5e3 });
+        await execAsync5("which dnf", { timeout: 5e3 });
         console.log("\u{1F4E6} Installing tmux via dnf...");
-        await execAsync4("sudo dnf install -y tmux", { timeout: 3e5 });
+        await execAsync5("sudo dnf install -y tmux", { timeout: 3e5 });
         console.log("\u2705 tmux installed successfully");
         return true;
       } catch {
@@ -5497,13 +6976,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 (existsSync12(webDir) && existsSync12(join5(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 (existsSync12(altWebDir) && existsSync12(join5(altWebDir, "package.json"))) {
+    const altWebDir = resolve9(currentDir, "..", "..", "web");
+    if (existsSync13(altWebDir) && existsSync13(join7(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -5526,18 +7005,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve10(true);
+        resolve11(true);
       } else {
-        resolve10(false);
+        resolve11(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve10(false);
+      resolve11(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -5561,30 +7040,30 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join5(webDir, ".next", "BUILD_ID");
-  return existsSync12(buildIdPath);
+  const buildIdPath = join7(webDir, ".next", "BUILD_ID");
+  return existsSync13(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join5(webDir, "src", "app");
-  const pagesDir = join5(webDir, "src", "pages");
-  const rootAppDir = join5(webDir, "app");
-  const rootPagesDir = join5(webDir, "pages");
-  return existsSync12(appDir) || existsSync12(pagesDir) || existsSync12(rootAppDir) || existsSync12(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 = [
-    join5(webDir, ".next", "standalone", "server.js"),
-    join5(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 (existsSync12(serverPath)) {
+    if (existsSync13(serverPath)) {
       return serverPath;
     }
   }
   return null;
 }
 function runCommand(command, args, cwd, env) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -5599,10 +7078,10 @@ function runCommand(command, args, cwd, env) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve10({ success: code === 0, output });
+      resolve11({ success: code === 0, output });
     });
     child.on("error", (err) => {
-      resolve10({ success: false, output: err.message });
+      resolve11({ success: false, output: err.message });
     });
   });
 }
@@ -5617,13 +7096,13 @@ 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 = existsSync12(join5(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync12(join5(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 = join5(webDir, "runtime-config.json");
+  const runtimeConfigPath = join7(webDir, "runtime-config.json");
   try {
     writeFileSync4(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
@@ -5645,7 +7124,7 @@ 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...");
@@ -5686,10 +7165,10 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   let started = false;
   let exited = false;
   let exitCode = null;
-  const startedPromise = new Promise((resolve10) => {
+  const startedPromise = new Promise((resolve11) => {
     const timeout = setTimeout(() => {
       if (!started && !exited) {
-        resolve10(false);
+        resolve11(false);
       }
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
@@ -5703,7 +7182,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
       if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
         started = true;
         clearTimeout(timeout);
-        resolve10(true);
+        resolve11(true);
       }
     });
     child.stderr?.on("data", (data) => {
@@ -5715,14 +7194,14 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     child.on("error", (err) => {
       if (!quiet) console.error(`  \u274C Web UI spawn error: ${err.message}`);
       clearTimeout(timeout);
-      resolve10(false);
+      resolve11(false);
     });
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
       if (!started) {
         clearTimeout(timeout);
-        resolve10(false);
+        resolve11(false);
       }
       webUIProcess = null;
     });
@@ -5815,7 +7294,7 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync12(config.resolvedWorkingDirectory)) {
+  if (!existsSync13(config.resolvedWorkingDirectory)) {
     mkdirSync5(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
@@ -6319,8 +7798,8 @@ function generateOpenAPISpec() {
 }
 
 // src/cli.ts
-import { writeFileSync as writeFileSync5, existsSync as existsSync13 } from "fs";
-import { resolve as resolve9, join as join6 } from "path";
+import { writeFileSync as writeFileSync5, existsSync as existsSync14 } from "fs";
+import { resolve as resolve10, join as join8 } from "path";
 async function apiRequest(baseUrl, path, options = {}) {
   const url = `${baseUrl}${path}`;
   const init = {
@@ -6355,13 +7834,13 @@ async function getActiveStream(baseUrl, sessionId) {
   return { hasActiveStream: false };
 }
 function promptApproval(rl, toolName, input) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const inputStr = JSON.stringify(input);
     const truncatedInput = inputStr.length > 100 ? inputStr.slice(0, 100) + "..." : inputStr;
     console.log(chalk.dim(`    Command: ${truncatedInput}`));
     rl.question(chalk.yellow(`    Approve? [y/n]: `), (answer) => {
       const approved = answer.toLowerCase().startsWith("y");
-      resolve10(approved);
+      resolve11(approved);
     });
   });
 }
@@ -6544,9 +8023,9 @@ async function runChat(options) {
         input: process.stdin,
         output: process.stdout
       });
-      const apiKey = await new Promise((resolve10) => {
+      const apiKey = await new Promise((resolve11) => {
         keyRl.question(chalk.cyan("Enter your AI Gateway API key: "), (answer) => {
-          resolve10(answer.trim());
+          resolve11(answer.trim());
         });
       });
       keyRl.close();
@@ -6877,13 +8356,13 @@ program.command("init").description("Create a sparkecoder.config.json file").opt
   let configLocation;
   if (options.global) {
     const appDataDir = ensureAppDataDirectory();
-    configPath = join6(appDataDir, "sparkecoder.config.json");
+    configPath = join8(appDataDir, "sparkecoder.config.json");
     configLocation = "global";
   } else {
-    configPath = resolve9(process.cwd(), "sparkecoder.config.json");
+    configPath = resolve10(process.cwd(), "sparkecoder.config.json");
     configLocation = "local";
   }
-  if (existsSync13(configPath) && !options.force) {
+  if (existsSync14(configPath) && !options.force) {
     console.log(chalk.yellow("Config file already exists. Use --force to overwrite."));
     console.log(chalk.dim(`  ${configPath}`));
     return;