sparkecoder 0.1.98 → 0.1.99

package/dist/agent/index.js

@@ -56,7 +56,49 @@ var init_types = __esm({
       computerUseEnabled: z.boolean().optional(),
       // Display dimensions for the computer use tool (defaults: 1280x800).
       computerUseDisplayWidth: z.number().int().positive().optional(),
-      computerUseDisplayHeight: z.number().int().positive().optional()
+      computerUseDisplayHeight: z.number().int().positive().optional(),
+      // 'orchestrator' = supervisor session; 'worker' = task spawned by an orchestrator.
+      role: z.enum(["orchestrator", "worker", "chat"]).optional(),
+      // Optional persona / extra system-prompt text appended to the orchestrator's
+      // system prompt (e.g. "speak in haiku", "answer in Korean", "be terse").
+      personality: z.string().optional(),
+      // For workers: the orchestrator session that spawned them. Used so
+      // terminal events (complete_task / task_failed / ask_question_to_user)
+      // can push system events back to the orchestrator's inbox.
+      orchestratorSessionId: z.string().optional(),
+      // Persisted Slack thread context the orchestrator can reply to.
+      slack: z.object({
+        channel: z.string().optional(),
+        threadTs: z.string().optional(),
+        teamId: z.string().optional()
+      }).optional(),
+      // Recurring prompts owned by this orchestrator. Stored inline on the
+      // session row so we don't need a separate DB collection.
+      schedules: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        cron: z.string(),
+        prompt: z.string(),
+        replyChannel: z.string().optional(),
+        enabled: z.boolean().default(true),
+        lastFiredAt: z.string().optional(),
+        // ISO date
+        createdAt: z.string()
+        // ISO date
+      })).optional(),
+      // Custom token-protected inbound webhook URLs.
+      webhooks: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        token: z.string(),
+        wake: z.enum(["now", "next"]).default("now"),
+        template: z.string().optional(),
+        hitCount: z.number().int().default(0),
+        lastHitAt: z.string().optional(),
+        // ISO date
+        createdAt: z.string()
+        // ISO date
+      })).optional()
     });
     VectorGatewayConfigSchema = z.object({
       // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
@@ -144,7 +186,74 @@ var init_types = __esm({
       // If configured, uses remote MongoDB instead of local SQLite
       remoteServer: RemoteServerConfigSchema,
       // Vector Gateway configuration for semantic search
-      vectorGateway: VectorGatewayConfigSchema
+      vectorGateway: VectorGatewayConfigSchema,
+      // Slack integration. When configured, the orchestrator can post to Slack
+      // and Slack `app_mention` events are routed into the orchestrator session.
+      slack: z.object({
+        botToken: z.string().optional(),
+        signingSecret: z.string().optional(),
+        defaultOrchestratorName: z.string().optional().default("orchestrator"),
+        // Allowlist controls — when set, only matching events reach the orchestrator.
+        // Empty arrays = "no allowlist" => allow all (subject to allowDmsFromAnyone below).
+        allowedUsers: z.array(z.string()).optional().default([]),
+        // Slack user IDs (U0123...)
+        allowedChannels: z.array(z.string()).optional().default([]),
+        // Slack channel IDs (C0123...)
+        // If true (default), the bot replies to DMs from anyone. If false, the user
+        // must also appear in `allowedUsers`.
+        allowDmsFromAnyone: z.boolean().optional().default(true),
+        // When true, denied @mentions / DMs get a friendly canned reply
+        // (no AI / no orchestrator). Use {user} and {channel} placeholders.
+        deniedReplyEnabled: z.boolean().optional().default(true),
+        deniedReplyTemplate: z.string().optional().default(
+          "Sorry, you don't have permission to use this bot. (Contact the bot owner if you think this is a mistake.)"
+        )
+      }).partial().optional(),
+      // MCP integrations. Each server is connected on demand and its tools are
+      // merged into the agent's toolset under `mcp_<server-name>_<tool>` keys.
+      mcp: z.object({
+        servers: z.array(z.object({
+          id: z.string(),
+          name: z.string(),
+          // human-friendly; also used as tool prefix
+          transport: z.enum(["http", "sse", "stdio"]),
+          url: z.string().optional(),
+          // http/sse
+          headers: z.record(z.string(), z.string()).optional(),
+          // http/sse (e.g. Authorization: Bearer ...)
+          command: z.string().optional(),
+          // stdio
+          args: z.array(z.string()).optional(),
+          // stdio
+          enabled: z.boolean().default(true),
+          createdAt: z.string(),
+          // ISO date
+          // OAuth scaffolding — present so tokens can be persisted by the
+          // settings UI once the auth flow completes. Bearer tokens can also
+          // be stored directly via `headers.Authorization` for now.
+          oauth: z.object({
+            authorizationUrl: z.string().optional(),
+            tokenUrl: z.string().optional(),
+            clientId: z.string().optional(),
+            clientSecret: z.string().optional(),
+            accessToken: z.string().optional(),
+            refreshToken: z.string().optional(),
+            expiresAt: z.string().optional()
+          }).partial().optional()
+        })).optional().default([])
+      }).partial().optional(),
+      // Authentication for the public (cloudflared) surface. When
+      // auth.cfAccess.enabled is true, every non-loopback request must carry a
+      // valid Cf-Access-Jwt-Assertion header whose `email` claim is in
+      // `auth.allowedEmails`. Slack events and /health bypass the check.
+      auth: z.object({
+        cfAccess: z.object({
+          enabled: z.boolean().optional().default(false),
+          teamDomain: z.string().optional(),
+          audTag: z.string().optional()
+        }).partial().optional(),
+        allowedEmails: z.array(z.string()).optional().default([])
+      }).partial().optional()
     });
   }
 });
@@ -164,12 +273,43 @@ function getAppDataDirectory() {
       return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
   }
 }
