sparkecoder 0.1.120 → 0.1.122

package/dist/cli.js

@@ -964,6 +964,7 @@ __export(config_exports, {
   setApiKey: () => setApiKey,
   setMcpServers: () => setMcpServers,
   setPublicUrl: () => setPublicUrl,
+  setSkillsAdditionalDirectories: () => setSkillsAdditionalDirectories,
   setSlackConfig: () => setSlackConfig,
   setWebhookToken: () => setWebhookToken
 });
@@ -1253,6 +1254,40 @@ function setWebhookToken(token) {
     console.warn("[config] failed to persist webhook token:", err?.message || err);
   }
 }
+function setSkillsAdditionalDirectories(directories) {
+  if (cachedConfig) {
+    const cur = cachedConfig.skills || {};
+    cachedConfig.skills = { ...cur, additionalDirectories: directories };
+    try {
+      const discovered = discoverSkillDirectories(cachedConfig.resolvedWorkingDirectory);
+      const additionalAbs = directories.map((d) => resolve(cachedConfig.resolvedWorkingDirectory, d)).filter((d) => existsSync(d));
+      cachedConfig.discoveredSkills = discovered;
+      cachedConfig.resolvedSkillsDirectories = [
+        ...discovered.allDirectories,
+        ...additionalAbs
+      ];
+    } catch {
+    }
+  }
+  try {
+    const cwdPath = resolve(process.cwd(), "sparkecoder.config.json");
+    const target = existsSync(cwdPath) ? cwdPath : join(ensureAppDataDirectory(), "sparkecoder.config.json");
+    let raw = {};
+    if (existsSync(target)) {
+      try {
+        raw = JSON.parse(readFileSync(target, "utf-8"));
+      } catch {
+        raw = {};
+      }
+    } else {
+      raw = createDefaultConfig();
+    }
+    raw.skills = { ...raw.skills || {}, additionalDirectories: directories };
+    writeFileSync(target, JSON.stringify(raw, null, 2));
+  } catch (err) {
+    console.warn("[config] failed to persist skill directories:", err?.message || err);
+  }
+}
 function setPublicUrl(publicUrl) {
   if (cachedConfig) {
     cachedConfig.server = { ...cachedConfig.server ?? {}, publicUrl };
@@ -2295,10 +2330,10 @@ async function resizeImageIfNeeded(buffer, mediaType) {
   const willConvertToJpeg = isPng && (needsShrink || buffer.length > 2 * 1024 * 1024);
   const outputMediaType = willConvertToJpeg || !isPng ? "image/jpeg" : "image/png";
   const ext = outputMediaType === "image/png" ? ".png" : ".jpg";
-  const cachePath = join3(cacheDir, key2 + ext);
-  if (existsSync3(cachePath)) {
+  const cachePath2 = join3(cacheDir, key2 + ext);
+  if (existsSync3(cachePath2)) {
     console.log(`[image-resize] Cache hit for ${width}x${height} image`);
-    return { buffer: readFileSync2(cachePath), mediaType: outputMediaType };
+    return { buffer: readFileSync2(cachePath2), mediaType: outputMediaType };
   }
   let pipeline = sharp(buffer);
   if (needsResize) {
@@ -2323,7 +2358,7 @@ async function resizeImageIfNeeded(buffer, mediaType) {
     }
     finalMediaType = "image/jpeg";
   }
-  writeFileSync2(cachePath, result);
+  writeFileSync2(cachePath2, result);
   const resultMeta = await sharp(result).metadata();
   console.log(
     `[image-resize] ${width}x${height} -> ${resultMeta.width}x${resultMeta.height} (${(buffer.length / 1024).toFixed(0)}KB -> ${(result.length / 1024).toFixed(0)}KB, ${finalMediaType})`
@@ -3014,7 +3049,7 @@ async function createClient(serverId, handle, root) {
     },
     async waitForDiagnostics(filePath, timeoutMs = 5e3) {
       const normalized = normalizePath(filePath);
-      return new Promise((resolve13) => {
+      return new Promise((resolve14) => {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
@@ -3033,7 +3068,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup2();
-          resolve13(diagnostics.get(normalized) || []);
+          resolve14(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -3408,7 +3443,7 @@ Working directory: ${options.workingDirectory}`,
                 isChunked: true
               });
               if (chunkCount > 1) {
-                await new Promise((resolve13) => setTimeout(resolve13, 0));
+                await new Promise((resolve14) => setTimeout(resolve14, 0));
               }
             }
           }
@@ -4027,7 +4062,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
   if (!existsSync10(directory)) {
     return [];
   }
-  const skills = [];
+  const skills2 = [];
   const entries = await readdir(directory, { withFileTypes: true });
   for (const entry2 of entries) {
     let filePath;
@@ -4051,7 +4086,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     if (parsed) {
       const alwaysApply = forceAlwaysApply || parsed.metadata.alwaysApply;
       const loadType = alwaysApply ? "always" : defaultLoadType;
-      skills.push({
+      skills2.push({
         name: parsed.metadata.name,
         description: parsed.metadata.description,
         filePath,
@@ -4065,7 +4100,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     } else {
       const name = getSkillNameFromPath(filePath);
       const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
-      skills.push({
+      skills2.push({
         name,
         description: firstParagraph.replace(/^#\s*/, "").trim(),
         filePath,
@@ -4078,7 +4113,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
       });
     }
   }
-  return skills.filter(
+  return skills2.filter(
     (s) => s.platforms.length === 0 || s.platforms.includes(process.platform)
   );
 }
@@ -4086,8 +4121,8 @@ 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) {
+    const skills2 = await loadSkillsFromDirectory(dir);
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4100,12 +4135,12 @@ async function loadAllSkillsFromDiscovered(discovered) {
   const allSkills = [];
   const seenNames = /* @__PURE__ */ new Set();
   for (const { path, priority } of discovered.alwaysLoadedDirs) {
-    const skills = await loadSkillsFromDirectory(path, {
+    const skills2 = await loadSkillsFromDirectory(path, {
       priority,
       defaultLoadType: "always",
       forceAlwaysApply: true
     });
-    for (const skill of skills) {
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4113,12 +4148,12 @@ async function loadAllSkillsFromDiscovered(discovered) {
     }
   }
   for (const { path, priority } of discovered.onDemandDirs) {
-    const skills = await loadSkillsFromDirectory(path, {
+    const skills2 = await loadSkillsFromDirectory(path, {
       priority,
       defaultLoadType: "on_demand",
       forceAlwaysApply: false
     });
-    for (const skill of skills) {
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4143,7 +4178,7 @@ async function loadAllSkillsFromDiscovered(discovered) {
     all: allSkills
   };
 }
-async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
+async function getGlobMatchedSkills(skills2, activeFiles, workingDirectory) {
   if (activeFiles.length === 0) {
     return [];
   }
@@ -4153,7 +4188,7 @@ async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
     }
     return f;
   });
-  const matchedSkills = skills.filter((skill) => {
+  const matchedSkills = skills2.filter((skill) => {
     if (skill.alwaysApply || skill.loadType === "always") {
       return false;
     }
@@ -4199,8 +4234,8 @@ async function loadSkillContent(skillName, directories) {
     content: parsed ? parsed.body : content
   };
 }
-function formatSkillsForContext(skills) {
-  const onDemandSkills = skills.filter((s) => !s.alwaysApply && s.loadType !== "always");
+function formatSkillsForContext(skills2) {
+  const onDemandSkills = skills2.filter((s) => !s.alwaysApply && s.loadType !== "always");
   if (onDemandSkills.length === 0) {
     return "No on-demand skills available.";
   }
@@ -4211,12 +4246,12 @@ function formatSkillsForContext(skills) {
   }
   return lines.join("\n");
 }
-function formatAlwaysLoadedSkills(skills) {
-  if (skills.length === 0) {
+function formatAlwaysLoadedSkills(skills2) {
+  if (skills2.length === 0) {
     return "";
   }
   const sections = [];
-  for (const skill of skills) {
+  for (const skill of skills2) {
     sections.push(`### ${skill.name}
 
 ${skill.content}`);
@@ -4225,12 +4260,12 @@ ${skill.content}`);
 
 ${sections.join("\n\n---\n\n")}`;
 }
-function formatGlobMatchedSkills(skills) {
-  if (skills.length === 0) {
+function formatGlobMatchedSkills(skills2) {
+  if (skills2.length === 0) {
     return "";
   }
   const sections = [];
-  for (const skill of skills) {
+  for (const skill of skills2) {
     sections.push(`### ${skill.name}
 
 ${skill.content}`);
@@ -4272,16 +4307,16 @@ Once loaded, a skill's content will be available in the conversation context.`,
       try {
         switch (action) {
           case "list": {
-            const skills = await loadAllSkills(options.skillsDirectories);
+            const skills2 = await loadAllSkills(options.skillsDirectories);
             return {
               success: true,
               action: "list",
-              skillCount: skills.length,
-              skills: skills.map((s) => ({
+              skillCount: skills2.length,
+              skills: skills2.map((s) => ({
                 name: s.name,
                 description: s.description
               })),
-              formatted: formatSkillsForContext(skills)
+              formatted: formatSkillsForContext(skills2)
             };
           }
           case "load": {
@@ -4719,8 +4754,8 @@ var init_subagent = __esm({
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else if (!done) {
-            const event = await new Promise((resolve13) => {
-              resolveNext = resolve13;
+            const event = await new Promise((resolve14) => {
+              resolveNext = resolve14;
             });
             if (event) {
               yield event;
@@ -5362,7 +5397,7 @@ function formatError(error) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function isPathExcluded(relativePath, exclude) {
   return exclude.some((pattern) => {
@@ -5380,7 +5415,7 @@ function isPathExcluded(relativePath, exclude) {
 }
 async function walkDirectory(dir, include, exclude, baseDir) {
   const { readdirSync: readdirSync4 } = await import("fs");
-  const { join: join17, relative: relative10 } = await import("path");
+  const { join: join19, relative: relative10 } = await import("path");
   const files = [];
   function walk(currentDir) {
     let entries;
@@ -5390,7 +5425,7 @@ async function walkDirectory(dir, include, exclude, baseDir) {
       return;
     }
     for (const entry2 of entries) {
-      const fullPath = join17(currentDir, entry2.name);
+      const fullPath = join19(currentDir, entry2.name);
       const relativePath = relative10(baseDir, fullPath);
       if (isPathExcluded(relativePath, exclude)) {
         continue;
@@ -7238,8 +7273,8 @@ async function buildSystemPrompt(options) {
     }
   } else {
     const { loadAllSkills: loadAllSkills2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
-    const skills = await loadAllSkills2(skillsDirectories);
-    onDemandSkillsContext = formatSkillsForContext(skills);
+    const skills2 = await loadAllSkills2(skillsDirectories);
+    onDemandSkillsContext = formatSkillsForContext(skills2);
   }
   const todos = await todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
@@ -8138,6 +8173,35 @@ function stripOrphanedToolResults(msg, removedIds) {
   if (parts.length === 0) return null;
   return { ...msg, content: parts };
 }
+function wrapToolsNeverThrow(tools) {
+  if (!tools || typeof tools !== "object") return tools;
+  const wrapped = {};
+  for (const [name, t] of Object.entries(tools)) {
+    if (!t || typeof t.execute !== "function") {
+      wrapped[name] = t;
+      continue;
+    }
+    const original = t.execute;
+    wrapped[name] = {
+      ...t,
+      execute: async (input, opts) => {
+        try {
+          return await original.call(t, input, opts);
+        } catch (err) {
+          const message = err?.message ?? String(err);
+          console.warn(`[tool:${name}] threw \u2014 converted to error result so the tool-call isn't orphaned:`, message);
+          return {
+            __error: true,
+            tool: name,
+            message,
+            note: "Tool execution threw an exception. The agent should treat this as a failed tool call and decide how to recover."
+          };
+        }
+      }
+    };
+  }
+  return wrapped;
+}
 function repairToolPairing(messages) {
   const toolCallIds = /* @__PURE__ */ new Set();
   const toolResultIds = /* @__PURE__ */ new Set();
@@ -8503,6 +8567,120 @@ var init_web = __esm({
   }
 });
 
+// src/integrations/slack/persistence.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync3, renameSync } from "fs";
+import { join as join9, dirname as dirname6 } from "path";
+function cachePath() {
+  return join9(ensureAppDataDirectory(), FILENAME);
+}
+function load() {
+  if (loaded) return;
+  loaded = true;
+  const path = cachePath();
+  if (!existsSync16(path)) return;
+  try {
+    const raw = readFileSync7(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== FILE_VERSION) return;
+    const now = Date.now();
+    for (const [id, e] of Object.entries(parsed.users || {})) {
+      if (e && typeof e.expiresAt === "number" && e.expiresAt > now) {
+        userMap.set(id, { name: e.name ?? null, expiresAt: e.expiresAt });
+      }
+    }
+    for (const [key2, e] of Object.entries(parsed.threads || {})) {
+      if (e && typeof e.expiresAt === "number" && e.expiresAt > now) {
+        threadMap.set(key2, { owned: !!e.owned, expiresAt: e.expiresAt });
+      }
+    }
+  } catch (err) {
+    console.warn(`[slack] could not load ${FILENAME}:`, err?.message || err);
+  }
+}
+function evictIfOversized(map, max) {
+  if (map.size <= max) return;
+  const sorted = [...map.entries()].sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+  const toRemove = map.size - max;
+  for (let i = 0; i < toRemove; i++) map.delete(sorted[i][0]);
+}
+function scheduleSave() {
+  dirty = true;
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    if (dirty) saveSync();
+  }, SAVE_DEBOUNCE_MS);
+  saveTimer.unref?.();
+}
+function saveSync() {
+  dirty = false;
+  try {
+    const path = cachePath();
+    const dir = dirname6(path);
+    if (!existsSync16(dir)) mkdirSync6(dir, { recursive: true });
+    const payload = {
+      version: FILE_VERSION,
+      users: Object.fromEntries(userMap),
+      threads: Object.fromEntries(threadMap)
+    };
+    const tmp = `${path}.tmp`;
+    writeFileSync3(tmp, JSON.stringify(payload), "utf-8");
+    renameSync(tmp, path);
+  } catch (err) {
+    console.warn(`[slack] could not persist ${FILENAME}:`, err?.message || err);
+  }
+}
+function hookExit() {
+  if (exitHooked) return;
+  exitHooked = true;
+  const flush2 = () => {
+    if (dirty) saveSync();
+  };
+  process.once("beforeExit", flush2);
+  process.once("SIGINT", flush2);
+  process.once("SIGTERM", flush2);
+}
+function getCachedUserName(userId) {
+  load();
+  return userMap.get(userId);
+}
+function setCachedUserName(userId, entry2) {
+  load();
+  hookExit();
+  userMap.set(userId, entry2);
+  evictIfOversized(userMap, MAX_USERS);
+  scheduleSave();
+}
+function getCachedThreadOwnership(key2) {
+  load();
+  return threadMap.get(key2);
+}
+function setCachedThreadOwnership(key2, entry2) {
+  load();
+  hookExit();
+  threadMap.set(key2, entry2);
+  evictIfOversized(threadMap, MAX_THREADS);
+  scheduleSave();
+}
+var FILENAME, FILE_VERSION, SAVE_DEBOUNCE_MS, MAX_USERS, MAX_THREADS, loaded, userMap, threadMap, dirty, saveTimer, exitHooked;
+var init_persistence = __esm({
+  "src/integrations/slack/persistence.ts"() {
+    "use strict";
+    init_config();
+    FILENAME = "slack-cache.json";
+    FILE_VERSION = 1;
+    SAVE_DEBOUNCE_MS = 500;
+    MAX_USERS = 5e3;
+    MAX_THREADS = 5e3;
+    loaded = false;
+    userMap = /* @__PURE__ */ new Map();
+    threadMap = /* @__PURE__ */ new Map();
+    dirty = false;
+    saveTimer = null;
+    exitHooked = false;
+  }
+});
+
 // src/integrations/slack/client.ts
 function readSlackConfig() {
   try {
@@ -8625,13 +8803,13 @@ async function fetchSlackUserName(userId) {
 async function resolveSlackUserName(userId) {
   if (!userId) return null;
   const now = Date.now();
-  const hit = userNameCache.get(userId);
+  const hit = getCachedUserName(userId);
   if (hit && hit.expiresAt > now) return hit.name;
   const inflight = userInflight.get(userId);
   if (inflight) return inflight;
   const p = (async () => {
     const name = await fetchSlackUserName(userId);
-    userNameCache.set(userId, {
+    setCachedUserName(userId, {
       name,
       expiresAt: now + (name ? USER_TTL_MS : USER_FAIL_TTL_MS)
     });
@@ -8653,11 +8831,63 @@ async function normalizeSlackMentions(text) {
   }
   return text.replace(userMentionRe, (_full, id, label) => {
     if (label) return `${label} <@${id}>`;
-    const cached = userNameCache.get(id);
+    const cached = getCachedUserName(id);
     const name = cached?.name;
     return name ? `${name} <@${id}>` : `<@${id}>`;
   });
 }
+function threadCacheKey(channel, threadTs) {
+  return `${channel}\u241F${threadTs}`;
+}
+async function fetchBotParticipatedInThread(channel, threadTs) {
+  const token = getSlackBotToken();
+  if (!token) return false;
+  const self = await ensureSlackSelfIdentity();
+  if (!self) return false;
+  try {
+    const url = `https://slack.com/api/conversations.replies?channel=${encodeURIComponent(channel)}&ts=${encodeURIComponent(threadTs)}&limit=200`;
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+    const data = await res.json().catch(() => ({}));
+    if (!data?.ok) {
+      console.warn(`[slack] conversations.replies(${channel}/${threadTs}) failed: ${data?.error || `HTTP ${res.status}`}`);
+      return false;
+    }
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    return messages.some(
+      (m) => self.botId && m.bot_id === self.botId || self.botUserId && m.user === self.botUserId
+    );
+  } catch (err) {
+    console.warn(`[slack] conversations.replies error:`, err?.message || err);
+    return false;
+  }
+}
+async function botParticipatedInThread(channel, threadTs) {
+  if (!channel || !threadTs) return false;
+  const key2 = threadCacheKey(channel, threadTs);
+  const now = Date.now();
+  const hit = getCachedThreadOwnership(key2);
+  if (hit && hit.expiresAt > now) return hit.owned;
+  const inflight = threadOwnedInflight.get(key2);
+  if (inflight) return inflight;
+  const p = (async () => {
+    const owned = await fetchBotParticipatedInThread(channel, threadTs);
+    setCachedThreadOwnership(key2, {
+      owned,
+      expiresAt: now + (owned ? THREAD_OWNED_TTL_MS : THREAD_NEG_TTL_MS)
+    });
+    threadOwnedInflight.delete(key2);
+    return owned;
+  })();
+  threadOwnedInflight.set(key2, p);
+  return p;
+}
+function noteBotPostedInThread(channel, threadTs) {
+  if (!channel || !threadTs) return;
+  setCachedThreadOwnership(threadCacheKey(channel, threadTs), {
+    owned: true,
+    expiresAt: Date.now() + THREAD_OWNED_TTL_MS
+  });
+}
 function getSlackDeniedReplyPolicy() {
   try {
     const cfg = getConfig();
@@ -8670,17 +8900,20 @@ function getSlackDeniedReplyPolicy() {
     return { enabled: true, template: DEFAULT_DENIED_TEMPLATE };
   }
 }
-var cachedSelf, selfInflight, USER_TTL_MS, USER_FAIL_TTL_MS, userNameCache, userInflight, DEFAULT_DENIED_TEMPLATE;
+var cachedSelf, selfInflight, USER_TTL_MS, USER_FAIL_TTL_MS, userInflight, THREAD_OWNED_TTL_MS, THREAD_NEG_TTL_MS, threadOwnedInflight, DEFAULT_DENIED_TEMPLATE;
 var init_client3 = __esm({
   "src/integrations/slack/client.ts"() {
     "use strict";
     init_config();
+    init_persistence();
     cachedSelf = null;
     selfInflight = null;
     USER_TTL_MS = 60 * 60 * 1e3;
     USER_FAIL_TTL_MS = 5 * 60 * 1e3;
-    userNameCache = /* @__PURE__ */ new Map();
     userInflight = /* @__PURE__ */ new Map();
+    THREAD_OWNED_TTL_MS = 60 * 60 * 1e3;
+    THREAD_NEG_TTL_MS = 5 * 60 * 1e3;
+    threadOwnedInflight = /* @__PURE__ */ new Map();
     DEFAULT_DENIED_TEMPLATE = "Sorry, you don't have permission to use this bot. (Contact the bot owner if you think this is a mistake.)";
   }
 });
@@ -8780,6 +9013,7 @@ var init_slack = __esm({
         if (!result.ok) throw new Error(`slack post failed: ${result.error}`);
         if (r.slackChannel && r.threadTs) {
           markThreadOwned(r.slackChannel, r.threadTs);
+          noteBotPostedInThread(r.slackChannel, r.threadTs);
         }
       },
       displayLabel(ref) {
@@ -9437,8 +9671,8 @@ var init_orchestrator_actions = __esm({
 
 // src/integrations/mcp/store.ts
 import { nanoid as nanoid6 } from "nanoid";
-import { existsSync as existsSync16, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve10, join as join9 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve10, join as join10 } from "path";
 function readServers() {
   try {
     const cfg = getConfig();
@@ -9450,12 +9684,12 @@ function readServers() {
 function refreshMcpServersFromDisk() {
   const candidates = [
     resolve10(process.cwd(), "sparkecoder.config.json"),
-    join9(ensureAppDataDirectory(), "sparkecoder.config.json")
+    join10(ensureAppDataDirectory(), "sparkecoder.config.json")
   ];
   for (const path of candidates) {
-    if (!existsSync16(path)) continue;
+    if (!existsSync17(path)) continue;
     try {
-      const raw = JSON.parse(readFileSync7(path, "utf-8"));
+      const raw = JSON.parse(readFileSync8(path, "utf-8"));
       const servers2 = Array.isArray(raw?.mcp?.servers) ? raw.mcp.servers : [];
       setMcpServers(servers2);
       return servers2;
@@ -9707,11 +9941,11 @@ function waitForTaskQuestionAnswer(question) {
   if (pendingQuestions.has(k)) {
     return Promise.reject(new Error(`Question already pending: ${question.questionId}`));
   }
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     pendingQuestions.set(k, {
       ...question,
       createdAt: /* @__PURE__ */ new Date(),
-      resolve: resolve13,
+      resolve: resolve14,
       reject
     });
   });
@@ -10068,7 +10302,7 @@ __export(recorder_exports, {
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { writeFile as writeFile5, mkdir as mkdir4, readFile as readFile11, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { tmpdir } from "os";
 import { nanoid as nanoid7 } from "nanoid";
 async function checkFfmpeg() {
@@ -10125,21 +10359,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join10(tmpdir(), `sparkecoder-recording-${nanoid7(8)}`);
+        const workDir = join11(tmpdir(), `sparkecoder-recording-${nanoid7(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join10(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            const framePath = join11(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
             await writeFile5(framePath, this.frames[i].data);
           }
           const duration = (this.frames[this.frames.length - 1].timestamp - this.frames[0].timestamp) / 1e3;
           const fps = duration > 0 ? Math.round(this.frames.length / duration) : 10;
           const clampedFps = Math.max(1, Math.min(fps, 30));
-          const outputPath = join10(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join11(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
             await execAsync5(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join10(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+              `ffmpeg -y -framerate ${clampedFps} -i "${join11(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
               { timeout: 12e4 }
             );
           } else {
@@ -10151,7 +10385,7 @@ var init_recorder = __esm({
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join10(workDir, f)).catch(() => {
+              await unlink2(join11(workDir, f)).catch(() => {
               });
             }
           }
@@ -10418,7 +10652,8 @@ ${personality.trim()}`;
         }
         const messages = await this.context.getMessages();
         const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
-        const wrappedTools = this.wrapToolsWithApproval(options, tools);
+        const approvalWrapped = this.wrapToolsWithApproval(options, tools);
+        const wrappedTools = wrapToolsNeverThrow(approvalWrapped);
         const useAnthropic = isAnthropicModel(this.session.model);
         const stream = streamText2({
           model: resolveModel(this.session.model),
@@ -10432,6 +10667,17 @@ ${personality.trim()}`;
           providerOptions: useAnthropic ? {
             anthropic: getAnthropicProviderOptions(this.session.model, { toolStreaming: true })
           } : void 0,
+          // Run repairToolPairing before EVERY step's model call, not just the
+          // first one. The AI SDK's multi-step loop can otherwise feed the model
+          // a prompt containing an orphan tool-call (e.g. when a previous step's
+          // tool result was lost, dropped during compaction, or the stream was
+          // aborted mid-tool). Repairing in `prepareStep` guarantees no orphan
+          // ever reaches the model and we never hit AI_MissingToolResultsError.
+          prepareStep: async ({ messages: stepMessages }) => {
+            const repaired = repairToolPairing(stepMessages);
+            if (repaired === stepMessages) return {};
+            return { messages: repaired };
+          },
           onStepFinish: async (step) => {
             options.onStepFinish?.(step);
           },
@@ -10467,7 +10713,7 @@ ${personality.trim()}`;
         });
         const messages = await this.context.getMessages();
         const tools = options.onToolProgress ? await this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
-        const wrappedTools = this.wrapToolsWithApproval(options, tools);
+        const wrappedTools = wrapToolsNeverThrow(this.wrapToolsWithApproval(options, tools));
         const useAnthropic = isAnthropicModel(this.session.model);
         const result = await generateText3({
           model: resolveModel(this.session.model),
@@ -10478,7 +10724,13 @@ ${personality.trim()}`;
           // Enable extended thinking/reasoning for models that support it
           providerOptions: useAnthropic ? {
             anthropic: getAnthropicProviderOptions(this.session.model)
-          } : void 0
+          } : void 0,
+          // Repair tool pairing before every step (see `stream()` for full rationale).
+          prepareStep: async ({ messages: stepMessages }) => {
+            const repaired = repairToolPairing(stepMessages);
+            if (repaired === stepMessages) return {};
+            return { messages: repaired };
+          }
         });
         const responseMessages = result.response.messages;
         this.context.addResponseMessages(responseMessages);
@@ -10655,12 +10907,19 @@ ${p.text}` : p.text;
             model: resolveModel(this.session.model),
             system: systemPrompt,
             messages,
-            tools: taskTools,
+            tools: wrapToolsNeverThrow(taskTools),
             stopWhen: stepCountIs2(500),
             abortSignal: combinedAbort,
             providerOptions: useAnthropic ? {
               anthropic: getAnthropicProviderOptions(this.session.model, { toolStreaming: true })
             } : void 0,
+            // See the matching note in `stream()` — repair tool pairing before
+            // every step so we never feed the model an orphan tool-call.
+            prepareStep: async ({ messages: stepMessages }) => {
+              const repaired = repairToolPairing(stepMessages);
+              if (repaired === stepMessages) return {};
+              return { messages: repaired };
+            },
             onStepFinish: async (step) => {
               options.onStepFinish?.(step);
               fireWebhook("task.step_finished", { iteration, text: step.text });
@@ -10860,14 +11119,14 @@ ${p.text}` : p.text;
           const result = await recorder.encode();
           recorder.clear();
           if (!result) return [];
-          const { readFile: readFile12, unlink: unlink3 } = await import("fs/promises");
+          const { readFile: readFile13, unlink: unlink4 } = await import("fs/promises");
           const uploadInfo = await storageQueries2.getUploadUrl(
             this.session.id,
             `browser-recording-${Date.now()}.mp4`,
             "video/mp4",
             "browser-recording"
           );
-          const fileData = await readFile12(result.path);
+          const fileData = await readFile13(result.path);
           await fetch(uploadInfo.uploadUrl, {
             method: "PUT",
             headers: { "Content-Type": "video/mp4" },
@@ -10875,7 +11134,7 @@ ${p.text}` : p.text;
           });
           await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: result.sizeBytes });
           const dlInfo = await storageQueries2.getDownloadUrl(uploadInfo.fileId);
-          await unlink3(result.path).catch(() => {
+          await unlink4(result.path).catch(() => {
           });
           console.log(`[TASK] Browser recording uploaded (${result.sizeBytes} bytes)`);
           return [dlInfo.downloadUrl];
@@ -10893,13 +11152,13 @@ ${p.text}` : p.text;
         try {
           const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
           if (!isRemoteConfigured2()) return [];
-          const { readFile: readFile12 } = await import("fs/promises");
-          const { join: join17, basename: basename6 } = await import("path");
+          const { readFile: readFile13 } = await import("fs/promises");
+          const { join: join19, basename: basename7 } = await import("path");
           const urls = [];
           for (const filePath of filePaths) {
             try {
-              const fullPath = filePath.startsWith("/") ? filePath : join17(this.session.workingDirectory, filePath);
-              const fileName = basename6(fullPath);
+              const fullPath = filePath.startsWith("/") ? filePath : join19(this.session.workingDirectory, filePath);
+              const fileName = basename7(fullPath);
               const ext = fileName.split(".").pop()?.toLowerCase() || "";
               const mimeMap = {
                 pdf: "application/pdf",
@@ -10923,7 +11182,7 @@ ${p.text}` : p.text;
                 contentType,
                 "task-output"
               );
-              const fileData = await readFile12(fullPath);
+              const fileData = await readFile13(fullPath);
               await fetch(uploadInfo.uploadUrl, {
                 method: "PUT",
                 headers: { "Content-Type": contentType },
@@ -10972,8 +11231,8 @@ ${p.text}` : p.text;
               this.pendingApprovals.set(toolCallId, await execution);
               options.onApprovalRequired?.(await execution);
               await sessionQueries.updateStatus(this.session.id, "waiting");
-              const approved = await new Promise((resolve13) => {
-                approvalResolvers.set(toolCallId, { resolve: resolve13, sessionId: this.session.id });
+              const approved = await new Promise((resolve14) => {
+                approvalResolvers.set(toolCallId, { resolve: resolve14, sessionId: this.session.id });
               });
               const resolverData = approvalResolvers.get(toolCallId);
               approvalResolvers.delete(toolCallId);
@@ -11079,8 +11338,8 @@ async function withSessionLock(sessionId, fn) {
   state2.pending++;
   const prev = state2.tail;
   let release;
-  const next = new Promise((resolve13) => {
-    release = resolve13;
+  const next = new Promise((resolve14) => {
+    release = resolve14;
   });
   state2.tail = prev.then(() => next);
   await prev;
@@ -11103,19 +11362,19 @@ var init_session_lock = __esm({
 });
 
 // src/orchestrator/webhook-events.ts
-import { existsSync as existsSync17, readFileSync as readFileSync8, appendFileSync as appendFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname7, join as join12 } from "path";
 import { nanoid as nanoid9 } from "nanoid";
 function logFilePath() {
-  return join11(getAppDataDirectory(), "webhook-events.jsonl");
+  return join12(getAppDataDirectory(), "webhook-events.jsonl");
 }
 function ensureLoaded() {
   if (cache !== null) return cache;
   cache = [];
   try {
     const p = logFilePath();
-    if (!existsSync17(p)) return cache;
-    const lines = readFileSync8(p, "utf-8").split("\n").filter(Boolean);
+    if (!existsSync18(p)) return cache;
+    const lines = readFileSync9(p, "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         cache.push(JSON.parse(line));
@@ -11125,7 +11384,7 @@ function ensureLoaded() {
     if (cache.length > MAX_EVENTS) {
       cache = cache.slice(-MAX_EVENTS);
       try {
-        writeFileSync3(p, cache.map((e) => JSON.stringify(e)).join("\n") + "\n");
+        writeFileSync4(p, cache.map((e) => JSON.stringify(e)).join("\n") + "\n");
       } catch {
       }
     }
@@ -11139,7 +11398,7 @@ function appendEvent(ev) {
   if (list.length > MAX_EVENTS) list.shift();
   try {
     const p = logFilePath();
-    mkdirSync6(dirname6(p), { recursive: true });
+    mkdirSync7(dirname7(p), { recursive: true });
     appendFileSync3(p, JSON.stringify(ev) + "\n");
   } catch {
   }
@@ -11170,8 +11429,8 @@ function updateEvent(id, patch) {
   list[i] = { ...list[i], ...patch };
   try {
     const p = logFilePath();
-    mkdirSync6(dirname6(p), { recursive: true });
-    writeFileSync3(p, list.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    mkdirSync7(dirname7(p), { recursive: true });
+    writeFileSync4(p, list.map((e) => JSON.stringify(e)).join("\n") + "\n");
   } catch {
   }
 }
@@ -11203,7 +11462,7 @@ function listEvents(filter = {}) {
 function clearAllEvents() {
   cache = [];
   try {
-    writeFileSync3(logFilePath(), "");
+    writeFileSync4(logFilePath(), "");
   } catch {
   }
 }
@@ -11693,17 +11952,17 @@ import chalk from "chalk";
 import ora from "ora";
 import "dotenv/config";
 import { createInterface } from "readline";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/server/index.ts
 import "dotenv/config";
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve11, dirname as dirname8, join as join15 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync10, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve12, dirname as dirname10, join as join17 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -11717,9 +11976,9 @@ init_checkpoints();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { z as z16 } from "zod";
-import { existsSync as existsSync18, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4, readdirSync as readdirSync3, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, readdirSync as readdirSync3, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
 import { readdir as readdir6 } from "fs/promises";
-import { join as join12, basename as basename5, extname as extname8, relative as relative9 } from "path";
+import { join as join13, basename as basename5, extname as extname8, relative as relative9 } from "path";
 import { nanoid as nanoid10 } from "nanoid";
 
 // src/tasks/agent-status.ts
@@ -12357,12 +12616,12 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
 });
 function getAttachmentsDir(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join12(appDataDir, "attachments", sessionId);
+  return join13(appDataDir, "attachments", sessionId);
 }
 function ensureAttachmentsDir(sessionId) {
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync18(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  if (!existsSync19(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
   return dir;
 }
@@ -12373,12 +12632,12 @@ sessions2.get("/:id/attachments", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync18(dir)) {
+  if (!existsSync19(dir)) {
     return c.json({ sessionId, attachments: [], count: 0 });
   }
   const files = readdirSync3(dir);
   const attachments = files.map((filename) => {
-    const filePath = join12(dir, filename);
+    const filePath = join13(dir, filename);
     const stats = statSync2(filePath);
     return {
       id: filename.split("_")[0],
@@ -12413,9 +12672,9 @@ sessions2.post("/:id/attachments", async (c) => {
       const id = nanoid10(10);
       const ext = extname8(file.name) || "";
       const safeFilename = `${id}_${basename5(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const filePath = join12(dir, safeFilename);
+      const filePath = join13(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
-      writeFileSync4(filePath, Buffer.from(arrayBuffer));
+      writeFileSync5(filePath, Buffer.from(arrayBuffer));
       return c.json({
         id,
         filename: file.name,
@@ -12439,13 +12698,13 @@ sessions2.post("/:id/attachments", async (c) => {
     const id = nanoid10(10);
     const ext = extname8(body.filename) || "";
     const safeFilename = `${id}_${basename5(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-    const filePath = join12(dir, safeFilename);
+    const filePath = join13(dir, safeFilename);
     let base64Data = body.data;
     if (base64Data.includes(",")) {
       base64Data = base64Data.split(",")[1];
     }
     const buffer = Buffer.from(base64Data, "base64");
-    writeFileSync4(filePath, buffer);
+    writeFileSync5(filePath, buffer);
     return c.json({
       id,
       filename: body.filename,
@@ -12468,7 +12727,7 @@ sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
     return c.json({ error: "Session not found" }, 404);
   }
   const dir = getAttachmentsDir(sessionId);
-  if (!existsSync18(dir)) {
+  if (!existsSync19(dir)) {
     return c.json({ error: "Attachment not found" }, 404);
   }
   const files = readdirSync3(dir);
@@ -12476,7 +12735,7 @@ sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
   if (!file) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const filePath = join12(dir, file);
+  const filePath = join13(dir, file);
   unlinkSync2(filePath);
   return c.json({ success: true, id: attachmentId });
 });
@@ -12559,7 +12818,7 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
     const entries = await readdir6(currentDir, { withFileTypes: true });
     for (const entry2 of entries) {
       if (results.length >= limit * 2) break;
-      const fullPath = join12(currentDir, entry2.name);
+      const fullPath = join13(currentDir, entry2.name);
       const relativePath = relative9(baseDir, fullPath);
       if (entry2.isDirectory() && IGNORED_DIRECTORIES.has(entry2.name)) {
         continue;
@@ -12607,7 +12866,7 @@ sessions2.get(
       return c.json({ error: "Session not found" }, 404);
     }
     const workingDirectory = session.workingDirectory;
-    if (!existsSync18(workingDirectory)) {
+    if (!existsSync19(workingDirectory)) {
       return c.json({
         sessionId,
         workingDirectory,
@@ -12715,14 +12974,101 @@ sessions2.get("/:id/browser-recording", async (c) => {
 
 // src/server/routes/agents.ts
 init_db();
-init_agent();
-init_session_lock();
-init_config();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { z as z17 } from "zod";
-import { existsSync as existsSync19, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
+
+// src/agent/missing-tool-recovery.ts
+init_db();
+function extractMissingToolCallIds(error) {
+  if (!error) return [];
+  const e = error;
+  if (Array.isArray(e.toolCallIds) && e.toolCallIds.every((x) => typeof x === "string")) {
+    return e.toolCallIds;
+  }
+  const msg = typeof e.message === "string" ? e.message : "";
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of msg.matchAll(/(?:tool call|tool calls)\s+([a-zA-Z0-9_\-, ]+?)(?:\.|$)/g)) {
+    for (const id of m[1].split(/\s*,\s*/)) {
+      const trimmed = id.trim();
+      if (trimmed) ids.add(trimmed);
+    }
+  }
+  return [...ids];
+}
+function isMissingToolResultsError(error) {
+  if (!error) return false;
+  const e = error;
+  if (e.name === "AI_MissingToolResultsError") return true;
+  if (Array.isArray(e.toolCallIds)) return true;
+  return typeof e.message === "string" && /tool result.*is missing for tool call/i.test(e.message);
+}
+async function recoverFromMissingToolResults(sessionId, error) {
+  const toolCallIds = extractMissingToolCallIds(error);
+  if (toolCallIds.length === 0) return null;
+  let history = [];
+  try {
+    history = await messageQueries.getModelMessages(sessionId);
+  } catch (err) {
+    console.warn("[missing-tool-recovery] could not load messages:", err?.message || err);
+  }
+  const toolNameByCallId = /* @__PURE__ */ new Map();
+  const existingResultIds = /* @__PURE__ */ new Set();
+  for (const msg of history) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type === "tool-call" && typeof part.toolCallId === "string") {
+        if (typeof part.toolName === "string") toolNameByCallId.set(part.toolCallId, part.toolName);
+      }
+      if (part?.type === "tool-result" && typeof part.toolCallId === "string") {
+        existingResultIds.add(part.toolCallId);
+      }
+    }
+  }
+  const resolved = toolCallIds.map((id) => ({
+    toolCallId: id,
+    toolName: toolNameByCallId.get(id) ?? "unknown",
+    foundInAssistantMessage: toolNameByCallId.has(id)
+  }));
+  const stillOrphaned = toolCallIds.filter((id) => !existingResultIds.has(id));
+  let syntheticToolMessageSaved = false;
+  if (stillOrphaned.length > 0) {
+    const syntheticParts = stillOrphaned.map((id) => ({
+      type: "tool-result",
+      toolCallId: id,
+      toolName: toolNameByCallId.get(id) ?? "unknown",
+      output: {
+        type: "text",
+        value: "[Auto-recovered: the original tool execution never produced a result (crash, timeout, or message stripped during context compaction). This synthetic placeholder lets the conversation continue.]"
+      }
+    }));
+    try {
+      await messageQueries.create(sessionId, {
+        role: "tool",
+        content: syntheticParts
+      });
+      syntheticToolMessageSaved = true;
+    } catch (err) {
+      console.error("[missing-tool-recovery] failed to persist synthetic tool message:", err?.message || err);
+    }
+  }
+  const lastFewMessageRoles = history.slice(-6).map((m) => m.role);
+  return {
+    kind: "missing_tool_results",
+    toolCallIds,
+    resolved,
+    syntheticToolMessageSaved,
+    lastFewMessageRoles,
+    hint: syntheticToolMessageSaved ? "Synthetic tool-result(s) saved. Re-send your message to continue." : "Could not auto-recover; please reset the session or revert to the previous checkpoint."
+  };
+}
+
+// src/server/routes/agents.ts
+init_agent();
+init_session_lock();
+init_config();
 
 // src/server/resumable-stream.ts
 import { createResumableStreamContext } from "resumable-stream/generic";
@@ -12878,7 +13224,7 @@ async function emitSyntheticToolStreaming(writeSSE, toolCallStarts, toolCallId,
       toolCallId,
       argsTextDelta: chunk
     }));
-    await new Promise((resolve13) => setTimeout(resolve13, 0));
+    await new Promise((resolve14) => setTimeout(resolve14, 0));
   }
 }
 function buildDevtoolsContextXml(sessionId) {
@@ -12929,12 +13275,12 @@ var rejectSchema = z17.object({
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join13(appDataDir, "attachments", sessionId);
+  return join14(appDataDir, "attachments", sessionId);
 }
 async function saveAttachmentToDisk(sessionId, attachment, index) {
   const attachmentsDir = getAttachmentsDirectory(sessionId);
-  if (!existsSync19(attachmentsDir)) {
-    mkdirSync8(attachmentsDir, { recursive: true });
+  if (!existsSync20(attachmentsDir)) {
+    mkdirSync9(attachmentsDir, { recursive: true });
   }
   let filename = attachment.filename;
   if (!filename) {
@@ -12952,8 +13298,8 @@ async function saveAttachmentToDisk(sessionId, attachment, index) {
     attachment.mediaType = resized.mediaType;
     attachment.data = buffer.toString("base64");
   }
-  const filePath = join13(attachmentsDir, filename);
-  writeFileSync5(filePath, buffer);
+  const filePath = join14(attachmentsDir, filename);
+  writeFileSync6(filePath, buffer);
   return filePath;
 }
 function stripDataUrlPrefix2(data) {
@@ -13133,7 +13479,7 @@ ${prompt}` });
                 chunkIndex,
                 chunkCount
               }));
-              await new Promise((resolve13) => setTimeout(resolve13, 0));
+              await new Promise((resolve14) => setTimeout(resolve14, 0));
             }
             const browserPort = progress.data?.browserStreamPort;
             const browserClosed = progress.data?.browserClosed;
@@ -13290,7 +13636,20 @@ ${prompt}` });
           await writeSSE(JSON.stringify({ type: "abort" }));
         } else {
           console.error("Agent error:", error);
-          await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
+          let debugPayload = void 0;
+          if (isMissingToolResultsError(error)) {
+            try {
+              const recovery = await recoverFromMissingToolResults(sessionId, error);
+              if (recovery) debugPayload = recovery;
+            } catch (recErr) {
+              console.error("[missing-tool-recovery] failed:", recErr?.message || recErr);
+            }
+          }
+          await writeSSE(JSON.stringify({
+            type: "error",
+            errorText: error.message,
+            ...debugPayload ? { debug: debugPayload } : {}
+          }));
           try {
             await activeStreamQueries.markError(streamId);
           } catch {
@@ -13680,7 +14039,7 @@ agents.post(
                   chunkIndex,
                   chunkCount
                 }));
-                await new Promise((resolve13) => setTimeout(resolve13, 0));
+                await new Promise((resolve14) => setTimeout(resolve14, 0));
               }
               const browserPort = progress.data?.browserStreamPort;
               const browserClosed = progress.data?.browserClosed;
@@ -13830,7 +14189,20 @@ agents.post(
             await writeSSE(JSON.stringify({ type: "abort" }));
           } else {
             console.error("Agent error:", error);
-            await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
+            let debugPayload = void 0;
+            if (isMissingToolResultsError(error)) {
+              try {
+                const recovery = await recoverFromMissingToolResults(session.id, error);
+                if (recovery) debugPayload = recovery;
+              } catch (recErr) {
+                console.error("[missing-tool-recovery] failed:", recErr?.message || recErr);
+              }
+            }
+            await writeSSE(JSON.stringify({
+              type: "error",
+              errorText: error.message,
+              ...debugPayload ? { debug: debugPayload } : {}
+            }));
             await activeStreamQueries.markError(streamId);
           }
         } finally {
@@ -13913,26 +14285,26 @@ init_config();
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { z as z18 } from "zod";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname7, join as join14 } from "path";
+import { dirname as dirname8, join as join15 } from "path";
 var __filename = fileURLToPath3(import.meta.url);
-var __dirname = dirname7(__filename);
+var __dirname = dirname8(__filename);
 var possiblePaths = [
-  join14(__dirname, "../package.json"),
+  join15(__dirname, "../package.json"),
   // From dist/server -> dist/../package.json
-  join14(__dirname, "../../package.json"),
+  join15(__dirname, "../../package.json"),
   // From dist/server (if nested differently)
-  join14(__dirname, "../../../package.json"),
+  join15(__dirname, "../../../package.json"),
   // From src/server/routes (development)
-  join14(process.cwd(), "package.json")
+  join15(process.cwd(), "package.json")
   // From current working directory
 ];
 var currentVersion = "0.0.0";
 var packageName = "sparkecoder";
 for (const packageJsonPath of possiblePaths) {
   try {
-    const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
     if (packageJson.name === "sparkecoder") {
       currentVersion = packageJson.version || "0.0.0";
       packageName = packageJson.name || "sparkecoder";
@@ -14750,12 +15122,13 @@ slack.post("/events", async (c) => {
     if (inbound) {
       const isThreadReply = ev.type === "message" && ev.channel_type !== "im" && typeof ev.thread_ts === "string" && ev.thread_ts !== ev.ts;
       if (isThreadReply) {
-        const ours = isThreadOwned(ev.channel, ev.thread_ts) || await threadBelongsToUs(ev.channel, ev.thread_ts);
+        const ours = isThreadOwned(ev.channel, ev.thread_ts) || await botParticipatedInThread(ev.channel, ev.thread_ts);
         if (!ours) {
           console.log(`[slack] dropping thread reply in unknown thread: channel=${ev.channel} thread=${ev.thread_ts}`);
           updateEvent(auditId, { status: "dropped", dropReason: "thread_not_owned" });
           return c.json({ ok: true });
         }
+        markThreadOwned(ev.channel, ev.thread_ts);
       }
       if (ev.type === "app_mention" && ev.channel && (ev.thread_ts || ev.ts)) {
         markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
@@ -14794,18 +15167,6 @@ slack.post("/events", async (c) => {
   }
   return c.json({ ok: true });
 });
-async function threadBelongsToUs(channel, threadTs) {
-  try {
-    const sessions3 = await sessionQueries.list(500, 0);
-    return sessions3.some((s) => {
-      const slack2 = s.config?.slack;
-      return slack2?.channel === channel && slack2?.threadTs === threadTs;
-    });
-  } catch (err) {
-    console.warn("[slack] threadBelongsToUs lookup failed:", err?.message ?? err);
-    return false;
-  }
-}
 async function findOrCreateOrchestratorId() {
   try {
     const all = await sessionQueries.list(500, 0);
@@ -15188,6 +15549,224 @@ mcpRouter.post("/:id/test", async (c) => {
   return c.json(result);
 });
 
+// src/server/routes/skills.ts
+init_config();
+init_skills();
+import { Hono as Hono9 } from "hono";
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { z as z22 } from "zod";
+import { existsSync as existsSync21, statSync as statSync3 } from "fs";
+import { readFile as readFile12, writeFile as writeFile6, unlink as unlink3, mkdir as mkdir5 } from "fs/promises";
+import { resolve as resolve11, join as join16, basename as basename6, dirname as dirname9, extname as extname9 } from "path";
+var skills = new Hono9();
+function encodeId(filePath) {
+  return Buffer.from(filePath, "utf-8").toString("base64url");
+}
+function decodeId(id) {
+  try {
+    const decoded = Buffer.from(id, "base64url").toString("utf-8");
+    return decoded || null;
+  } catch {
+    return null;
+  }
+}
+function listAllDirectories() {
+  const cfg = getConfig();
+  const discovered = discoverSkillDirectories(cfg.resolvedWorkingDirectory);
+  const out = [];
+  for (const { path, priority } of discovered.alwaysLoadedDirs) {
+    out.push({
+      path,
+      source: pathToSource(path),
+      label: pathToLabel(path),
+      priority,
+      alwaysApply: true
+    });
+  }
+  for (const { path, priority } of discovered.onDemandDirs) {
+    out.push({
+      path,
+      source: pathToSource(path),
+      label: pathToLabel(path),
+      priority,
+      alwaysApply: false
+    });
+  }
+  const additional = cfg.skills?.additionalDirectories || [];
+  for (const dir of additional) {
+    const abs = resolve11(cfg.resolvedWorkingDirectory, dir);
+    if (out.some((d) => d.path === abs)) continue;
+    out.push({
+      path: abs,
+      source: "additional",
+      label: pathToLabel(abs),
+      priority: 50,
+      alwaysApply: false
+    });
+  }
+  return out;
+}
+function pathToSource(path) {
+  if (path.includes("/skills/default") || path.endsWith("/skills/default")) return "builtin";
+  return "project";
+}
+function pathToLabel(path) {
+  if (path.includes("/skills/default")) return "Built-in (default)";
+  if (path.includes("/.sparkecoder/rules")) return ".sparkecoder/rules";
+  if (path.includes("/.sparkecoder/skills")) return ".sparkecoder/skills";
+  if (path.includes("/.cursor/rules")) return ".cursor/rules";
+  if (path.includes("/.claude/skills")) return ".claude/skills";
+  return basename6(dirname9(path)) + "/" + basename6(path);
+}
+skills.get("/", async (c) => {
+  const dirs = listAllDirectories();
+  const allSkills = [];
+  for (const dir of dirs) {
+    if (!existsSync21(dir.path)) continue;
+    try {
+      const list = await loadSkillsFromDirectory(dir.path, {
+        priority: dir.priority,
+        defaultLoadType: dir.alwaysApply ? "always" : "on_demand",
+        forceAlwaysApply: dir.alwaysApply
+      });
+      for (const s of list) {
+        let size = 0;
+        try {
+          size = statSync3(s.filePath).size;
+        } catch {
+        }
+        allSkills.push({
+          id: encodeId(s.filePath),
+          name: s.name,
+          description: s.description,
+          filePath: s.filePath,
+          fileName: basename6(s.filePath),
+          sourceDir: dir.path,
+          sourceLabel: dir.label,
+          sourceType: dir.source,
+          alwaysApply: s.alwaysApply,
+          globs: s.globs,
+          sizeBytes: size
+        });
+      }
+    } catch (err) {
+      console.warn("[skills] failed to read", dir.path, err?.message || err);
+    }
+  }
+  return c.json({
+    directories: dirs.map((d) => ({
+      path: d.path,
+      label: d.label,
+      source: d.source,
+      alwaysApply: d.alwaysApply,
+      exists: existsSync21(d.path),
+      writable: isWritable(d.path)
+    })),
+    skills: allSkills
+  });
+});
+function isWritable(dir) {
+  try {
+    if (!existsSync21(dir)) return false;
+    if (dir.includes("/skills/default")) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+skills.get("/:id", async (c) => {
+  const filePath = decodeId(c.req.param("id"));
+  if (!filePath || !existsSync21(filePath)) {
+    return c.json({ error: "skill not found" }, 404);
+  }
+  const content = await readFile12(filePath, "utf-8");
+  return c.json({
+    id: c.req.param("id"),
+    filePath,
+    fileName: basename6(filePath),
+    content,
+    writable: !filePath.includes("/skills/default")
+  });
+});
+skills.post(
+  "/",
+  zValidator7("json", z22.object({
+    directory: z22.string().min(1),
+    fileName: z22.string().min(1),
+    content: z22.string()
+  })),
+  async (c) => {
+    const { directory, fileName, content } = c.req.valid("json");
+    const cfg = getConfig();
+    const targetDir = resolve11(cfg.resolvedWorkingDirectory, directory);
+    if (targetDir.includes("/skills/default")) {
+      return c.json({ error: "cannot write into built-in skills directory" }, 400);
+    }
+    const safeName = basename6(fileName).replace(/[^A-Za-z0-9._-]/g, "-");
+    const ext = extname9(safeName).toLowerCase();
+    const finalName = ext === ".md" || ext === ".mdc" ? safeName : `${safeName}.md`;
+    const filePath = join16(targetDir, finalName);
+    if (existsSync21(filePath)) {
+      return c.json({ error: `file already exists: ${finalName}` }, 409);
+    }
+    try {
+      await mkdir5(targetDir, { recursive: true });
+      await writeFile6(filePath, content, "utf-8");
+    } catch (err) {
+      return c.json({ error: err?.message || "write failed" }, 500);
+    }
+    return c.json({ id: encodeId(filePath), filePath, fileName: finalName }, 201);
+  }
+);
+skills.put(
+  "/:id",
+  zValidator7("json", z22.object({ content: z22.string() })),
+  async (c) => {
+    const filePath = decodeId(c.req.param("id"));
+    if (!filePath || !existsSync21(filePath)) return c.json({ error: "skill not found" }, 404);
+    if (filePath.includes("/skills/default")) {
+      return c.json({ error: "built-in skills are read-only" }, 400);
+    }
+    await writeFile6(filePath, c.req.valid("json").content, "utf-8");
+    return c.json({ ok: true });
+  }
+);
+skills.delete("/:id", async (c) => {
+  const filePath = decodeId(c.req.param("id"));
+  if (!filePath || !existsSync21(filePath)) return c.json({ error: "skill not found" }, 404);
+  if (filePath.includes("/skills/default")) {
+    return c.json({ error: "built-in skills are read-only" }, 400);
+  }
+  await unlink3(filePath);
+  return c.json({ ok: true });
+});
+skills.post(
+  "/directories",
+  zValidator7("json", z22.object({ path: z22.string().min(1) })),
+  (c) => {
+    const cfg = getConfig();
+    const inputPath = c.req.valid("json").path.trim();
+    const abs = resolve11(cfg.resolvedWorkingDirectory, inputPath);
+    const current = cfg.skills?.additionalDirectories || [];
+    if (current.some((d) => resolve11(cfg.resolvedWorkingDirectory, d) === abs)) {
+      return c.json({ error: "directory already added" }, 409);
+    }
+    const next = [...current, abs];
+    setSkillsAdditionalDirectories(next);
+    return c.json({ ok: true, path: abs, exists: existsSync21(abs) }, 201);
+  }
+);
+skills.delete("/directories", (c) => {
+  const inputPath = c.req.query("path");
+  if (!inputPath) return c.json({ error: "path query param required" }, 400);
+  const cfg = getConfig();
+  const abs = resolve11(cfg.resolvedWorkingDirectory, inputPath);
+  const current = cfg.skills?.additionalDirectories || [];
+  const next = current.filter((d) => resolve11(cfg.resolvedWorkingDirectory, d) !== abs);
+  setSkillsAdditionalDirectories(next);
+  return c.json({ ok: true });
+});
+
 // src/server/auth/cf-access.ts
 init_config();
 import { createRemoteJWKSet, jwtVerify } from "jose";
@@ -15444,13 +16023,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 = dirname8(fileURLToPath4(import.meta.url));
-    const webDir = resolve11(currentDir, "..", "web");
-    if (existsSync20(webDir) && existsSync20(join15(webDir, "package.json"))) {
+    const currentDir = dirname10(fileURLToPath4(import.meta.url));
+    const webDir = resolve12(currentDir, "..", "web");
+    if (existsSync22(webDir) && existsSync22(join17(webDir, "package.json"))) {
       return webDir;
     }
-    const altWebDir = resolve11(currentDir, "..", "..", "web");
-    if (existsSync20(altWebDir) && existsSync20(join15(altWebDir, "package.json"))) {
+    const altWebDir = resolve12(currentDir, "..", "..", "web");
+    if (existsSync22(altWebDir) && existsSync22(join17(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -15473,18 +16052,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve13(true);
+        resolve14(true);
       } else {
-        resolve13(false);
+        resolve14(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve13(false);
+      resolve14(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -15508,30 +16087,30 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join15(webDir, ".next", "BUILD_ID");
-  return existsSync20(buildIdPath);
+  const buildIdPath = join17(webDir, ".next", "BUILD_ID");
+  return existsSync22(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join15(webDir, "src", "app");
-  const pagesDir = join15(webDir, "src", "pages");
-  const rootAppDir = join15(webDir, "app");
-  const rootPagesDir = join15(webDir, "pages");
-  return existsSync20(appDir) || existsSync20(pagesDir) || existsSync20(rootAppDir) || existsSync20(rootPagesDir);
+  const appDir = join17(webDir, "src", "app");
+  const pagesDir = join17(webDir, "src", "pages");
+  const rootAppDir = join17(webDir, "app");
+  const rootPagesDir = join17(webDir, "pages");
+  return existsSync22(appDir) || existsSync22(pagesDir) || existsSync22(rootAppDir) || existsSync22(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join15(webDir, ".next", "standalone", "server.js"),
-    join15(webDir, ".next", "standalone", "web", "server.js")
+    join17(webDir, ".next", "standalone", "server.js"),
+    join17(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
-    if (existsSync20(serverPath)) {
+    if (existsSync22(serverPath)) {
       return serverPath;
     }
   }
   return null;
 }
 function runCommand(command, args, cwd, env) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -15546,10 +16125,10 @@ function runCommand(command, args, cwd, env) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve13({ success: code === 0, output });
+      resolve14({ success: code === 0, output });
     });
     child.on("error", (err) => {
-      resolve13({ success: false, output: err.message });
+      resolve14({ success: false, output: err.message });
     });
   });
 }
@@ -15564,15 +16143,15 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync20(join15(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync20(join15(webDir, "package-lock.json"));
+  const usePnpm = existsSync22(join17(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync22(join17(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 = join15(webDir, "runtime-config.json");
+  const runtimeConfigPath = join17(webDir, "runtime-config.json");
   try {
-    writeFileSync6(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
+    writeFileSync7(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
   } catch (err) {
     if (!quiet) console.warn(`  \u26A0 Could not write runtime config: ${err}`);
@@ -15592,7 +16171,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   if (standaloneServerPath) {
     command = "node";
     args = ["server.js"];
-    cwd = dirname8(standaloneServerPath);
+    cwd = dirname10(standaloneServerPath);
     webEnv.PORT = String(actualPort);
     webEnv.HOSTNAME = "0.0.0.0";
     if (!quiet) console.log("  \u{1F4E6} Starting Web UI from standalone build...");
@@ -15633,10 +16212,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((resolve13) => {
+  const startedPromise = new Promise((resolve14) => {
     const timeout = setTimeout(() => {
       if (!started && !exited) {
-        resolve13(false);
+        resolve14(false);
       }
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
@@ -15650,7 +16229,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);
-        resolve13(true);
+        resolve14(true);
       }
     });
     child.stderr?.on("data", (data) => {
@@ -15662,14 +16241,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);
-      resolve13(false);
+      resolve14(false);
     });
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
       if (!started) {
         clearTimeout(timeout);
-        resolve13(false);
+        resolve14(false);
       }
       webUIProcess = null;
     });
@@ -15692,7 +16271,7 @@ function stopWebUI() {
   }
 }
 async function createApp(options = {}) {
-  const app = new Hono9();
+  const app = new Hono10();
   app.use("*", cors({
     origin: "*",
     // Allow all origins
@@ -15720,6 +16299,7 @@ async function createApp(options = {}) {
   app.route("/api/schedules", schedulesRouter);
   app.route("/api/orchestrator", orchestratorRouter);
   app.route("/api/mcp", mcpRouter);
+  app.route("/api/skills", skills);
   app.route("/api/webhooks", webhooksRouter);
   const config = getConfig();
   const webhookToken = config?.webhooks?.token;
@@ -15785,8 +16365,8 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync20(config.resolvedWorkingDirectory)) {
-    mkdirSync9(config.resolvedWorkingDirectory, { recursive: true });
+  if (!existsSync22(config.resolvedWorkingDirectory)) {
+    mkdirSync10(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   if (!config.resolvedRemoteServer.url) {
@@ -16344,18 +16924,18 @@ function generateOpenAPISpec() {
 init_config();
 init_semantic();
 init_db();
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync7, readFileSync as readFileSync10, existsSync as existsSync21, statSync as statSync3 } from "fs";
-import { resolve as resolve12, join as join16 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8, readFileSync as readFileSync11, existsSync as existsSync23, statSync as statSync4 } from "fs";
+import { resolve as resolve13, join as join18 } from "path";
 function getCliVersion() {
-  const here = dirname9(fileURLToPath5(import.meta.url));
+  const here = dirname11(fileURLToPath5(import.meta.url));
   const candidates = [
-    join16(here, "..", "package.json"),
-    join16(here, "..", "..", "package.json"),
-    join16(process.cwd(), "package.json")
+    join18(here, "..", "package.json"),
+    join18(here, "..", "..", "package.json"),
+    join18(process.cwd(), "package.json")
   ];
   for (const p of candidates) {
     try {
-      const pkg = JSON.parse(readFileSync10(p, "utf8"));
+      const pkg = JSON.parse(readFileSync11(p, "utf8"));
       if (pkg.name === "sparkecoder" && pkg.version) return pkg.version;
     } catch {
     }
@@ -16396,18 +16976,18 @@ async function getActiveStream(baseUrl, sessionId) {
   return { hasActiveStream: false };
 }
 function promptApproval(rl, toolName, input) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     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/a(lways)]: `), (answer) => {
       const lower = answer.toLowerCase().trim();
       if (lower === "a" || lower === "always") {
-        resolve13("always");
+        resolve14("always");
       } else if (lower.startsWith("y")) {
-        resolve13("approve");
+        resolve14("approve");
       } else {
-        resolve13("reject");
+        resolve14("reject");
       }
     });
   });
@@ -16604,9 +17184,9 @@ async function runChat(options) {
         input: process.stdin,
         output: process.stdout
       });
-      const apiKey = await new Promise((resolve13) => {
+      const apiKey = await new Promise((resolve14) => {
         keyRl.question(chalk.cyan("Enter your AI Gateway API key: "), (answer) => {
-          resolve13(answer.trim());
+          resolve14(answer.trim());
         });
       });
       keyRl.close();
@@ -17002,8 +17582,8 @@ program.command("task").description("Run an autonomous task that completes witho
   let outputSchema;
   try {
     const schemaStr = options.schema;
-    if (existsSync21(schemaStr)) {
-      outputSchema = JSON.parse(readFileSync10(schemaStr, "utf-8"));
+    if (existsSync23(schemaStr)) {
+      outputSchema = JSON.parse(readFileSync11(schemaStr, "utf-8"));
     } else {
       outputSchema = JSON.parse(schemaStr);
     }
@@ -17070,28 +17650,28 @@ program.command("init").description("Create a sparkecoder.config.json file").opt
   let configLocation;
   if (options.global) {
     const appDataDir = ensureAppDataDirectory();
-    configPath = join16(appDataDir, "sparkecoder.config.json");
+    configPath = join18(appDataDir, "sparkecoder.config.json");
     configLocation = "global";
   } else {
-    configPath = resolve12(process.cwd(), "sparkecoder.config.json");
+    configPath = resolve13(process.cwd(), "sparkecoder.config.json");
     configLocation = "local";
   }
-  if (existsSync21(configPath) && !options.force) {
+  if (existsSync23(configPath) && !options.force) {
     console.log(chalk.yellow("Config file already exists. Use --force to overwrite."));
     console.log(chalk.dim(`  ${configPath}`));
     return;
   }
   const config = createDefaultConfig();
-  writeFileSync7(configPath, JSON.stringify(config, null, 2));
+  writeFileSync8(configPath, JSON.stringify(config, null, 2));
   console.log(chalk.green(`\u2713 Created ${configLocation} config`));
   console.log(chalk.dim(`  ${configPath}`));
   console.log(chalk.dim("Set AI_GATEWAY_API_KEY and run sparkecoder to start"));
 });
 program.command("slack-setup").description("Interactively configure Slack integration (bot token + signing secret)").option("--bot-token <token>", "Slack bot token (xoxb-...)").option("--signing-secret <secret>", "Slack app signing secret").option("-g, --global", "Write to global config (~/.sparkecoder/sparkecoder.config.json)").action(async (options) => {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (label, fallback = "") => new Promise((resolve13) => {
+  const ask = (label, fallback = "") => new Promise((resolve14) => {
     const suffix = fallback ? ` (${fallback})` : "";
-    rl.question(`${label}${suffix}: `, (answer) => resolve13(answer.trim() || fallback));
+    rl.question(`${label}${suffix}: `, (answer) => resolve14(answer.trim() || fallback));
   });
   try {
     const botToken = options.botToken || await ask("Slack bot token (xoxb-...)");
@@ -17101,11 +17681,11 @@ program.command("slack-setup").description("Interactively configure Slack integr
       console.error(chalk.red("Both bot token and signing secret are required."));
       process.exit(1);
     }
-    const configPath = options.global ? join16(ensureAppDataDirectory(), "sparkecoder.config.json") : resolve12(process.cwd(), "sparkecoder.config.json");
+    const configPath = options.global ? join18(ensureAppDataDirectory(), "sparkecoder.config.json") : resolve13(process.cwd(), "sparkecoder.config.json");
     let existing = {};
-    if (existsSync21(configPath)) {
+    if (existsSync23(configPath)) {
       try {
-        existing = JSON.parse(readFileSync10(configPath, "utf-8"));
+        existing = JSON.parse(readFileSync11(configPath, "utf-8"));
       } catch {
       }
     } else {
@@ -17117,7 +17697,7 @@ program.command("slack-setup").description("Interactively configure Slack integr
       signingSecret,
       defaultOrchestratorName: existing.slack?.defaultOrchestratorName ?? "orchestrator"
     };
-    writeFileSync7(configPath, JSON.stringify(existing, null, 2));
+    writeFileSync8(configPath, JSON.stringify(existing, null, 2));
     console.log(chalk.green(`
 \u2713 Slack configured`));
     console.log(chalk.dim(`  ${configPath}`));
@@ -17369,9 +17949,9 @@ program.command("cloudflared-setup").description("Auto-detect cloudflared + set
     }
     const verOut = run("cloudflared", ["--version"]).stdout?.toString().split("\n")[0] || "installed";
     console.log(chalk.green("\u2713"), "cloudflared:", chalk.dim(verOut));
-    const cfDir = join16(homedir2(), ".cloudflared");
-    const certPath = join16(cfDir, "cert.pem");
-    if (!existsSync21(certPath)) {
+    const cfDir = join18(homedir2(), ".cloudflared");
+    const certPath = join18(cfDir, "cert.pem");
+    if (!existsSync23(certPath)) {
       console.log(chalk.yellow("No Cloudflare login cert found."));
       if (await confirm("Run `cloudflared tunnel login` now (opens a browser)?", true)) {
         run("cloudflared", ["tunnel", "login"], { inheritIO: true, check: true });
@@ -17415,8 +17995,8 @@ program.command("cloudflared-setup").description("Auto-detect cloudflared + set
         return;
       }
     }
-    const credsFile = tunnel.credentials_file || join16(cfDir, `${tunnel.id}.json`);
-    if (!existsSync21(credsFile)) {
+    const credsFile = tunnel.credentials_file || join18(cfDir, `${tunnel.id}.json`);
+    if (!existsSync23(credsFile)) {
       console.log(chalk.yellow(`Credentials file not found at ${credsFile}. The tunnel may still work via cert.pem.`));
     }
     let hostname = options.hostname;
@@ -17439,7 +18019,7 @@ program.command("cloudflared-setup").description("Auto-detect cloudflared + set
         console.log(chalk.yellow("DNS route warning:"), err.trim().split("\n").slice(-2).join(" "));
       }
     }
-    const configPath = join16(cfDir, "config.yml");
+    const configPath = join18(cfDir, "config.yml");
     const configBody = `tunnel: ${tunnel.id}
 credentials-file: ${credsFile}
 ingress:
@@ -17450,14 +18030,14 @@ ingress:
   - service: http_status:404
 `;
     let wroteConfig = false;
-    if (existsSync21(configPath)) {
-      const existing = readFileSync10(configPath, "utf8");
+    if (existsSync23(configPath)) {
+      const existing = readFileSync11(configPath, "utf8");
       if (existing.trim() === configBody.trim()) {
         console.log(chalk.green("\u2713"), `config.yml already up to date: ${configPath}`);
         wroteConfig = true;
       } else if (await confirm(`A different ${configPath} exists. Overwrite (a backup will be saved)?`, false)) {
         copyFileSync(configPath, `${configPath}.bak.${Date.now()}`);
-        writeFileSync7(configPath, configBody);
+        writeFileSync8(configPath, configBody);
         console.log(chalk.green("\u2713"), `wrote ${configPath} (previous saved as .bak.*)`);
         wroteConfig = true;
       } else {
@@ -17465,7 +18045,7 @@ ingress:
         console.log(chalk.cyan(configBody));
       }
     } else {
-      writeFileSync7(configPath, configBody);
+      writeFileSync8(configPath, configBody);
       console.log(chalk.green("\u2713"), `wrote ${configPath}`);
       wroteConfig = true;
     }
@@ -17566,7 +18146,7 @@ program.command("config").description("Show current configuration").option("-c,
 });
 program.command("index").description("Index repository for semantic search").option("--status", "Show index status instead of indexing").option("--full", "Force full re-index (ignore existing embeddings)").option("-w, --working-dir <path>", "Working directory (defaults to current directory)").option("-c, --config <path>", "Path to config file").option("-v, --verbose", "Show detailed progress").action(async (options) => {
   try {
-    const workingDir = options.workingDir ? resolve12(options.workingDir) : process.cwd();
+    const workingDir = options.workingDir ? resolve13(options.workingDir) : process.cwd();
     let config = loadConfig(options.config, workingDir);
     const remoteUrl = config.resolvedRemoteServer.url;
     if (!remoteUrl) {
@@ -17700,7 +18280,7 @@ Indexing ${chalk.cyan(namespace)}...
 });
 program.command("search").description("Search indexed repository using semantic search").argument("<query>", "Search query").option("-n, --num <count>", "Number of results to show", "5").option("-w, --working-dir <path>", "Working directory (defaults to current directory)").option("-c, --config <path>", "Path to config file").action(async (query, options) => {
   try {
-    const workingDir = options.workingDir ? resolve12(options.workingDir) : process.cwd();
+    const workingDir = options.workingDir ? resolve13(options.workingDir) : process.cwd();
     const config = loadConfig(options.config, workingDir);
     const remoteUrl = config.resolvedRemoteServer.url;
     if (!remoteUrl) {
@@ -17955,17 +18535,17 @@ program.command("request-permissions").description("Open System Settings to the
 });
 {
   let stateFilePath = function() {
-    return join16(ensureAppDataDirectory(), "recordings.json");
+    return join18(ensureAppDataDirectory(), "recordings.json");
   }, readState = function() {
     const p = stateFilePath();
-    if (!existsSync21(p)) return [];
+    if (!existsSync23(p)) return [];
     try {
-      return JSON.parse(readFileSync10(p, "utf-8"));
+      return JSON.parse(readFileSync11(p, "utf-8"));
     } catch {
       return [];
     }
   }, writeState = function(rows) {
-    writeFileSync7(stateFilePath(), JSON.stringify(rows, null, 2), { mode: 384 });
+    writeFileSync8(stateFilePath(), JSON.stringify(rows, null, 2), { mode: 384 });
   }, isAlive = function(pid) {
     try {
       process.kill(pid, 0);
@@ -17980,16 +18560,16 @@ program.command("request-permissions").description("Open System Settings to the
   const record = program.command("record").description("Start/stop screen recordings");
   record.command("start").description("Start a screen recording (returns id, path, pid as JSON)").option("--name <slug>", "Optional human-readable label for the recording").option("--dir <path>", "Output directory (default: ~/recordings)").action(async (opts) => {
     const { homedir: homedir2, platform: osPlatform } = await import("os");
-    const outDir = opts.dir ? resolve12(opts.dir.replace(/^~/, homedir2())) : join16(homedir2(), "recordings");
-    mkdirSync10(outDir, { recursive: true });
+    const outDir = opts.dir ? resolve13(opts.dir.replace(/^~/, homedir2())) : join18(homedir2(), "recordings");
+    mkdirSync11(outDir, { recursive: true });
     const id = `rec-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
     const ext = osPlatform() === "darwin" ? "mov" : "mp4";
     const filename = `${id}${opts.name ? `-${String(opts.name).replace(/[^a-z0-9-]+/gi, "-").toLowerCase()}` : ""}.${ext}`;
-    const path = join16(outDir, filename);
+    const path = join18(outDir, filename);
     let cmd;
     let args;
     if (osPlatform() === "darwin") {
-      cmd = existsSync21("/usr/sbin/screencapture") ? "/usr/sbin/screencapture" : "screencapture";
+      cmd = existsSync23("/usr/sbin/screencapture") ? "/usr/sbin/screencapture" : "screencapture";
       args = ["-v", "-C", "-k", path];
     } else if (osPlatform() === "linux") {
       const display = process.env.DISPLAY || ":0.0";
@@ -18092,8 +18672,8 @@ program.command("request-permissions").description("Open System Settings to the
       }
     }
     writeState(rows.filter((r) => r.id !== id));
-    const fileExists = existsSync21(row.path);
-    const sizeMb = fileExists ? Math.round(statSync3(row.path).size / (1024 * 1024) * 10) / 10 : 0;
+    const fileExists = existsSync23(row.path);
+    const sizeMb = fileExists ? Math.round(statSync4(row.path).size / (1024 * 1024) * 10) / 10 : 0;
     console.log(JSON.stringify({
       id,
       path: row.path,
@@ -18127,7 +18707,7 @@ program.command("request-permissions").description("Open System Settings to the
           }
         }
       }
-      stopped.push({ id: r.id, path: r.path, ok: existsSync21(r.path) });
+      stopped.push({ id: r.id, path: r.path, ok: existsSync23(r.path) });
     }
     writeState([]);
     console.log(JSON.stringify({ stopped }));