+function ensureAppDataDirectory() {
+  const dir = getAppDataDirectory();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
 function getConfig() {
   if (!cachedConfig) {
     throw new Error("Config not loaded. Call loadConfig first.");
   }
   return cachedConfig;
 }
+function setMcpServers(servers2) {
+  if (cachedConfig) {
+    const cur = cachedConfig.mcp || {};
+    cachedConfig.mcp = { ...cur, servers: servers2 };
+  }
+  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.mcp = { ...raw.mcp || {}, servers: servers2 };
+    writeFileSync(target, JSON.stringify(raw, null, 2));
+  } catch (err) {
+    console.warn("[config] failed to persist mcp config:", err?.message || err);
+  }
+}
 function requiresApproval(toolName, sessionConfig) {
   const config = getConfig();
   if (sessionConfig?.toolApprovals?.["*"] !== void 0) {
@@ -187,6 +327,33 @@ function requiresApproval(toolName, sessionConfig) {
   }
   return false;
 }
+function createDefaultConfig() {
+  return {
+    defaultModel: "anthropic/claude-opus-4.7",
+    // workingDirectory is intentionally not set - defaults to where CLI is run
+    toolApprovals: {
+      bash: true,
+      write_file: false,
+      read_file: false,
+      load_skill: false,
+      todo: false
+    },
+    skills: {
+      directory: "./skills",
+      additionalDirectories: []
+    },
+    context: {
+      maxChars: 2e5,
+      autoSummarize: true,
+      keepRecentMessages: 10
+    },
+    server: {
+      port: 3141,
+      host: "127.0.0.1"
+    },
+    databasePath: "./sparkecoder.db"
+  };
+}
 var cachedConfig, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
 var init_config = __esm({
   "src/config/index.ts"() {
@@ -661,13 +828,43 @@ var init_remote = __esm({
 });
 
 // src/db/index.ts
+var db_exports = {};
+__export(db_exports, {
+  activeStreamQueries: () => activeStreamQueries,
+  checkpointQueries: () => checkpointQueries,
+  closeDatabase: () => closeDatabase,
+  fileBackupQueries: () => fileBackupQueries,
+  getDb: () => getDb,
+  indexStatusQueries: () => indexStatusQueries,
+  indexedChunkQueries: () => indexedChunkQueries,
+  initDatabase: () => initDatabase,
+  isUsingRemote: () => isUsingRemote,
+  messageQueries: () => messageQueries,
+  sessionQueries: () => sessionQueries,
+  skillQueries: () => skillQueries,
+  subagentQueries: () => subagentQueries,
+  terminalQueries: () => terminalQueries,
+  todoQueries: () => todoQueries,
+  toolExecutionQueries: () => toolExecutionQueries
+});
+function initDatabase(config) {
+  initRemoteDatabase(config.url, config.authKey);
+  initialized = true;
+}
 function getDb() {
   if (!initialized) {
     throw new Error("Database not initialized. Call initDatabase first.");
   }
   return {};
 }
-var initialized, sessionQueries, messageQueries, toolExecutionQueries, todoQueries, skillQueries, fileBackupQueries, subagentQueries, indexStatusQueries;
+function isUsingRemote() {
+  return true;
+}
+function closeDatabase() {
+  closeRemoteDatabase();
+  initialized = false;
+}
+var initialized, sessionQueries, messageQueries, toolExecutionQueries, todoQueries, skillQueries, terminalQueries, activeStreamQueries, checkpointQueries, fileBackupQueries, subagentQueries, indexedChunkQueries, indexStatusQueries;
 var init_db = __esm({
   "src/db/index.ts"() {
     "use strict";
@@ -678,8 +875,12 @@ var init_db = __esm({
     toolExecutionQueries = remoteToolExecutionQueries;
     todoQueries = remoteTodoQueries;
     skillQueries = remoteSkillQueries;
+    terminalQueries = remoteTerminalQueries;
+    activeStreamQueries = remoteActiveStreamQueries;
+    checkpointQueries = remoteCheckpointQueries;
     fileBackupQueries = remoteFileBackupQueries;
     subagentQueries = remoteSubagentQueries;
+    indexedChunkQueries = remoteIndexedChunkQueries;
     indexStatusQueries = remoteIndexStatusQueries;
   }
 });
@@ -783,20 +984,20 @@ async function loadSkillsFromDirectory(directory, options = {}) {
   }
   const skills = [];
   const entries = await readdir(directory, { withFileTypes: true });
-  for (const entry of entries) {
+  for (const entry2 of entries) {
     let filePath;
     let fileName;
-    if (entry.isDirectory()) {
-      const skillMdPath = resolve6(directory, entry.name, "SKILL.md");
+    if (entry2.isDirectory()) {
+      const skillMdPath = resolve6(directory, entry2.name, "SKILL.md");
       if (existsSync10(skillMdPath)) {
         filePath = skillMdPath;
-        fileName = entry.name;
+        fileName = entry2.name;
       } else {
         continue;
       }
-    } else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdc")) {
-      filePath = resolve6(directory, entry.name);
-      fileName = entry.name;
+    } else if (entry2.name.endsWith(".md") || entry2.name.endsWith(".mdc")) {
+      filePath = resolve6(directory, entry2.name);
+      fileName = entry2.name;
     } else {
       continue;
     }
@@ -1425,6 +1626,63 @@ var init_semantic_search = __esm({
   }
 });
 
+// src/orchestrator/conversation-archive.ts
+var conversation_archive_exports = {};
+__export(conversation_archive_exports, {
+  appendTurn: () => appendTurn,
+  flattenContent: () => flattenContent,
+  getHistoryDir: () => getHistoryDir,
+  listSessionArchives: () => listSessionArchives
+});
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, appendFileSync as appendFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join9 } from "path";
+function getHistoryDir() {
+  const dir = join9(ensureAppDataDirectory(), "history");
+  if (!existsSync16(dir)) mkdirSync6(dir, { recursive: true });
+  return dir;
+}
+function appendTurn(turn) {
+  try {
+    const dir = getHistoryDir();
+    const path = join9(dir, `${turn.sessionId}.jsonl`);
+    const line = JSON.stringify({
+      ts: turn.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: turn.sessionId,
+      sessionName: turn.sessionName,
+      role: turn.role,
+      content: turn.content,
+      channel: turn.channel
+    });
+    appendFileSync2(path, line + "\n", "utf-8");
+  } catch (err) {
+    console.warn(`[conversation-archive] failed to persist turn for ${turn.sessionId}: ${err?.message || err}`);
+  }
+}
+function flattenContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((p) => {
+      if (!p || typeof p !== "object") return "";
+      if (p.type === "text" && typeof p.text === "string") return p.text;
+      if (p.type === "image") return `[image${p.filename ? ` ${p.filename}` : ""}]`;
+      if (p.type === "file") return `[file${p.filename ? ` ${p.filename}` : ""}]`;
+      return "";
+    }).filter(Boolean).join(" ");
+  }
+  return "";
+}
+function listSessionArchives() {
+  const dir = getHistoryDir();
+  if (!existsSync16(dir)) return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
+}
+var init_conversation_archive = __esm({
+  "src/orchestrator/conversation-archive.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
 // src/browser/stream-proxy.ts
 var stream_proxy_exports = {};
 __export(stream_proxy_exports, {
@@ -1634,9 +1892,9 @@ __export(recorder_exports, {
 import { exec as exec6 } from "child_process";
 import { promisify as promisify6 } 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 join9 } from "path";
+import { join as join11 } from "path";
 import { tmpdir as tmpdir2 } from "os";
-import { nanoid as nanoid5 } from "nanoid";
+import { nanoid as nanoid8 } from "nanoid";
 async function checkFfmpeg() {
   try {
     await execAsync6("ffmpeg -version", { timeout: 5e3 });
@@ -1691,21 +1949,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join9(tmpdir2(), `sparkecoder-recording-${nanoid5(8)}`);
+        const workDir = join11(tmpdir2(), `sparkecoder-recording-${nanoid8(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join9(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 = join9(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join11(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
             await execAsync6(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join9(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 {
@@ -1717,7 +1975,7 @@ var init_recorder = __esm({
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join9(workDir, f)).catch(() => {
+              await unlink2(join11(workDir, f)).catch(() => {
               });
             }
           }
@@ -1742,7 +2000,7 @@ var init_recorder = __esm({
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool14,
+  tool as tool15,
   stepCountIs as stepCountIs2
 } from "ai";
 
@@ -1950,8 +2208,8 @@ var SUBAGENT_MODELS = {
 // src/agent/index.ts
 init_db();
 init_config();
-import { z as z15 } from "zod";
-import { nanoid as nanoid6 } from "nanoid";
+import { z as z16 } from "zod";
+import { nanoid as nanoid9 } from "nanoid";
 
 // src/tools/bash.ts
 import { tool } from "ai";
@@ -3133,7 +3391,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;
@@ -3152,7 +3410,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup2();
-          resolve10(diagnostics.get(normalized) || []);
+          resolve11(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -3363,20 +3621,20 @@ async function getClientsForFile(filePath) {
   return client ? [client] : [];
 }
 async function touchFile(filePath, waitForDiagnostics = false) {
-  const clients = await getClientsForFile(filePath);
-  if (clients.length === 0) {
+  const clients2 = await getClientsForFile(filePath);
+  if (clients2.length === 0) {
     return;
   }
-  await Promise.all(clients.map((client) => client.notifyOpen(filePath)));
+  await Promise.all(clients2.map((client) => client.notifyOpen(filePath)));
   if (waitForDiagnostics) {
-    await Promise.all(clients.map((client) => client.waitForDiagnostics(filePath)));
+    await Promise.all(clients2.map((client) => client.waitForDiagnostics(filePath)));
   }
 }
 async function getDiagnostics(filePath) {
   const normalized = normalizePath(filePath);
-  const clients = await getClientsForFile(normalized);
+  const clients2 = await getClientsForFile(normalized);
   const allDiagnostics = [];
-  for (const client of clients) {
+  for (const client of clients2) {
     const diags = client.getDiagnostics(normalized);
     allDiagnostics.push(...diags);
   }
@@ -3507,7 +3765,7 @@ Working directory: ${options.workingDirectory}`,
                 isChunked: true
               });
               if (chunkCount > 1) {
-                await new Promise((resolve10) => setTimeout(resolve10, 0));
+                await new Promise((resolve11) => setTimeout(resolve11, 0));
               }
             }
           }
@@ -4103,16 +4361,16 @@ async function findSupportedFiles(dir, workingDirectory, maxFiles = 50) {
     if (files.length >= maxFiles) return;
     try {
       const entries = await readdir2(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
+      for (const entry2 of entries) {
         if (files.length >= maxFiles) break;
-        const fullPath = resolve7(currentDir, entry.name);
-        if (entry.isDirectory()) {
-          if (["node_modules", ".git", "dist", "build", ".next", "coverage"].includes(entry.name)) {
+        const fullPath = resolve7(currentDir, entry2.name);
+        if (entry2.isDirectory()) {
+          if (["node_modules", ".git", "dist", "build", ".next", "coverage"].includes(entry2.name)) {
             continue;
           }
           await walk(fullPath);
-        } else if (entry.isFile()) {
-          const ext = extname5(entry.name);
+        } else if (entry2.isFile()) {
+          const ext = extname5(entry2.name);
           if (supportedExtensions.includes(ext)) {
             files.push(fullPath);
           }
@@ -4453,8 +4711,8 @@ var Subagent = class {
       if (eventQueue.length > 0) {
         yield eventQueue.shift();
       } else if (!done) {
-        const event = await new Promise((resolve10) => {
-          resolveNext = resolve10;
+        const event = await new Promise((resolve11) => {
+          resolveNext = resolve11;
         });
         if (event) {
           yield event;
@@ -4605,16 +4863,16 @@ async function grepForSymbol(symbol, workingDirectory) {
     let remaining = maxFiles;
     try {
       const entries = await readdir3(dir, { withFileTypes: true });
-      for (const entry of entries) {
+      for (const entry2 of entries) {
         if (remaining <= 0) return null;
-        const fullPath = resolve8(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (IGNORED_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        const fullPath = resolve8(dir, entry2.name);
+        if (entry2.isDirectory()) {
+          if (IGNORED_DIRS.has(entry2.name) || entry2.name.startsWith(".")) continue;
           const found = await search(fullPath, remaining);
           if (found) return found;
           remaining -= 10;
-        } else if (entry.isFile()) {
-          const ext = entry.name.substring(entry.name.lastIndexOf("."));
+        } else if (entry2.isFile()) {
+          const ext = entry2.name.substring(entry2.name.lastIndexOf("."));
           if (!SUPPORTED_EXTS.has(ext)) continue;
           remaining--;
           const content = await readFile8(fullPath, "utf-8");
@@ -6753,6 +7011,84 @@ ${JSON.stringify(outputSchema, null, 2)}
 - **\`ask_question_to_user({ question, context?, choices? })\`** \u2014 Call only when you need information that is not available in the repo, task prompt, files, logs, or tools. Ask one clear question; after the answer is returned, continue working.
 `;
 }
+function buildOrchestratorPromptAddendum() {
+  return `
+## Orchestrator Mode
+
+You are the **orchestrator agent**. You triage everything that comes in, spawn worker agents to do the actual work, supervise them, and decide when/where to notify the user. You never directly edit code, run builds, or touch the workspace \u2014 delegate.
+
+### Channels (where messages come from, and how to reply)
+
+Every user-message you see is tagged at the front with a channel pill describing where it came from. **You are responsible for routing replies to the correct channel.** Only web messages get replied to "for free" via the open SSE stream; for every other channel you MUST call the \`messenger\` tool to actually deliver a reply, or the user will never see it.
+
+Pill formats:
+
+- \`[WEB] ...\` \u2014 typed in the web dashboard. Your assistant text streams back automatically. No tool call needed.
+- \`[SLACK channel=C0123 thread=1700000000.001 user=U0123] ...\` \u2014 a Slack mention or DM. To reply: \`messenger({action:'post', channel:'slack', to:'C0123', threadTs:'1700000000.001', text:'...'})\`. **Always set \`threadTs\`** so the reply lands in the same thread.
+- \`[SYSTEM worker.completed worker-name] ...\` \u2014 a worker you spawned finished. Look back at the conversation: where did the request originate?
+  - If the original request was \`[WEB]\`, a normal text reply is enough (the user is watching).
+  - If it was \`[SLACK ...]\`, post the result to that Slack thread via \`messenger\`.
+  - If it was a schedule with \`replyChannel\`, post there.
+- \`[SYSTEM worker.failed worker-name] ...\` \u2014 same routing logic as completed; tell the user.
+- \`[SYSTEM worker.question worker-name] ...\` \u2014 a worker is blocked on \`ask_question_to_user\`. Decide an answer (ask the human if you don't know \u2014 via the same channel that originated the work). Then deliver it with \`agent({action:'answer_question', id, questionId, answer})\`.
+- \`[SCHEDULE name] ...\` \u2014 a scheduled prompt fired. Treat as a user request from that schedule. Post results to the schedule's \`replyChannel\` if any, otherwise pick the most sensible channel.
+- \`[WEBHOOK name] ...\` \u2014 an external service hit one of your webhook URLs. Body is the request body (verbatim or per the webhook's template).
+
+### Handling delivery failures
+
+If \`messenger({action:'post', ...})\` returns \`{ok:false, error:'...'}\` (e.g. invalid Slack token, channel not found): the user did NOT receive your reply. Try:
+1. Re-checking the destination (channel id, thread ts).
+2. Falling back to another channel the user is reachable on (e.g. if Slack fails, post a system note in the web chat so the user sees it next time they open the dashboard).
+3. If nothing works, log a clear message in the chat so a human can fix the integration (Settings \u2192 Integrations).
+**Never silently swallow a delivery failure.**
+
+### Hard rules
+
+- Never edit code, run builds, or modify files yourself. \`bash\`, \`write_file\` etc. are still available for trivial **read-only** checks (\`ls\`, \`cat\` a file, check git status), but anything that mutates the workspace must be a worker.
+- Give workers **clear, self-contained goals**. Include any context they'd otherwise have to ask you about.
+- Prefer \`agent({action:'message'})\` (queued) over \`agent({action:'stop'})\` for course corrections.
+- Don't poll. Worker completions wake you automatically via SYSTEM events.
+
+### Tools (4 total \u2014 each takes an \`action\` field)
+
+\`\`\`
+agent({action: 'list' | 'get' | 'spawn' | 'message' | 'answer_question' | 'stop', ...})
+messenger({action: 'list_channels' | 'post', ...})
+schedule({action: 'create' | 'list' | 'update' | 'delete' | 'pause' | 'resume', ...})
+webhook({action: 'create' | 'list' | 'update' | 'delete', ...})
+\`\`\`
+
+You ALSO have the regular agent toolset (\`bash\`, \`read_file\`, \`write_file\`, \`load_skill\`, \`linter\`, \`explore_agent\`, \`code_graph\`, etc.) for low-level work.
+
+### Self-extension via skills + filesystem
+
+You manage your own configuration by editing files. Load the relevant skill first to get the file path and schema:
+
+- **MCP integrations** \u2014 load the \`manage-mcp\` skill. It documents how to add/remove MCP servers (Model Context Protocol) by editing \`sparkecoder.config.json\`. Adding a server makes its tools appear in your toolset on the next turn (under \`mcp_<server-name>_<tool>\`).
+- **Conversation history / long-term memory** \u2014 load the \`search-conversations\` skill. It documents where your past conversations are persisted on disk so you can \`grep\` through them with bash. Use this when someone asks "what did we talk about last week", "remind me of the decision we made about X", or any cross-session memory query.
+
+If the user asks "add the GitHub MCP" or "remember that I prefer Python", load the right skill first, then act on the documented file paths with bash/read_file/write_file.
+
+#### Common shapes
+- Spawn a worker:
+  \`agent({action:'spawn', name:'count-tests', goal:'Run X and report Y as summary', outputSchema?: { type:'object', properties:{...}, required:[...] }})\`
+- Answer a worker's question:
+  \`agent({action:'answer_question', id, questionId, answer})\`
+- Post to Slack thread:
+  \`messenger({action:'post', channel:'slack', to:'C0123', threadTs:'1700000000.001', text:'...'})\`
+- Schedule a recurring prompt:
+  \`schedule({action:'create', name:'standup-9am', cron:'0 9 * * 1-5', prompt:'Summarize yesterday\\'s git activity in this repo'})\`
+- Create a webhook:
+  \`webhook({action:'create', name:'github-prs', wake:'now'})\` \u2014 returns the URL.
+
+### Typical flow
+
+1. Inbound event arrives (any channel).
+2. You decompose, \`spawn\` one or more workers with explicit goals.
+3. Workers run autonomously. They wake you via SYSTEM events when done / failed / blocked.
+4. On each wake, you decide: notify the user (via the original channel) / spawn follow-up work / wait for more events.
+`;
+}
 function createSummaryPrompt(conversationHistory) {
   return `Please provide a concise summary of the following conversation history. Focus on:
 1. The main task or goal being worked on
@@ -7164,6 +7500,23 @@ ${summaryContent}`
   }
   async addResponseMessages(messages) {
     await messageQueries.addMany(this.sessionId, messages);
+    try {
+      const { appendTurn: appendTurn2, flattenContent: flattenContent2 } = await Promise.resolve().then(() => (init_conversation_archive(), conversation_archive_exports));
+      const { sessionQueries: sessionQueries2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+      const session = await sessionQueries2.getById(this.sessionId).catch(() => void 0);
+      for (const m of messages) {
+        if (m.role !== "assistant") continue;
+        const text = flattenContent2(m.content).trim();
+        if (!text) continue;
+        appendTurn2({
+          sessionId: this.sessionId,
+          sessionName: session?.name ?? void 0,
+          role: "assistant",
+          content: text
+        });
+      }
+    } catch {
+    }
   }
   async getStats() {
     const messages = await messageQueries.getModelMessages(this.sessionId);
@@ -7241,6 +7594,685 @@ function repairToolPairing(messages) {
   return repaired;
 }
 
+// src/tools/orchestrator-actions.ts
+import { tool as tool14 } from "ai";
+import { z as z15 } from "zod";
+
+// src/integrations/channels/web.ts
+var webChannel = {
+  id: "web",
+  canSend: () => true,
+  // outbound goes through the live SSE writer, not via channel.send
+  displayLabel: () => "WEB"
+};
+
+// src/integrations/slack/client.ts
+init_config();
+function readSlackConfig() {
+  try {
+    const cfg = getConfig();
+    const slack = cfg?.slack;
+    if (!slack?.botToken) return void 0;
+    return {
+      botToken: String(slack.botToken),
+      signingSecret: slack.signingSecret ? String(slack.signingSecret) : void 0,
+      defaultOrchestratorName: slack.defaultOrchestratorName ? String(slack.defaultOrchestratorName) : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function getSlackAdapter() {
+  const cfg = readSlackConfig();
+  if (!cfg) return void 0;
+  return {
+    async postMessage({ channel, text, threadTs }) {
+      const res = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=utf-8",
+          "Authorization": `Bearer ${cfg.botToken}`
+        },
+        body: JSON.stringify({ channel, text, thread_ts: threadTs })
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok || data?.ok === false) {
+        return { ok: false, error: data?.error || `HTTP ${res.status}` };
+      }
+      return { ok: true, ts: data?.ts };
+    }
+  };
+}
+function isSlackConfigured() {
+  return readSlackConfig() !== void 0;
+}
+
+// src/integrations/channels/slack.ts
+var slackChannel = {
+  id: "slack",
+  canSend: () => isSlackConfigured(),
+  async send(ref, text) {
+    const r = ref;
+    const adapter = getSlackAdapter();
+    if (!adapter) throw new Error("slack not configured");
+    const result = await adapter.postMessage({
+      channel: r.slackChannel,
+      text,
+      threadTs: r.threadTs
+    });
+    if (!result.ok) throw new Error(`slack post failed: ${result.error}`);
+  },
+  displayLabel(ref) {
+    const r = ref;
+    const parts = ["SLACK"];
+    if (r.slackChannel) parts.push(`channel=${r.slackChannel}`);
+    if (r.threadTs) parts.push(`thread=${r.threadTs}`);
+    if (r.user) parts.push(`user=${r.user}`);
+    return parts.join(" ");
+  }
+};
+
+// src/integrations/channels/system.ts
+var systemChannel = {
+  id: "system",
+  canSend: () => false,
+  // no outbound; orchestrator decides how to relay
+  displayLabel(ref) {
+    const r = ref;
+    return `SYSTEM ${r.kind} ${r.workerName}`;
+  }
+};
+function workerCompletedEvent(workerId, workerName, summary) {
+  const ref = { channel: "system", kind: "worker.completed", workerId, workerName };
+  return {
+    ref,
+    content: `[${systemChannel.displayLabel(ref)}] Worker "${workerName}" (${workerId}) completed. Summary: ${summary}`,
+    wake: "now",
+    enqueuedAt: /* @__PURE__ */ new Date()
+  };
+}
+function workerFailedEvent(workerId, workerName, error) {
+  const ref = { channel: "system", kind: "worker.failed", workerId, workerName };
+  return {
+    ref,
+    content: `[${systemChannel.displayLabel(ref)}] Worker "${workerName}" (${workerId}) FAILED. Error: ${error}`,
+    wake: "now",
+    enqueuedAt: /* @__PURE__ */ new Date()
+  };
+}
+function workerQuestionEvent(workerId, workerName, question, questionId) {
+  const ref = { channel: "system", kind: "worker.question", workerId, workerName };
+  return {
+    ref,
+    content: `[${systemChannel.displayLabel(ref)}] Worker "${workerName}" (${workerId}) is BLOCKED on a question. Use the agent tool to answer it:
+Question: ${question}
+questionId: ${questionId}`,
+    wake: "now",
+    enqueuedAt: /* @__PURE__ */ new Date()
+  };
+}
+
+// src/integrations/channels/schedule.ts
+var scheduleChannel = {
+  id: "schedule",
+  canSend: () => false,
+  displayLabel(ref) {
+    const r = ref;
+    return `SCHEDULE ${r.scheduleName}`;
+  }
+};
+
+// src/integrations/channels/webhook.ts
+var webhookChannel = {
+  id: "webhook",
+  canSend: () => false,
+  displayLabel(ref) {
+    const r = ref;
+    return `WEBHOOK ${r.webhookName}`;
+  }
+};
+
+// src/integrations/channels/registry.ts
+var channels = /* @__PURE__ */ new Map();
+for (const c of [webChannel, slackChannel, systemChannel, scheduleChannel, webhookChannel]) {
+  channels.set(c.id, c);
+}
+function getChannel(id) {
+  return channels.get(id);
+}
+function listChannels() {
+  return Array.from(channels.values());
+}
+function listOutboundChannels() {
+  return listChannels().filter((c) => c.canSend());
+}
+
+// src/integrations/channels/messenger.ts
+async function postMessage(opts) {
+  const adapter = getChannel(opts.channel);
+  if (!adapter) return { ok: false, error: `unknown channel: ${opts.channel}` };
+  if (!adapter.canSend() || !adapter.send) {
+    return { ok: false, error: `channel ${opts.channel} not configured or does not support sending` };
+  }
+  let ref;
+  switch (opts.channel) {
+    case "slack": {
+      const slackRef = { channel: "slack", slackChannel: opts.to, threadTs: opts.threadTs };
+      ref = slackRef;
+      break;
+    }
+    default:
+      ref = { channel: opts.channel, to: opts.to };
+  }
+  try {
+    await adapter.send(ref, opts.text);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+function describeConfiguredChannels() {
+  return listOutboundChannels().map((c) => ({
+    id: String(c.id),
+    canSend: true,
+    label: c.id === "slack" ? "Slack" : String(c.id)
+  }));
+}
+
+// src/orchestrator/schedules-store.ts
+init_db();
+import { nanoid as nanoid5 } from "nanoid";
+async function readOrch(orchestratorSessionId) {
+  const s = await sessionQueries.getById(orchestratorSessionId);
+  if (!s) return null;
+  const schedules = s.config?.schedules ?? [];
+  return { schedules, config: s.config ?? {} };
+}
+async function listSchedules(orchestratorSessionId) {
+  const data = await readOrch(orchestratorSessionId);
+  return data?.schedules ?? [];
+}
+async function createSchedule(orchestratorSessionId, input) {
+  const data = await readOrch(orchestratorSessionId);
+  if (!data) throw new Error("orchestrator session not found");
+  const row = {
+    id: `sch_${nanoid5(10)}`,
+    name: input.name,
+    cron: input.cron,
+    prompt: input.prompt,
+    replyChannel: input.replyChannel,
+    enabled: true,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const schedules = [...data.schedules, row];
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, schedules } });
+  return row;
+}
+async function updateSchedule(orchestratorSessionId, id, patch) {
+  const data = await readOrch(orchestratorSessionId);
+  if (!data) return null;
+  const schedules = data.schedules.map((s) => s.id === id ? { ...s, ...patch } : s);
+  const updated = schedules.find((s) => s.id === id) || null;
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, schedules } });
+  return updated;
+}
+async function deleteSchedule(orchestratorSessionId, id) {
+  const data = await readOrch(orchestratorSessionId);
+  if (!data) return false;
+  const next = data.schedules.filter((s) => s.id !== id);
+  if (next.length === data.schedules.length) return false;
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, schedules: next } });
+  return true;
+}
+
+// src/orchestrator/webhooks-store.ts
+init_db();
+import { randomBytes } from "crypto";
+import { nanoid as nanoid6 } from "nanoid";
+function newToken() {
+  return randomBytes(24).toString("base64url");
+}
+async function readOrch2(orchestratorSessionId) {
+  const s = await sessionQueries.getById(orchestratorSessionId);
+  if (!s) return null;
+  const webhooks = s.config?.webhooks ?? [];
+  return { webhooks, config: s.config ?? {} };
+}
+async function listWebhooks(orchestratorSessionId) {
+  return (await readOrch2(orchestratorSessionId))?.webhooks ?? [];
+}
+async function createWebhook(orchestratorSessionId, input) {
+  const data = await readOrch2(orchestratorSessionId);
+  if (!data) throw new Error("orchestrator session not found");
+  const row = {
+    id: `whk_${nanoid6(10)}`,
+    name: input.name,
+    token: newToken(),
+    wake: input.wake ?? "now",
+    template: input.template,
+    hitCount: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const webhooks = [...data.webhooks, row];
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, webhooks } });
+  return row;
+}
+async function updateWebhook(orchestratorSessionId, id, patch) {
+  const data = await readOrch2(orchestratorSessionId);
+  if (!data) return null;
+  const webhooks = data.webhooks.map((w) => {
+    if (w.id !== id) return w;
+    const next = { ...w, ...patch };
+    if (patch.rotateToken) next.token = newToken();
+    return next;
+  });
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, webhooks } });
+  return webhooks.find((w) => w.id === id) ?? null;
+}
+async function deleteWebhook(orchestratorSessionId, id) {
+  const data = await readOrch2(orchestratorSessionId);
+  if (!data) return false;
+  const next = data.webhooks.filter((w) => w.id !== id);
+  if (next.length === data.webhooks.length) return false;
+  await sessionQueries.update(orchestratorSessionId, { config: { ...data.config, webhooks: next } });
+  return true;
+}
+
+// src/tools/orchestrator-actions.ts
+async function api2(baseUrl, path, init = {}) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: init.method || "GET",
+    headers: { "Content-Type": "application/json" },
+    body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = { raw: text };
+  }
+  if (!res.ok) throw new Error(parsed?.error || `HTTP ${res.status}`);
+  return parsed;
+}
+function previewMessageContent(content) {
+  if (typeof content === "string") return content.slice(0, 500);
+  if (Array.isArray(content)) {
+    const text = content.find((p) => p?.type === "text");
+    if (text?.text) return String(text.text).slice(0, 500);
+  }
+  return "";
+}
+var AGENT_STATUS_ENUM = z15.enum(["running", "needs_attention", "completed", "failed", "idle"]);
+var agentInputSchema = z15.object({
+  action: z15.enum(["list", "get", "spawn", "message", "answer_question", "stop"]).describe("Which agent operation to perform."),
+  // list
+  status: AGENT_STATUS_ENUM.optional().describe("list only: filter to one status."),
+  limit: z15.number().int().min(1).max(100).optional().describe("list only: max rows."),
+  // get / message / answer_question / stop
+  id: z15.string().optional().describe("get | message | answer_question | stop: the agent (session) id."),
+  recentMessages: z15.number().int().min(0).max(50).optional().describe("get only: how many recent messages to include."),
+  // spawn
+  name: z15.string().optional().describe("spawn only: short human-readable label."),
+  goal: z15.string().optional().describe("spawn only: the worker's self-contained instruction."),
+  outputSchema: z15.record(z15.string(), z15.unknown()).optional().describe(
+    'spawn only: JSON Schema for the worker result. Defaults to {type:"object", properties:{summary:{type:"string"}}, required:["summary"]}.'
+  ),
+  model: z15.string().optional().describe("spawn only: model override."),
+  workingDirectory: z15.string().optional().describe("spawn only: working directory override."),
+  maxIterations: z15.number().int().min(1).max(500).optional().describe("spawn only."),
+  // message
+  text: z15.string().optional().describe("message only: the text to deliver to the worker."),
+  force: z15.boolean().optional().describe("message only: soft-interrupt the current step."),
+  // answer_question
+  questionId: z15.string().optional().describe("answer_question only: pending question id (e.g. q_abc123)."),
+  answer: z15.string().optional().describe("answer_question only: your answer.")
+});
+function buildAgentTool(opts) {
+  return tool14({
+    description: "Manage worker agents. Actions: list (browse with optional status filter), get (deep dive: status, todos, pending question, recent messages, final result; required: id), spawn (start a new worker; required: name, goal), message (post a message to a running worker; force=true to soft-interrupt; required: id, text), answer_question (resolve a worker's ask_question_to_user prompt; required: id, questionId, answer), stop (hard-cancel a running worker; required: id).",
+    inputSchema: agentInputSchema,
+    execute: async (input) => {
+      switch (input.action) {
+        case "list": {
+          const limit = input.limit ?? 50;
+          const data = await api2(opts.baseUrl, `/sessions?role=worker&limit=${limit}`);
+          const filtered = input.status ? data.sessions.filter((s) => s.agentStatus === input.status) : data.sessions;
+          return {
+            count: filtered.length,
+            agents: filtered.map((s) => ({
+              id: s.id,
+              name: s.name,
+              status: s.agentStatus,
+              isStreaming: s.isStreaming,
+              pendingQuestion: s.pendingQuestion,
+              lastMessagePreview: s.lastMessagePreview,
+              updatedAt: s.updatedAt
+            }))
+          };
+        }
+        case "get": {
+          if (!input.id) return { error: "id required for action=get" };
+          const limit = input.recentMessages ?? 5;
+          const [session, messages] = await Promise.all([
+            api2(opts.baseUrl, `/sessions/${input.id}`),
+            api2(opts.baseUrl, `/sessions/${input.id}/messages?limit=${limit}`)
+          ]);
+          const task = session.config?.task ?? null;
+          return {
+            id: session.id,
+            name: session.name,
+            status: session.agentStatus,
+            role: session.role,
+            isStreaming: session.isStreaming,
+            model: session.model,
+            workingDirectory: session.workingDirectory,
+            pendingQuestion: session.pendingQuestion,
+            todos: session.todos,
+            task: task ? { status: task.status, result: task.result, error: task.error, iterations: task.iterations } : null,
+            recentMessages: messages.messages.map((m) => ({ role: m.role, content: previewMessageContent(m.content) })),
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt
+          };
+        }
+        case "spawn": {
+          if (!input.name || !input.goal) return { error: "name and goal required for action=spawn" };
+          const outputSchema = input.outputSchema ?? {
+            type: "object",
+            properties: { summary: { type: "string", description: "Human-readable summary of what was done." } },
+            required: ["summary"]
+          };
+          const created = await api2(opts.baseUrl, "/tasks", {
+            method: "POST",
+            body: {
+              prompt: input.goal,
+              outputSchema,
+              model: input.model ?? opts.defaultModel,
+              workingDirectory: input.workingDirectory ?? opts.defaultWorkingDirectory,
+              name: input.name,
+              maxIterations: input.maxIterations ?? 100,
+              orchestratorSessionId: opts.orchestratorSessionId
+            }
+          });
+          return {
+            id: created.taskId,
+            name: input.name,
+            status: "running",
+            message: `Spawned "${input.name}" (${created.taskId}). It will wake you with a system event when it completes, fails, or asks a question. No polling needed.`
+          };
+        }
+        case "message": {
+          if (!input.id || !input.text) return { error: "id and text required for action=message" };
+          await api2(opts.baseUrl, `/sessions/${input.id}/messages`, {
+            method: "POST",
+            body: { text: input.text, source: "orchestrator", force: !!input.force }
+          });
+          return {
+            delivered: true,
+            id: input.id,
+            force: !!input.force,
+            note: input.force ? "Will be delivered after the current step aborts." : "Queued; delivered before the worker's next iteration."
+          };
+        }
+        case "answer_question": {
+          if (!input.id || !input.questionId || !input.answer) return { error: "id, questionId, answer required for action=answer_question" };
+          const res = await api2(opts.baseUrl, `/tasks/${input.id}/questions/${input.questionId}/answer`, {
+            method: "POST",
+            body: { answer: input.answer, answeredBy: "orchestrator" }
+          });
+          return { delivered: true, ...res };
+        }
+        case "stop": {
+          if (!input.id) return { error: "id required for action=stop" };
+          const res = await api2(opts.baseUrl, `/tasks/${input.id}/cancel`, { method: "POST" });
+          return { stopped: true, ...res };
+        }
+      }
+    }
+  });
+}
+var messengerInputSchema = z15.object({
+  action: z15.enum(["list_channels", "post"]),
+  // post
+  channel: z15.string().optional().describe('post only: channel id (e.g. "slack").'),
+  to: z15.string().optional().describe('post only: destination. Slack: channel id (C0123), user id (U0123), or "#channel-name".'),
+  text: z15.string().optional().describe("post only: message body."),
+  threadTs: z15.string().optional().describe("post + slack: reply in this thread."),
+  subject: z15.string().optional().describe("post + email: subject (future).")
+});
+function buildMessengerTool() {
+  return tool14({
+    description: "Send messages on configured external channels. Actions: list_channels (no args; returns which integrations are configured), post (required: channel, to, text). Use this to ping the user on Slack when a worker finishes, when a schedule fires, etc.",
+    inputSchema: messengerInputSchema,
+    execute: async (input) => {
+      if (input.action === "list_channels") {
+        return { channels: describeConfiguredChannels() };
+      }
+      if (!input.channel || !input.to || !input.text) {
+        return { ok: false, error: "channel, to, text required for action=post" };
+      }
+      const result = await postMessage({
+        channel: input.channel,
+        to: input.to,
+        text: input.text,
+        threadTs: input.threadTs,
+        subject: input.subject
+      });
+      return result;
+    }
+  });
+}
+var scheduleInputSchema = z15.object({
+  action: z15.enum(["create", "list", "update", "delete", "pause", "resume"]),
+  // create / update
+  name: z15.string().optional().describe("create | update"),
+  cron: z15.string().optional().describe('create | update: 5-field cron (e.g. "0 9 * * 1-5" = weekdays at 9am).'),
+  prompt: z15.string().optional().describe("create | update: the prompt injected when the schedule fires."),
+  replyChannel: z15.string().optional().describe("create | update: default channel id for orchestrator replies."),
+  // update / delete / pause / resume
+  id: z15.string().optional().describe("update | delete | pause | resume: schedule id."),
+  enabled: z15.boolean().optional().describe("update only.")
+});
+function buildScheduleTool(opts) {
+  return tool14({
+    description: "Recurring prompts. Actions: create (required: name, cron, prompt), list, update (required: id; any of name/cron/prompt/enabled/replyChannel), delete (required: id), pause (required: id), resume (required: id). Cron is standard 5-field syntax.",
+    inputSchema: scheduleInputSchema,
+    execute: async (input) => {
+      const orcId = opts.orchestratorSessionId;
+      switch (input.action) {
+        case "create": {
+          if (!input.name || !input.cron || !input.prompt) return { error: "name, cron, prompt required" };
+          return await createSchedule(orcId, {
+            name: input.name,
+            cron: input.cron,
+            prompt: input.prompt,
+            replyChannel: input.replyChannel
+          });
+        }
+        case "list":
+          return { schedules: await listSchedules(orcId) };
+        case "update": {
+          if (!input.id) return { error: "id required" };
+          const { action: _a, id, ...patch } = input;
+          const row = await updateSchedule(orcId, id, patch);
+          return row ? row : { error: "not found" };
+        }
+        case "delete":
+          if (!input.id) return { error: "id required" };
+          return { deleted: await deleteSchedule(orcId, input.id) };
+        case "pause":
+          if (!input.id) return { error: "id required" };
+          return await updateSchedule(orcId, input.id, { enabled: false });
+        case "resume":
+          if (!input.id) return { error: "id required" };
+          return await updateSchedule(orcId, input.id, { enabled: true });
+      }
+    }
+  });
+}
+var webhookInputSchema = z15.object({
+  action: z15.enum(["create", "list", "update", "delete"]),
+  name: z15.string().optional().describe("create | update."),
+  wake: z15.enum(["now", "next"]).optional().describe("create | update: now = wake orchestrator immediately; next = add as context."),
+  template: z15.string().optional().describe("create | update: mustache-style template ({{path.to.field}}). Defaults to pretty-printed JSON."),
+  id: z15.string().optional().describe("update | delete: webhook id."),
+  rotateToken: z15.boolean().optional().describe("update only: regenerate the URL token.")
+});
+function buildWebhookUrl(opts, token) {
+  const base = opts.publicBaseUrl?.replace(/\/$/, "") || opts.baseUrl.replace(/\/$/, "");
+  return `${base}/api/inbox/${token}`;
+}
+function buildWebhookTool(opts) {
+  return tool14({
+    description: "Custom token-protected inbound URLs. Anyone POSTing JSON to the URL pings the orchestrator. Actions: create (required: name), list, update (required: id; optional: name, wake, template, rotateToken), delete (required: id). Use these to wire up GitHub, IFTTT, n8n, etc.",
+    inputSchema: webhookInputSchema,
+    execute: async (input) => {
+      const orcId = opts.orchestratorSessionId;
+      switch (input.action) {
+        case "create": {
+          if (!input.name) return { error: "name required" };
+          const row = await createWebhook(orcId, {
+            name: input.name,
+            wake: input.wake,
+            template: input.template
+          });
+          return { ...row, url: buildWebhookUrl(opts, row.token) };
+        }
+        case "list": {
+          const rows = await listWebhooks(orcId);
+          return { webhooks: rows.map((r) => ({ ...r, url: buildWebhookUrl(opts, r.token) })) };
+        }
+        case "update": {
+          if (!input.id) return { error: "id required" };
+          const { action: _a, id, ...patch } = input;
+          const row = await updateWebhook(orcId, id, patch);
+          if (!row) return { error: "not found" };
+          return { ...row, url: buildWebhookUrl(opts, row.token) };
+        }
+        case "delete":
+          if (!input.id) return { error: "id required" };
+          return { deleted: await deleteWebhook(orcId, input.id) };
+      }
+    }
+  });
+}
+function createOrchestratorActionTools(opts) {
+  return {
+    agent: buildAgentTool(opts),
+    messenger: buildMessengerTool(),
+    schedule: buildScheduleTool(opts),
+    webhook: buildWebhookTool(opts)
+  };
+}
+
+// src/integrations/mcp/pool.ts
+import { createMCPClient } from "@ai-sdk/mcp";
+
+// src/integrations/mcp/store.ts
+init_config();
+import { nanoid as nanoid7 } from "nanoid";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve10, join as join10 } from "path";
+function readServers() {
+  try {
+    const cfg = getConfig();
+    return Array.isArray(cfg?.mcp?.servers) ? cfg.mcp.servers : [];
+  } catch {
+    return [];
+  }
+}
+function refreshMcpServersFromDisk() {
+  const candidates = [
+    resolve10(process.cwd(), "sparkecoder.config.json"),
+    join10(ensureAppDataDirectory(), "sparkecoder.config.json")
+  ];
+  for (const path of candidates) {
+    if (!existsSync17(path)) continue;
+    try {
+      const raw = JSON.parse(readFileSync8(path, "utf-8"));
+      const servers2 = Array.isArray(raw?.mcp?.servers) ? raw.mcp.servers : [];
+      setMcpServers(servers2);
+      return servers2;
+    } catch {
+    }
+  }
+  return readServers();
+}
+function listMcpServers() {
+  return readServers();
+}
+
+// src/integrations/mcp/pool.ts
+var clients = /* @__PURE__ */ new Map();
+var failureCount = /* @__PURE__ */ new Map();
+function buildTransportConfig(server) {
+  if (server.transport === "http") {
+    return {
+      type: "http",
+      url: server.url,
+      headers: server.headers
+    };
+  }
+  if (server.transport === "sse") {
+    return {
+      type: "sse",
+      url: server.url,
+      headers: server.headers
+    };
+  }
+  throw new Error("stdio transport is wired separately (see getOrCreate)");
+}
+async function buildStdioTransport(server) {
+  const mod = await import("@ai-sdk/mcp/mcp-stdio");
+  const Cls = mod.Experimental_StdioMCPTransport || mod.StdioClientTransport;
+  if (!Cls) throw new Error("@ai-sdk/mcp/mcp-stdio is missing the stdio transport class");
+  return new Cls({ command: server.command, args: server.args ?? [] });
+}
+async function getOrCreate(server) {
+  const existing = clients.get(server.id);
+  if (existing) return existing;
+  const transport = server.transport === "stdio" ? await buildStdioTransport(server) : buildTransportConfig(server);
+  const client = await createMCPClient({ transport });
+  clients.set(server.id, client);
+  failureCount.delete(server.id);
+  return client;
+}
+async function closeClient(serverId) {
+  const c = clients.get(serverId);
+  if (!c) return;
+  clients.delete(serverId);
+  try {
+    await c.close();
+  } catch {
+  }
+}
+async function loadAllMcpTools(opts = {}) {
+  const tools = {};
+  const previous = new Set(listMcpServers().map((s) => s.id));
+  const current = refreshMcpServersFromDisk();
+  const currentIds = new Set(current.map((s) => s.id));
+  for (const oldId of previous) {
+    if (!currentIds.has(oldId)) await closeClient(oldId);
+  }
+  for (const s of current.filter((x) => x.enabled)) {
+    try {
+      const client = await getOrCreate(s);
+      const serverTools = await client.tools();
+      for (const [name, t] of Object.entries(serverTools)) {
+        const key2 = `mcp_${s.name}_${name}`;
+        tools[key2] = t;
+      }
+    } catch (err) {
+      failureCount.set(s.id, (failureCount.get(s.id) ?? 0) + 1);
+      if (!opts.quiet) {
+        console.warn(`[mcp] loading tools from "${s.name}" (${s.id}) failed: ${err?.message || err}`);
+      }
+      await closeClient(s.id);
+    }
+  }
+  return tools;
+}
+
 // src/utils/webhook.ts
 var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
   "task.started",
@@ -7294,19 +8326,102 @@ function waitForTaskQuestionAnswer(question) {
   if (pendingQuestions.has(k)) {
     return Promise.reject(new Error(`Question already pending: ${question.questionId}`));
   }
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     pendingQuestions.set(k, {
       ...question,
       createdAt: /* @__PURE__ */ new Date(),
-      resolve: resolve10,
+      resolve: resolve11,
       reject
     });
   });
 }
 
+// src/tasks/pending-input.ts
+var sessions = /* @__PURE__ */ new Map();
+function entry(sessionId) {
+  let e = sessions.get(sessionId);
+  if (!e) {
+    e = { queue: [] };
+    sessions.set(sessionId, e);
+  }
+  return e;
+}
+function drainInputs(sessionId) {
+  const e = sessions.get(sessionId);
+  if (!e || e.queue.length === 0) return [];
+  const out = e.queue.slice();
+  e.queue.length = 0;
+  return out;
+}
+function registerInterruptController(sessionId, controller) {
+  entry(sessionId).interruptController = controller;
+}
+function clearInterruptController(sessionId) {
+  const e = sessions.get(sessionId);
+  if (e) e.interruptController = void 0;
+}
+
+// src/orchestrator/inbox.ts
+var inboxes = /* @__PURE__ */ new Map();
+var FLUSH_DEBOUNCE_MS = 200;
+var flushHandler = null;
+function entryFor(sessionId) {
+  let e = inboxes.get(sessionId);
+  if (!e) {
+    e = { pending: [] };
+    inboxes.set(sessionId, e);
+  }
+  return e;
+}
+function pushToInbox(orchestratorSessionId, event) {
+  const e = entryFor(orchestratorSessionId);
+  e.pending.push(event);
+  if (event.wake === "now") {
+    scheduleFlush(orchestratorSessionId);
+  }
+}
+function scheduleFlush(sessionId) {
+  const e = inboxes.get(sessionId);
+  if (!e) return;
+  if (e.timer) clearTimeout(e.timer);
+  e.timer = setTimeout(() => {
+    void flush(sessionId);
+  }, FLUSH_DEBOUNCE_MS);
+}
+async function flush(sessionId) {
+  const e = inboxes.get(sessionId);
+  if (!e) return;
+  if (e.timer) {
+    clearTimeout(e.timer);
+    e.timer = void 0;
+  }
+  const events = e.pending.splice(0);
+  if (events.length === 0) return;
+  if (!flushHandler) {
+    console.warn("[orchestrator-inbox] flush called with no handler installed; dropping events");
+    return;
+  }
+  try {
+    await flushHandler(sessionId, events);
+  } catch (err) {
+    console.error("[orchestrator-inbox] flush handler threw:", err?.message || err);
+  }
+}
+
 // src/agent/index.ts
 var MAX_SSE_FIELD_LENGTH = 8 * 1024;
 var SSE_PREVIEW_LENGTH = 2 * 1024;
+function anySignal(signals) {
+  const ctrl = new AbortController();
+  for (const s of signals) {
+    if (s.aborted) {
+      ctrl.abort();
+      return ctrl.signal;
+    }
+    s.addEventListener("abort", () => ctrl.abort(), { once: true });
+  }
+  return ctrl.signal;
+}
 function truncateWriteFileInput(input) {
   const out = { ...input };
   for (const key2 of ["content", "old_string", "new_string"]) {
@@ -7344,7 +8459,7 @@ var Agent = class _Agent {
   async createToolsWithCallbacks(options) {
     const config = getConfig();
     const sessionConfig = this.session.config || {};
-    return createTools({
+    const tools = await createTools({
       sessionId: this.session.id,
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
@@ -7355,6 +8470,23 @@ var Agent = class _Agent {
       onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
       onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0
     });
+    if (this.session.config?.role === "orchestrator") {
+      const orchTools = createOrchestratorActionTools({
+        baseUrl: `http://127.0.0.1:${config.server?.port ?? 3141}`,
+        orchestratorSessionId: this.session.id,
+        defaultWorkingDirectory: this.session.workingDirectory,
+        defaultModel: this.session.model || config.defaultModel,
+        publicBaseUrl: config.server?.publicUrl
+      });
+      for (const [name, t] of Object.entries(orchTools)) {
+        tools[name] = t;
+      }
+    }
+    const mcpTools = await loadAllMcpTools({ quiet: true });
+    for (const [name, t] of Object.entries(mcpTools)) {
+      tools[name] = t;
+    }
+    return tools;
   }
   /**
    * Create or resume an agent session
@@ -7392,6 +8524,23 @@ var Agent = class _Agent {
       computerUseDisplayWidth: sessionConfig.computerUseDisplayWidth,
       computerUseDisplayHeight: sessionConfig.computerUseDisplayHeight
     });
+    if (session.config?.role === "orchestrator") {
+      const baseUrl = `http://127.0.0.1:${config.server?.port ?? 3141}`;
+      const orchTools = createOrchestratorActionTools({
+        baseUrl,
+        orchestratorSessionId: session.id,
+        defaultWorkingDirectory: session.workingDirectory,
+        defaultModel: session.model || config.defaultModel,
+        publicBaseUrl: config.server?.publicUrl
+      });
+      for (const [name, t] of Object.entries(orchTools)) {
+        tools[name] = t;
+      }
+    }
+    const mcpTools = await loadAllMcpTools({ quiet: true });
+    for (const [name, t] of Object.entries(mcpTools)) {
+      tools[name] = t;
+    }
     return new _Agent(session, context, tools);
   }
   /**
@@ -7463,7 +8612,7 @@ ${prompt}` });
       this.context.addUserMessage(userContent);
     }
     await sessionQueries.updateStatus(this.session.id, "active");
-    const systemPrompt = await buildSystemPrompt({
+    let systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
       sessionId: this.session.id,
@@ -7471,6 +8620,19 @@ ${prompt}` });
       // TODO: Pass activeFiles from client for glob matching
       activeFiles: []
     });
+    if (this.session.config?.role === "orchestrator") {
+      systemPrompt = `${systemPrompt}
+
+${buildOrchestratorPromptAddendum()}`;
+      const personality = this.session.config.personality;
+      if (personality && personality.trim()) {
+        systemPrompt = `${systemPrompt}
+
+## Your personality / persona
+
+${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);
@@ -7639,6 +8801,15 @@ ${prompt}` });
           if (emit) {
             await emit(JSON.stringify({ type: "task-question", data: payload }));
           }
+          const orchId = this.session.config?.orchestratorSessionId;
+          if (orchId) {
+            pushToInbox(orchId, workerQuestionEvent(
+              this.session.id,
+              this.session.name || "worker",
+              question.question,
+              question.questionId
+            ));
+          }
           const answer = await answerPromise;
           const answeredPayload = {
             questionId: question.questionId,
@@ -7675,8 +8846,22 @@ ${taskAddendum}`;
       if (options.abortSignal?.aborted) {
         const cancelError = "Task was cancelled";
         fireWebhook("task.failed", { status: "failed", error: cancelError, iterations: iteration });
+        clearInterruptController(this.session.id);
         return { status: "failed", error: cancelError, iterations: iteration };
       }
+      const pending = drainInputs(this.session.id);
+      for (const p of pending) {
+        const labelled = p.source === "orchestrator" ? `[message from orchestrator]
+${p.text}` : p.source === "system" ? `[system note]
+${p.text}` : p.text;
+        if (emit) {
+          await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: labelled } }));
+        }
+        await this.context.addUserMessage(labelled);
+      }
+      const interruptController = new AbortController();
+      registerInterruptController(this.session.id, interruptController);
+      const combinedAbort = options.abortSignal ? anySignal([options.abortSignal, interruptController.signal]) : interruptController.signal;
       const messages = await this.context.getMessages();
       const useAnthropic = isAnthropicModel(this.session.model);
       if (emit) {
@@ -7693,7 +8878,7 @@ ${taskAddendum}`;
         messages,
         tools: taskTools,
         stopWhen: stepCountIs2(500),
-        abortSignal: options.abortSignal,
+        abortSignal: combinedAbort,
         providerOptions: useAnthropic ? {
           anthropic: getAnthropicProviderOptions(this.session.model, { toolStreaming: true })
         } : void 0,
@@ -7771,6 +8956,8 @@ ${taskAddendum}`;
       if (emit && reasoningStarted) {
         await emit(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
       }
+      const interrupted = interruptController.signal.aborted;
+      clearInterruptController(this.session.id);
       const iterResponse = await iterStream.response;
       const responseMessages = iterResponse.messages;
       await this.context.addResponseMessages(responseMessages);
@@ -7826,6 +9013,11 @@ ${taskAddendum}`;
         await sessionQueries.update(this.session.id, {
           config: { ...this.session.config, task: updatedTask2 }
         });
+        const orchId = this.session.config?.orchestratorSessionId;
+        if (orchId) {
+          const summary = finalStatus === "completed" ? typeof sig.result?.summary === "string" ? sig.result.summary : JSON.stringify(sig.result) : sig.error || "unknown error";
+          pushToInbox(orchId, finalStatus === "completed" ? workerCompletedEvent(this.session.id, this.session.name || "worker", summary) : workerFailedEvent(this.session.id, this.session.name || "worker", summary));
+        }
         return {
           status: finalStatus,
           result: sig.result,
@@ -7833,12 +9025,15 @@ ${taskAddendum}`;
           iterations: iteration
         };
       }
-      const continuationPrompt = "Continue working on the task. Before calling `complete_task`, VERIFY your work is correct \u2014 re-read edited files, run the linter, run tests if applicable, and check the browser/server if you made UI or API changes. Make sure you searched the right directories and found everything relevant. When fully verified, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason.";
-      if (emit) {
-        await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: continuationPrompt } }));
+      if (!interrupted) {
+        const continuationPrompt = "Continue working on the task. Before calling `complete_task`, VERIFY your work is correct \u2014 re-read edited files, run the linter, run tests if applicable, and check the browser/server if you made UI or API changes. Make sure you searched the right directories and found everything relevant. When fully verified, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason.";
+        if (emit) {
+          await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: continuationPrompt } }));
+        }
+        await this.context.addUserMessage(continuationPrompt);
       }
-      await this.context.addUserMessage(continuationPrompt);
     }
+    clearInterruptController(this.session.id);
     const timeoutError = `Task did not complete within ${maxIterations} iterations`;
     const timeoutRecordingUrls = await this.finishTaskRecording(taskRecorder);
     fireWebhook("task.failed", {
@@ -7856,6 +9051,10 @@ ${taskAddendum}`;
     await sessionQueries.update(this.session.id, {
       config: { ...this.session.config, task: updatedTask }
     });
+    const orchIdTimeout = this.session.config?.orchestratorSessionId;
+    if (orchIdTimeout) {
+      pushToInbox(orchIdTimeout, workerFailedEvent(this.session.id, this.session.name || "worker", timeoutError));
+    }
     return { status: "failed", error: timeoutError, iterations: iteration };
   }
   /**
@@ -7916,11 +9115,11 @@ ${taskAddendum}`;
       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: join10, basename: basename5 } = await import("path");
+      const { join: join12, basename: basename5 } = await import("path");
       const urls = [];
       for (const filePath of filePaths) {
         try {
-          const fullPath = filePath.startsWith("/") ? filePath : join10(this.session.workingDirectory, filePath);
+          const fullPath = filePath.startsWith("/") ? filePath : join12(this.session.workingDirectory, filePath);
           const fileName = basename5(fullPath);
           const ext = fileName.split(".").pop()?.toLowerCase() || "";
           const mimeMap = {
@@ -7978,11 +9177,11 @@ ${taskAddendum}`;
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool14({
+      wrappedTools[name] = tool15({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z15.object({}),
+        inputSchema: originalTool.inputSchema || z16.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid6();
+          const toolCallId = toolOptions.toolCallId || nanoid9();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -7994,8 +9193,8 @@ ${taskAddendum}`;
           this.pendingApprovals.set(toolCallId, await execution);
           options.onApprovalRequired?.(await execution);
           await 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);