sparkecoder 0.1.130 → 0.1.132

package/dist/agent/index.js

@@ -145,8 +145,8 @@ var init_types = __esm({
       authKey: z.string().optional()
     }).optional();
     SparkcoderConfigSchema = z.object({
-      // Default model to use (Vercel AI Gateway format)
-      defaultModel: z.string().default("anthropic/claude-opus-4.7"),
+      // Default model to use (LiteLLM model id)
+      defaultModel: z.string().default("gpt-5.5"),
       // Working directory for file operations
       workingDirectory: z.string().optional(),
       // Tool approval settings
@@ -185,6 +185,14 @@ var init_types = __esm({
       webhooks: z.object({
         token: z.string().optional()
       }).optional(),
+      // Self-update: when running as the managed service, periodically check
+      // npm for a newer published version and, if found, re-run the hosted
+      // installer (full upgrade + restart). Disabled automatically when not
+      // running from a global install (e.g. dev/source checkouts).
+      autoUpdate: z.object({
+        enabled: z.boolean().optional().default(true),
+        intervalHours: z.number().positive().optional().default(6)
+      }).optional().default({}),
       // Database path (used for local SQLite - ignored if remoteServer is configured)
       databasePath: z.string().optional().default("./sparkecoder.db"),
       // Remote server configuration (for centralized storage)
@@ -334,7 +342,7 @@ function requiresApproval(toolName, sessionConfig) {
 }
 function createDefaultConfig() {
   return {
-    defaultModel: "anthropic/claude-opus-4.7",
+    defaultModel: "gpt-5.5",
     // workingDirectory is intentionally not set - defaults to where CLI is run
     toolApprovals: {
       bash: true,
@@ -356,6 +364,10 @@ function createDefaultConfig() {
       port: 3141,
       host: "0.0.0.0"
     },
+    autoUpdate: {
+      enabled: true,
+      intervalHours: 6
+    },
     databasePath: "./sparkecoder.db"
   };
 }
@@ -371,6 +383,7 @@ var init_config = __esm({
       openai: "OPENAI_API_KEY",
       google: "GOOGLE_GENERATIVE_AI_API_KEY",
       xai: "XAI_API_KEY",
+      litellm: "LITELLM_API_KEY",
       "ai-gateway": "AI_GATEWAY_API_KEY"
     };
     SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
@@ -1707,94 +1720,734 @@ var init_conversation_archive = __esm({
   }
 });
 
-// src/browser/stream-proxy.ts
-var stream_proxy_exports = {};
-__export(stream_proxy_exports, {
-  BrowserStreamProxy: () => BrowserStreamProxy,
-  destroyProxy: () => destroyProxy,
-  getOrCreateProxy: () => getOrCreateProxy,
-  getProxy: () => getProxy
-});
-import WebSocket from "ws";
-import { EventEmitter } from "events";
-function getOrCreateProxy(sessionId, port) {
-  const existing = activeProxies.get(sessionId);
-  if (existing) {
-    console.log(`[BROWSER-WS] Reusing existing proxy for session ${sessionId} (connected=${existing.connected})`);
-    return existing;
+// 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,
+          realName: e.realName ?? null,
+          email: e.email ?? 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);
   }
-  console.log(`[BROWSER-WS] Creating new proxy for session ${sessionId} on port ${port} (active proxies: ${activeProxies.size})`);
-  const proxy = new BrowserStreamProxy(port);
-  activeProxies.set(sessionId, proxy);
-  proxy.on("close", () => {
-    console.log(`[BROWSER-WS] Proxy closed for session ${sessionId}, removing from registry`);
-    activeProxies.delete(sessionId);
-  });
-  proxy.connect();
-  return proxy;
 }
-function getProxy(sessionId) {
-  return activeProxies.get(sessionId);
+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 destroyProxy(sessionId) {
-  const proxy = activeProxies.get(sessionId);
-  if (proxy) {
-    console.log(`[BROWSER-WS] destroyProxy() called for session ${sessionId}`);
-    proxy.destroy();
-    activeProxies.delete(sessionId);
-  } else {
-    console.log(`[BROWSER-WS] destroyProxy() called but no proxy exists for session ${sessionId}`);
+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);
   }
 }
-var RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, FRAME_THROTTLE_MS, BrowserStreamProxy, activeProxies;
-var init_stream_proxy = __esm({
-  "src/browser/stream-proxy.ts"() {
+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 setCachedThreadOwnership(key2, entry2) {
+  load();
+  hookExit();
+  threadMap.set(key2, entry2);
+  evictIfOversized(threadMap, MAX_THREADS);
+  scheduleSave();
+}
+var FILENAME, FILE_VERSION, SAVE_DEBOUNCE_MS, MAX_THREADS, loaded, userMap, threadMap, dirty, saveTimer, exitHooked;
+var init_persistence = __esm({
+  "src/integrations/slack/persistence.ts"() {
     "use strict";
-    RECONNECT_DELAY_MS = 1e3;
-    MAX_RECONNECT_ATTEMPTS = 20;
-    FRAME_THROTTLE_MS = 100;
-    BrowserStreamProxy = class extends EventEmitter {
-      ws = null;
-      port;
-      reconnectAttempts = 0;
-      reconnectTimer = null;
-      destroyed = false;
-      lastFrameTime = 0;
-      _latestFrame = null;
-      _connected = false;
-      constructor(port) {
-        super();
-        this.port = port;
+    init_config();
+    FILENAME = "slack-cache.json";
+    FILE_VERSION = 1;
+    SAVE_DEBOUNCE_MS = 500;
+    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 slackBackoffMs(attempt) {
+  const expo = SLACK_BACKOFF_BASE_MS * 2 ** attempt;
+  const jitter = Math.floor(Math.random() * SLACK_BACKOFF_BASE_MS);
+  return Math.min(expo + jitter, SLACK_BACKOFF_CAP_MS);
+}
+async function slackFetchWithRetry(url, init, attempts = SLACK_FETCH_ATTEMPTS) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    const isLast = i === attempts - 1;
+    try {
+      const res = await fetch(url, init);
+      if ((res.status === 429 || res.status >= 500) && !isLast) {
+        const ra = Number(res.headers.get("retry-after"));
+        const waitMs = Number.isFinite(ra) && ra > 0 ? Math.min(ra * 1e3, SLACK_BACKOFF_CAP_MS) : slackBackoffMs(i);
+        await new Promise((r) => setTimeout(r, waitMs));
+        continue;
       }
-      get connected() {
-        return this._connected;
+      return res;
+    } catch (err) {
+      lastErr = err;
+      if (isLast) throw err;
+      await new Promise((r) => setTimeout(r, slackBackoffMs(i)));
+    }
+  }
+  throw lastErr ?? new Error("slack fetch failed");
+}
+async function addResultReaction(channel, timestamp, state2) {
+  const name = RESULT_REACTIONS[state2];
+  if (!name) return { ok: false, error: `no_reaction_for_state:${state2}` };
+  const adapter = getSlackAdapter();
+  if (!adapter) return { ok: false, error: "slack_not_configured" };
+  try {
+    const res = await adapter.addReaction({ channel, timestamp, name });
+    if (!res.ok && !REACTION_SOFT_ERRORS.has(res.error || "")) {
+      console.warn(`[slack] addReaction ${name} failed on ${channel}/${timestamp}: ${res.error}`);
+    }
+    return res;
+  } catch (err) {
+    console.warn(`[slack] addResultReaction threw on ${channel}/${timestamp}:`, err?.message || err);
+    return { ok: false, error: err?.message || "unknown" };
+  }
+}
+async function postThreadMessage(channel, threadTs, text) {
+  const adapter = getSlackAdapter();
+  if (!adapter) return { ok: false, error: "slack_not_configured" };
+  try {
+    return await adapter.postMessage({ channel, text, threadTs });
+  } catch (err) {
+    console.warn(`[slack] postThreadMessage threw on ${channel}/${threadTs}:`, err?.message || err);
+    return { ok: false, error: err?.message || "unknown" };
+  }
+}
+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;
+  const slackForm = async (endpoint, params) => {
+    const body = new URLSearchParams(params).toString();
+    const res = await fetch(`https://slack.com/api/${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+        Authorization: `Bearer ${cfg.botToken}`
+      },
+      body
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok || data?.ok === false) {
+      return { ok: false, error: data?.error || `HTTP ${res.status}` };
+    }
+    return { ok: true };
+  };
+  return {
+    async postMessage({ channel, text, threadTs }) {
+      const res = await slackFetchWithRetry("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}` };
       }
-      get latestFrame() {
-        return this._latestFrame;
+      return { ok: true, ts: data?.ts };
+    },
+    addReaction({ channel, timestamp, name }) {
+      return slackForm("reactions.add", { channel, timestamp, name });
+    },
+    removeReaction({ channel, timestamp, name }) {
+      return slackForm("reactions.remove", { channel, timestamp, name });
+    }
+  };
+}
+function isSlackConfigured() {
+  return readSlackConfig() !== void 0;
+}
+function threadCacheKey(channel, threadTs) {
+  return `${channel}\u241F${threadTs}`;
+}
+function noteBotPostedInThread(channel, threadTs) {
+  if (!channel || !threadTs) return;
+  setCachedThreadOwnership(threadCacheKey(channel, threadTs), {
+    owned: true,
+    expiresAt: Date.now() + THREAD_OWNED_TTL_MS
+  });
+}
+var RESULT_REACTIONS, SLACK_FETCH_ATTEMPTS, SLACK_BACKOFF_BASE_MS, SLACK_BACKOFF_CAP_MS, REACTION_SOFT_ERRORS, USER_TTL_MS, USER_FAIL_TTL_MS, THREAD_OWNED_TTL_MS, THREAD_NEG_TTL_MS;
+var init_client2 = __esm({
+  "src/integrations/slack/client.ts"() {
+    "use strict";
+    init_config();
+    init_persistence();
+    RESULT_REACTIONS = {
+      responded: "white_check_mark",
+      skipped: "zzz",
+      handed_off: "eyes",
+      failed: "warning"
+    };
+    SLACK_FETCH_ATTEMPTS = 3;
+    SLACK_BACKOFF_BASE_MS = 400;
+    SLACK_BACKOFF_CAP_MS = 3e4;
+    REACTION_SOFT_ERRORS = /* @__PURE__ */ new Set([
+      "already_reacted",
+      // add: someone (or we) already added this emoji
+      "no_reaction",
+      // remove: the emoji isn't on the message
+      "message_not_found"
+      // remove/add: original message deleted
+    ]);
+    USER_TTL_MS = 60 * 60 * 1e3;
+    USER_FAIL_TTL_MS = 5 * 60 * 1e3;
+    THREAD_OWNED_TTL_MS = 60 * 60 * 1e3;
+    THREAD_NEG_TTL_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/agent/session-lock.ts
+function isSessionLocked(sessionId) {
+  const s = locks.get(sessionId);
+  return !!s && s.pending > 0;
+}
+var locks;
+var init_session_lock = __esm({
+  "src/agent/session-lock.ts"() {
+    "use strict";
+    locks = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/orchestrator/webhook-events.ts
+import { existsSync as existsSync17, readFileSync as readFileSync8, appendFileSync as appendFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
+import { nanoid as nanoid4 } from "nanoid";
+function logFilePath() {
+  return join10(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);
+    for (const line of lines) {
+      try {
+        cache.push(JSON.parse(line));
+      } catch {
       }
-      connect() {
-        if (this.destroyed) return;
-        console.log(`[BROWSER-WS] connect() called for port ${this.port}`);
-        this.doConnect();
+    }
+    if (cache.length > MAX_EVENTS) {
+      cache = cache.slice(-MAX_EVENTS);
+      try {
+        writeFileSync4(p, cache.map((e) => JSON.stringify(e)).join("\n") + "\n");
+      } catch {
       }
-      doConnect() {
-        if (this.destroyed) return;
-        const url = `ws://localhost:${this.port}`;
-        console.log(`[BROWSER-WS] Attempting WebSocket connection to ${url} (attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
-        try {
-          this.ws = new WebSocket(url);
-        } catch (err) {
-          console.warn(`[BROWSER-WS] WebSocket constructor threw for ${url}:`, err);
-          this.scheduleReconnect();
-          return;
-        }
-        this.ws.on("open", () => {
-          console.log(`[BROWSER-WS] Connected to ${url} (after ${this.reconnectAttempts} retries)`);
-          this.reconnectAttempts = 0;
-          this._connected = true;
-        });
-        this.ws.on("message", (raw) => {
-          try {
+    }
+  } catch {
+  }
+  return cache;
+}
+function appendEvent(ev) {
+  const list = ensureLoaded();
+  list.push(ev);
+  if (list.length > MAX_EVENTS) list.shift();
+  try {
+    const p = logFilePath();
+    mkdirSync7(dirname7(p), { recursive: true });
+    appendFileSync3(p, JSON.stringify(ev) + "\n");
+  } catch {
+  }
+}
+function recordEvent(ev) {
+  const full = {
+    id: ev.id ?? nanoid4(),
+    ts: ev.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: ev.source,
+    status: ev.status,
+    subtype: ev.subtype,
+    channel: ev.channel,
+    user: ev.user,
+    textSnippet: ev.textSnippet?.slice(0, 200),
+    dropReason: ev.dropReason,
+    error: ev.error,
+    sessionId: ev.sessionId,
+    durationMs: ev.durationMs,
+    meta: ev.meta
+  };
+  appendEvent(full);
+  return full.id;
+}
+var MAX_EVENTS, cache;
+var init_webhook_events = __esm({
+  "src/orchestrator/webhook-events.ts"() {
+    "use strict";
+    init_config();
+    MAX_EVENTS = 1e3;
+    cache = null;
+  }
+});
+
+// src/orchestrator/inbox.ts
+var inbox_exports = {};
+__export(inbox_exports, {
+  clearInbox: () => clearInbox,
+  flush: () => flush,
+  peekInbox: () => peekInbox,
+  pushToInbox: () => pushToInbox,
+  setFlushHandler: () => setFlushHandler
+});
+function setFlushHandler(fn) {
+  flushHandler = fn;
+}
+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);
+  try {
+    trackInbound(orchestratorSessionId, event);
+  } catch {
+  }
+  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);
+  }
+}
+function peekInbox(sessionId) {
+  return inboxes.get(sessionId)?.pending.slice() ?? [];
+}
+function clearInbox(sessionId) {
+  const e = inboxes.get(sessionId);
+  if (!e) return;
+  if (e.timer) {
+    clearTimeout(e.timer);
+    e.timer = void 0;
+  }
+  e.pending.length = 0;
+}
+var inboxes, FLUSH_DEBOUNCE_MS, flushHandler;
+var init_inbox = __esm({
+  "src/orchestrator/inbox.ts"() {
+    "use strict";
+    init_inbox_acks();
+    inboxes = /* @__PURE__ */ new Map();
+    FLUSH_DEBOUNCE_MS = 200;
+    flushHandler = null;
+  }
+});
+
+// src/orchestrator/inbox-acks.ts
+var inbox_acks_exports = {};
+__export(inbox_acks_exports, {
+  MAX_ATTEMPTS: () => MAX_ATTEMPTS,
+  RECONCILE_EVERY_MS: () => RECONCILE_EVERY_MS,
+  REPLAY_AFTER_MS: () => REPLAY_AFTER_MS,
+  __getAck: () => __getAck,
+  __listAcks: () => __listAcks,
+  __resetAcks: () => __resetAcks,
+  eventKey: () => eventKey,
+  markRespondedForThread: () => markRespondedForThread,
+  markState: () => markState,
+  reconcileOnce: () => reconcileOnce,
+  resolveBatchOnTurnEnd: () => resolveBatchOnTurnEnd,
+  startReconciler: () => startReconciler,
+  stopReconciler: () => stopReconciler,
+  trackInbound: () => trackInbound
+});
+function eventKey(event) {
+  const ref = event.ref;
+  const ch = ref?.channel ?? "unknown";
+  switch (ch) {
+    case "slack":
+      return `slack${SEP}${ref.slackChannel}${SEP}${ref.messageTs ?? ref.threadTs ?? ""}`;
+    case "system":
+      return `system${SEP}${ref.workerId}${SEP}${ref.kind}`;
+    case "webhook":
+      return `webhook${SEP}${ref.webhookId}${SEP}${event.enqueuedAt instanceof Date ? event.enqueuedAt.getTime() : Date.now()}`;
+    case "schedule":
+      return `schedule${SEP}${ref.scheduleId}${SEP}${event.enqueuedAt instanceof Date ? event.enqueuedAt.getTime() : Date.now()}`;
+    default:
+      return `${ch}${SEP}${event.enqueuedAt instanceof Date ? event.enqueuedAt.getTime() : Date.now()}${SEP}${event.content.slice(0, 40)}`;
+  }
+}
+function trackInbound(sessionId, event) {
+  if (event.wake === "never") return null;
+  const key2 = eventKey(event);
+  const existing = ledger.get(key2);
+  if (existing) return key2;
+  const ref = event.ref;
+  const now = Date.now();
+  const entry2 = {
+    key: key2,
+    sessionId,
+    event,
+    channel: ref?.channel ?? "unknown",
+    state: "working",
+    attempts: 0,
+    trackedAt: now,
+    updatedAt: now
+  };
+  if (ref?.channel === "slack") {
+    entry2.slackChannel = ref.slackChannel;
+    entry2.threadTs = ref.threadTs;
+    entry2.messageTs = ref.messageTs;
+  }
+  ledger.set(key2, entry2);
+  if (ledger.size > MAX_ENTRIES) pruneOldest();
+  return key2;
+}
+function markState(key2, state2) {
+  const entry2 = ledger.get(key2);
+  if (!entry2) return;
+  if (TERMINAL.has(entry2.state)) return;
+  entry2.state = state2;
+  entry2.updatedAt = Date.now();
+  if (entry2.channel === "slack" && entry2.slackChannel && entry2.messageTs) {
+    fireResultReaction(entry2.slackChannel, entry2.messageTs, state2);
+  }
+}
+function markRespondedForThread(slackChannel2, threadTs) {
+  if (!slackChannel2 || !threadTs) return;
+  for (const entry2 of ledger.values()) {
+    if (entry2.channel === "slack" && entry2.state === "working" && entry2.slackChannel === slackChannel2 && entry2.threadTs === threadTs) {
+      markState(entry2.key, "responded");
+    }
+  }
+}
+function resolveBatchOnTurnEnd(events, ok) {
+  if (!ok) return;
+  for (const ev of events) {
+    const key2 = eventKey(ev);
+    const entry2 = ledger.get(key2);
+    if (!entry2 || entry2.state !== "working") continue;
+    if (entry2.channel === "slack") continue;
+    markState(key2, "responded");
+  }
+}
+async function reconcileOnce(now = Date.now()) {
+  let pushToInbox2 = null;
+  const toReplay = [];
+  for (const entry2 of ledger.values()) {
+    if (TERMINAL.has(entry2.state)) {
+      if (now - entry2.updatedAt > PRUNE_AFTER_MS) ledger.delete(entry2.key);
+      continue;
+    }
+    if (isSessionLocked(entry2.sessionId)) continue;
+    if (now - entry2.updatedAt < REPLAY_AFTER_MS) continue;
+    if (entry2.attempts >= MAX_ATTEMPTS) {
+      failEntry(entry2);
+      continue;
+    }
+    toReplay.push(entry2);
+  }
+  if (toReplay.length === 0) return;
+  try {
+    ({ pushToInbox: pushToInbox2 } = await Promise.resolve().then(() => (init_inbox(), inbox_exports)));
+  } catch {
+    return;
+  }
+  for (const entry2 of toReplay) {
+    entry2.attempts += 1;
+    entry2.updatedAt = Date.now();
+    const nudged = {
+      ...entry2.event,
+      content: `[REPLAY attempt ${entry2.attempts}/${MAX_ATTEMPTS} \u2014 you received this but have not yet replied to it or marked it handled. Respond now on the originating channel; if it genuinely needs no reply, you can ignore it.]
+${entry2.event.content}`,
+      wake: "now"
+    };
+    try {
+      pushToInbox2(entry2.sessionId, nudged);
+    } catch {
+    }
+  }
+}
+function failEntry(entry2) {
+  entry2.state = "failed";
+  entry2.updatedAt = Date.now();
+  if (entry2.channel === "slack" && entry2.slackChannel && entry2.messageTs) {
+    fireResultReaction(entry2.slackChannel, entry2.messageTs, "failed");
+    if (entry2.threadTs) {
+      fireFallback(
+        entry2.slackChannel,
+        entry2.threadTs,
+        `:warning: I wasn't able to handle this after ${entry2.attempts} attempt(s). It may need a human \u2014 flagging it here so it isn't lost.`
+      );
+    }
+  }
+  recordEvent({
+    source: "daemon",
+    status: "failed",
+    channel: entry2.channel,
+    sessionId: entry2.sessionId,
+    error: `unacknowledged after ${entry2.attempts} replay attempt(s)`,
+    textSnippet: entry2.event.content.slice(0, 200),
+    meta: { ackKey: entry2.key, ackState: "failed" }
+  });
+}
+function pruneOldest() {
+  const terminal = [];
+  for (const e of ledger.values()) if (TERMINAL.has(e.state)) terminal.push(e);
+  terminal.sort((a, b) => a.updatedAt - b.updatedAt);
+  for (const e of terminal) {
+    if (ledger.size <= MAX_ENTRIES) break;
+    ledger.delete(e.key);
+  }
+  while (ledger.size > MAX_ENTRIES) {
+    const oldest = ledger.keys().next().value;
+    if (!oldest) break;
+    ledger.delete(oldest);
+  }
+}
+function fireResultReaction(channel, ts, state2) {
+  if (typeof addResultReaction !== "function") return;
+  try {
+    void Promise.resolve(addResultReaction(channel, ts, state2)).catch(() => {
+    });
+  } catch {
+  }
+}
+function fireFallback(channel, threadTs, text) {
+  if (typeof postThreadMessage !== "function") return;
+  try {
+    void Promise.resolve(postThreadMessage(channel, threadTs, text)).catch(() => {
+    });
+  } catch {
+  }
+}
+function startReconciler() {
+  if (reconcileTimer) return;
+  reconcileTimer = setInterval(() => {
+    void reconcileOnce();
+  }, RECONCILE_EVERY_MS);
+  if (typeof reconcileTimer.unref === "function") reconcileTimer.unref();
+}
+function stopReconciler() {
+  if (reconcileTimer) {
+    clearInterval(reconcileTimer);
+    reconcileTimer = null;
+  }
+}
+function __getAck(key2) {
+  return ledger.get(key2);
+}
+function __listAcks() {
+  return [...ledger.values()];
+}
+function __resetAcks() {
+  ledger.clear();
+}
+var REPLAY_AFTER_MS, RECONCILE_EVERY_MS, MAX_ATTEMPTS, PRUNE_AFTER_MS, MAX_ENTRIES, TERMINAL, SEP, ledger, reconcileTimer;
+var init_inbox_acks = __esm({
+  "src/orchestrator/inbox-acks.ts"() {
+    "use strict";
+    init_session_lock();
+    init_webhook_events();
+    init_client2();
+    REPLAY_AFTER_MS = 3 * 6e4;
+    RECONCILE_EVERY_MS = 6e4;
+    MAX_ATTEMPTS = 2;
+    PRUNE_AFTER_MS = 60 * 6e4;
+    MAX_ENTRIES = 5e3;
+    TERMINAL = /* @__PURE__ */ new Set(["responded", "skipped", "handed_off", "failed"]);
+    SEP = "\u241F";
+    ledger = /* @__PURE__ */ new Map();
+    reconcileTimer = null;
+  }
+});
+
+// src/browser/stream-proxy.ts
+var stream_proxy_exports = {};
+__export(stream_proxy_exports, {
+  BrowserStreamProxy: () => BrowserStreamProxy,
+  destroyProxy: () => destroyProxy,
+  getOrCreateProxy: () => getOrCreateProxy,
+  getProxy: () => getProxy
+});
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+function getOrCreateProxy(sessionId, port) {
+  const existing = activeProxies.get(sessionId);
+  if (existing) {
+    console.log(`[BROWSER-WS] Reusing existing proxy for session ${sessionId} (connected=${existing.connected})`);
+    return existing;
+  }
+  console.log(`[BROWSER-WS] Creating new proxy for session ${sessionId} on port ${port} (active proxies: ${activeProxies.size})`);
+  const proxy = new BrowserStreamProxy(port);
+  activeProxies.set(sessionId, proxy);
+  proxy.on("close", () => {
+    console.log(`[BROWSER-WS] Proxy closed for session ${sessionId}, removing from registry`);
+    activeProxies.delete(sessionId);
+  });
+  proxy.connect();
+  return proxy;
+}
+function getProxy(sessionId) {
+  return activeProxies.get(sessionId);
+}
+function destroyProxy(sessionId) {
+  const proxy = activeProxies.get(sessionId);
+  if (proxy) {
+    console.log(`[BROWSER-WS] destroyProxy() called for session ${sessionId}`);
+    proxy.destroy();
+    activeProxies.delete(sessionId);
+  } else {
+    console.log(`[BROWSER-WS] destroyProxy() called but no proxy exists for session ${sessionId}`);
+  }
+}
+var RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, FRAME_THROTTLE_MS, BrowserStreamProxy, activeProxies;
+var init_stream_proxy = __esm({
+  "src/browser/stream-proxy.ts"() {
+    "use strict";
+    RECONNECT_DELAY_MS = 1e3;
+    MAX_RECONNECT_ATTEMPTS = 20;
+    FRAME_THROTTLE_MS = 100;
+    BrowserStreamProxy = class extends EventEmitter {
+      ws = null;
+      port;
+      reconnectAttempts = 0;
+      reconnectTimer = null;
+      destroyed = false;
+      lastFrameTime = 0;
+      _latestFrame = null;
+      _connected = false;
+      constructor(port) {
+        super();
+        this.port = port;
+      }
+      get connected() {
+        return this._connected;
+      }
+      get latestFrame() {
+        return this._latestFrame;
+      }
+      connect() {
+        if (this.destroyed) return;
+        console.log(`[BROWSER-WS] connect() called for port ${this.port}`);
+        this.doConnect();
+      }
+      doConnect() {
+        if (this.destroyed) return;
+        const url = `ws://localhost:${this.port}`;
+        console.log(`[BROWSER-WS] Attempting WebSocket connection to ${url} (attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
+        try {
+          this.ws = new WebSocket(url);
+        } catch (err) {
+          console.warn(`[BROWSER-WS] WebSocket constructor threw for ${url}:`, err);
+          this.scheduleReconnect();
+          return;
+        }
+        this.ws.on("open", () => {
+          console.log(`[BROWSER-WS] Connected to ${url} (after ${this.reconnectAttempts} retries)`);
+          this.reconnectAttempts = 0;
+          this._connected = true;
+        });
+        this.ws.on("message", (raw) => {
+          try {
             const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
             this.handleMessage(msg);
           } catch (err) {
@@ -1915,10 +2568,10 @@ __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 join11 } from "path";
-import { tmpdir } from "os";
-import { nanoid as nanoid7 } from "nanoid";
+import { writeFile as writeFile6, mkdir as mkdir4, readFile as readFile11, unlink as unlink2, readdir as readdir5, rm as rm2 } from "fs/promises";
+import { join as join13 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { nanoid as nanoid8 } from "nanoid";
 async function checkFfmpeg() {
   try {
     await execAsync5("ffmpeg -version", { timeout: 5e3 });
@@ -1929,7 +2582,7 @@ async function checkFfmpeg() {
 }
 async function cleanup(dir) {
   try {
-    await rm(dir, { recursive: true, force: true });
+    await rm2(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1973,21 +2626,21 @@ var init_recorder = __esm({
        */
       async encode() {
         if (this.frames.length === 0) return null;
-        const workDir = join11(tmpdir(), `sparkecoder-recording-${nanoid7(8)}`);
+        const workDir = join13(tmpdir2(), `sparkecoder-recording-${nanoid8(8)}`);
         await mkdir4(workDir, { recursive: true });
         try {
           for (let i = 0; i < this.frames.length; i++) {
-            const framePath = join11(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
-            await writeFile5(framePath, this.frames[i].data);
+            const framePath = join13(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            await writeFile6(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 = join11(workDir, `recording_${this.sessionId}.mp4`);
+          const outputPath = join13(workDir, `recording_${this.sessionId}.mp4`);
           const hasFfmpeg = await checkFfmpeg();
           if (hasFfmpeg) {
             await execAsync5(
-              `ffmpeg -y -framerate ${clampedFps} -i "${join11(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+              `ffmpeg -y -framerate ${clampedFps} -i "${join13(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
               { timeout: 12e4 }
             );
           } else {
@@ -1999,7 +2652,7 @@ var init_recorder = __esm({
           const files = await readdir5(workDir);
           for (const f of files) {
             if (f.startsWith("frame_")) {
-              await unlink2(join11(workDir, f)).catch(() => {
+              await unlink2(join13(workDir, f)).catch(() => {
               });
             }
           }
@@ -2233,7 +2886,7 @@ var SUBAGENT_MODELS = {
 init_db();
 init_config();
 import { z as z15 } from "zod";
-import { nanoid as nanoid8 } from "nanoid";
+import { nanoid as nanoid9 } from "nanoid";
 
 // src/tools/bash.ts
 import { tool } from "ai";
@@ -6011,7 +6664,8 @@ async function buildSystemPrompt(options) {
     sessionId,
     discoveredSkills,
     activeFiles = [],
-    customInstructions
+    customInstructions,
+    taskScopedSkills
   } = options;
   let alwaysLoadedContent = "";
   let globMatchedContent = "";
@@ -6032,6 +6686,22 @@ async function buildSystemPrompt(options) {
     const skills = await loadAllSkills2(skillsDirectories);
     onDemandSkillsContext = formatSkillsForContext(skills);
   }
+  let taskScopedSkillsBlock = "";
+  if (taskScopedSkills && (taskScopedSkills.always.length > 0 || taskScopedSkills.onDemand.length > 0)) {
+    const parts = ["<task_provided_skills>"];
+    parts.push("These skills were supplied with this task and are available for this run only.");
+    if (taskScopedSkills.always.length > 0) {
+      parts.push(formatAlwaysLoadedSkills(taskScopedSkills.always));
+    }
+    if (taskScopedSkills.onDemand.length > 0) {
+      parts.push("Load any of these on demand with the load_skill tool:");
+      for (const s of taskScopedSkills.onDemand) {
+        parts.push(`- ${s.name}: ${s.description}`);
+      }
+    }
+    parts.push("</task_provided_skills>");
+    taskScopedSkillsBlock = parts.join("\n");
+  }
   const todos = await todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
   const plans = await readSessionPlans(workingDirectory, sessionId);
@@ -6324,6 +6994,8 @@ ${globMatchedContent}
 ${onDemandSkillsContext}
 </on_demand_skills>
 
+${taskScopedSkillsBlock}
+
 <current_task_list>
 ${todosContext}
 </current_task_list>
@@ -6931,20 +7603,110 @@ function sanitizeModelMessages(messages) {
   return result;
 }
 
+// src/utils/cap-image-count.ts
+var MAX_IMAGES_IN_CONTEXT = 11;
+var IMAGE_TRUNCATED_PLACEHOLDER = "[image truncated due to length of conversation]";
+function isImagePart(part) {
+  if (!part || typeof part !== "object") return false;
+  const t = part.type;
+  if (t === "image") return true;
+  if (t === "image-data") return true;
+  if (t === "media") {
+    const data = part.data;
+    const mt = part.mediaType;
+    if (typeof data === "string" && typeof mt === "string" && mt.startsWith("image/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function makePlaceholder() {
+  return { type: "text", text: IMAGE_TRUNCATED_PLACEHOLDER };
+}
+function countImages(messages) {
+  let n = 0;
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (isImagePart(part)) {
+        n++;
+        continue;
+      }
+      if (part && typeof part === "object" && part.type === "tool-result" && part.output && part.output.type === "content" && Array.isArray(part.output.value)) {
+        for (const sub of part.output.value) {
+          if (isImagePart(sub)) n++;
+        }
+      }
+    }
+  }
+  return n;
+}
+function capImageCount(messages, max = MAX_IMAGES_IN_CONTEXT) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  if (max < 0) throw new Error("capImageCount: max must be >= 0");
+  const total = countImages(messages);
+  if (total <= max) return messages;
+  let toDrop = total - max;
+  let mutated = false;
+  const out = messages.slice();
+  for (let i = 0; i < out.length && toDrop > 0; i++) {
+    const msg = out[i];
+    if (!Array.isArray(msg.content)) continue;
+    let contentCloned = false;
+    const ensureContentCloned = () => {
+      if (contentCloned) return;
+      out[i] = { ...msg, content: [...msg.content] };
+      contentCloned = true;
+    };
+    const content = () => out[i].content;
+    for (let j = 0; j < content().length && toDrop > 0; j++) {
+      const part = content()[j];
+      if (isImagePart(part)) {
+        ensureContentCloned();
+        out[i].content[j] = makePlaceholder();
+        toDrop--;
+        mutated = true;
+        continue;
+      }
+      if (part && typeof part === "object" && part.type === "tool-result" && part.output && part.output.type === "content" && Array.isArray(part.output.value)) {
+        const innerImages = [];
+        const innerValue = part.output.value;
+        for (let k = 0; k < innerValue.length; k++) {
+          if (isImagePart(innerValue[k])) innerImages.push(k);
+        }
+        if (innerImages.length === 0) continue;
+        const dropHere = Math.min(innerImages.length, toDrop);
+        ensureContentCloned();
+        const newOutputValue = [...innerValue];
+        for (let d = 0; d < dropHere; d++) {
+          newOutputValue[innerImages[d]] = makePlaceholder();
+        }
+        const newPart = {
+          ...part,
+          output: {
+            ...part.output,
+            value: newOutputValue
+          }
+        };
+        out[i].content[j] = newPart;
+        toDrop -= dropHere;
+        mutated = true;
+      }
+    }
+  }
+  if (mutated) {
+    console.warn(
+      `[cap-image-count] Replaced ${total - max} oldest image(s) with text placeholder (total=${total}, kept=${max}). This prevents request-too-large errors at the model / tunnel layer.`
+    );
+  }
+  return mutated ? out : messages;
+}
+
 // src/agent/model-limits.ts
 var MODEL_LIMITS = {
-  "anthropic/claude-opus-4.7": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "anthropic/claude-opus-4-6": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "anthropic/claude-sonnet-4": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "anthropic/claude-3.5-sonnet": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "anthropic/claude-3-haiku": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "google/gemini-3-flash-preview": { contextWindow: 1e6, rollingTarget: 15e4 },
-  "google/gemini-2.5-pro": { contextWindow: 1e6, rollingTarget: 15e4 },
-  "google/gemini-2.5-flash": { contextWindow: 1e6, rollingTarget: 15e4 },
-  "openai/gpt-4o": { contextWindow: 128e3, rollingTarget: 78e3 },
-  "openai/gpt-4.1": { contextWindow: 1e6, rollingTarget: 15e4 },
-  "openai/o3": { contextWindow: 2e5, rollingTarget: 15e4 },
-  "xai/grok-3": { contextWindow: 131072, rollingTarget: 8e4 }
+  "claude-opus-4-8": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "gpt-5.5": { contextWindow: 35e4, rollingTarget: 15e4 },
+  "claude-fable-5": { contextWindow: 2e5, rollingTarget: 15e4 }
 };
 var DEFAULT_LIMITS = { contextWindow: 2e5, rollingTarget: 15e4 };
 var PREFIX_DEFAULTS = {
@@ -7015,6 +7777,7 @@ ${summaryContent}`
     messages = repairToolPairing(messages);
     messages = ensureToolResultsFollowCalls(messages);
     messages = ensureEndsWithUserOrTool(messages);
+    messages = capImageCount(messages);
     return messages;
   }
   // ---------------------------------------------------------------------------
@@ -7132,7 +7895,7 @@ ${summaryContent}`
   }
   async summarizeChunk(chunk) {
     const historyText = chunk.map((msg) => {
-      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(stripBinaryContentForSummary(msg.content));
       return `[${msg.role}]: ${content}`;
     }).join("\n\n");
     try {
@@ -7243,9 +8006,35 @@ ${summaryContent}`
     this.summaries = [];
   }
 };
-function stripOrphanedToolResults(msg, removedIds) {
-  if (!Array.isArray(msg.content)) return msg;
-  const parts = msg.content.filter((part) => {
+function stripBinaryContentForSummary(value) {
+  if (Array.isArray(value)) return value.map(stripBinaryContentForSummary);
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const type = record.type;
+  if ((type === "image-data" || type === "file-data" || type === "media") && typeof record.data === "string") {
+    const mediaType = typeof record.mediaType === "string" ? record.mediaType : "unknown media type";
+    const filename = typeof record.filename === "string" ? ` ${record.filename}` : "";
+    return {
+      ...record,
+      data: `[${type}${filename}; ${mediaType}; ${record.data.length} base64 chars omitted for summary]`
+    };
+  }
+  if (type === "image" && typeof record.image === "string") {
+    const filename = typeof record.filename === "string" ? ` ${record.filename}` : "";
+    return {
+      ...record,
+      image: `[image${filename}; ${record.image.length} base64 chars omitted for summary]`
+    };
+  }
+  const out = {};
+  for (const [key2, nested] of Object.entries(record)) {
+    out[key2] = stripBinaryContentForSummary(nested);
+  }
+  return out;
+}
+function stripOrphanedToolResults(msg, removedIds) {
+  if (!Array.isArray(msg.content)) return msg;
+  const parts = msg.content.filter((part) => {
     if (part.type === "tool-result" && removedIds.has(part.toolCallId)) return false;
     if (part.type === "tool-call" && removedIds.has(part.toolCallId)) return false;
     return true;
@@ -7406,161 +8195,8 @@ var webChannel = {
   displayLabel: () => "WEB"
 };
 
-// src/integrations/slack/client.ts
-init_config();
-
-// src/integrations/slack/persistence.ts
-init_config();
-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";
-var FILENAME = "slack-cache.json";
-var FILE_VERSION = 1;
-var SAVE_DEBOUNCE_MS = 500;
-var MAX_THREADS = 5e3;
-var loaded = false;
-var userMap = /* @__PURE__ */ new Map();
-var threadMap = /* @__PURE__ */ new Map();
-var dirty = false;
-var saveTimer = null;
-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,
-          realName: e.realName ?? null,
-          email: e.email ?? 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);
-  }
-}
-var exitHooked = false;
-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 setCachedThreadOwnership(key2, entry2) {
-  load();
-  hookExit();
-  threadMap.set(key2, entry2);
-  evictIfOversized(threadMap, MAX_THREADS);
-  scheduleSave();
-}
-
-// src/integrations/slack/client.ts
-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;
-}
-var USER_TTL_MS = 60 * 60 * 1e3;
-var USER_FAIL_TTL_MS = 5 * 60 * 1e3;
-var THREAD_OWNED_TTL_MS = 60 * 60 * 1e3;
-var THREAD_NEG_TTL_MS = 5 * 60 * 1e3;
-function threadCacheKey(channel, threadTs) {
-  return `${channel}\u241F${threadTs}`;
-}
-function noteBotPostedInThread(channel, threadTs) {
-  if (!channel || !threadTs) return;
-  setCachedThreadOwnership(threadCacheKey(channel, threadTs), {
-    owned: true,
-    expiresAt: Date.now() + THREAD_OWNED_TTL_MS
-  });
-}
-
 // src/integrations/channels/slack.ts
+init_client2();
 var ownedThreads = /* @__PURE__ */ new Set();
 function threadKey(channel, threadTs) {
   return `${channel}\u241F${threadTs}`;
@@ -7584,6 +8220,8 @@ var slackChannel = {
     if (r.slackChannel && r.threadTs) {
       markThreadOwned(r.slackChannel, r.threadTs);
       noteBotPostedInThread(r.slackChannel, r.threadTs);
+      void Promise.resolve().then(() => (init_inbox_acks(), inbox_acks_exports)).then((m) => m.markRespondedForThread(r.slackChannel, r.threadTs)).catch(() => {
+      });
     }
   },
   displayLabel(ref) {
@@ -7710,7 +8348,7 @@ function describeConfiguredChannels() {
 
 // src/orchestrator/schedules-store.ts
 init_db();
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid5 } from "nanoid";
 async function readOrch(orchestratorSessionId) {
   const s = await sessionQueries.getById(orchestratorSessionId);
   if (!s) return null;
@@ -7725,7 +8363,7 @@ async function createSchedule(orchestratorSessionId, input) {
   const data = await readOrch(orchestratorSessionId);
   if (!data) throw new Error("orchestrator session not found");
   const row = {
-    id: `sch_${nanoid4(10)}`,
+    id: `sch_${nanoid5(10)}`,
     name: input.name,
     cron: input.cron,
     prompt: input.prompt,
@@ -7760,7 +8398,7 @@ init_config();
 // src/orchestrator/webhooks-store.ts
 init_db();
 import { randomBytes } from "crypto";
-import { nanoid as nanoid5 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
 function newToken() {
   return randomBytes(24).toString("base64url");
 }
@@ -7777,7 +8415,7 @@ async function createWebhook(orchestratorSessionId, input) {
   const data = await readOrch2(orchestratorSessionId);
   if (!data) throw new Error("orchestrator session not found");
   const row = {
-    id: `whk_${nanoid5(10)}`,
+    id: `whk_${nanoid6(10)}`,
     name: input.name,
     token: newToken(),
     wake: input.wake ?? "now",
@@ -7853,6 +8491,26 @@ var agentInputSchema = z14.object({
   model: z14.string().optional().describe("spawn only: model override."),
   workingDirectory: z14.string().optional().describe("spawn only: working directory override."),
   maxIterations: z14.number().int().min(1).max(500).optional().describe("spawn only."),
+  mcpServers: z14.array(
+    z14.object({
+      name: z14.string(),
+      transport: z14.enum(["http", "sse", "stdio"]),
+      url: z14.string().optional(),
+      headers: z14.record(z14.string(), z14.string()).optional(),
+      command: z14.string().optional(),
+      args: z14.array(z14.string()).optional(),
+      env: z14.record(z14.string(), z14.string()).optional()
+    })
+  ).optional().describe("spawn only: task-scoped MCP servers (with auth headers) connected for this worker only, tools exposed as mcp_<name>_<tool>."),
+  skills: z14.array(
+    z14.object({
+      name: z14.string(),
+      description: z14.string().optional(),
+      content: z14.string(),
+      alwaysApply: z14.boolean().optional(),
+      globs: z14.array(z14.string()).optional()
+    })
+  ).optional().describe("spawn only: task-scoped skills (inline markdown) available to this worker only."),
   // message
   text: z14.string().optional().describe("message only: the text to deliver to the worker."),
   force: z14.boolean().optional().describe("message only: soft-interrupt the current step."),
@@ -7923,7 +8581,9 @@ function buildAgentTool(opts) {
               workingDirectory: input.workingDirectory ?? opts.defaultWorkingDirectory,
               name: input.name,
               maxIterations: input.maxIterations ?? 100,
-              orchestratorSessionId: opts.orchestratorSessionId
+              orchestratorSessionId: opts.orchestratorSessionId,
+              ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
+              ...input.skills ? { skills: input.skills } : {}
             }
           });
           return {
@@ -8104,9 +8764,9 @@ import { createMCPClient } from "@ai-sdk/mcp";
 
 // src/integrations/mcp/store.ts
 init_config();
-import { nanoid as nanoid6 } from "nanoid";
-import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve10, join as join10 } from "path";
+import { nanoid as nanoid7 } from "nanoid";
+import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve10, join as join11 } from "path";
 function readServers() {
   try {
     const cfg = getConfig();
@@ -8118,12 +8778,12 @@ function readServers() {
 function refreshMcpServersFromDisk() {
   const candidates = [
     resolve10(process.cwd(), "sparkecoder.config.json"),
-    join10(ensureAppDataDirectory(), "sparkecoder.config.json")
+    join11(ensureAppDataDirectory(), "sparkecoder.config.json")
   ];
   for (const path of candidates) {
-    if (!existsSync17(path)) continue;
+    if (!existsSync18(path)) continue;
     try {
-      const raw = JSON.parse(readFileSync8(path, "utf-8"));
+      const raw = JSON.parse(readFileSync9(path, "utf-8"));
       const servers2 = Array.isArray(raw?.mcp?.servers) ? raw.mcp.servers : [];
       setMcpServers(servers2);
       return servers2;
@@ -8207,6 +8867,149 @@ async function loadAllMcpTools(opts = {}) {
   return tools;
 }
 
+// src/integrations/mcp/task-scoped.ts
+import { createMCPClient as createMCPClient2 } from "@ai-sdk/mcp";
+function sanitizeName(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/_+/g, "_");
+}
+function buildHttpLikeTransport(server) {
+  if (!server.url) {
+    throw new Error(`${server.transport} transport requires a url`);
+  }
+  return {
+    type: server.transport,
+    url: server.url,
+    headers: server.headers
+  };
+}
+async function buildStdioTransport2(server) {
+  if (!server.command) {
+    throw new Error("stdio transport requires a command");
+  }
+  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 ?? [],
+    env: server.env
+  });
+}
+async function buildTransport(server) {
+  return server.transport === "stdio" ? await buildStdioTransport2(server) : buildHttpLikeTransport(server);
+}
+async function connectTaskMcpServers(servers2, opts = {}) {
+  const tools = {};
+  const connected = [];
+  const errors = [];
+  const clients2 = [];
+  for (const raw of servers2 ?? []) {
+    const name = sanitizeName(raw.name || "");
+    if (!name) {
+      errors.push({ name: raw.name || "(unnamed)", error: "server name is required" });
+      continue;
+    }
+    let client = null;
+    try {
+      const transport = await buildTransport(raw);
+      client = await createMCPClient2({ transport });
+      clients2.push(client);
+      const serverTools = await client.tools();
+      for (const [toolName, t] of Object.entries(serverTools)) {
+        tools[`mcp_${name}_${toolName}`] = t;
+      }
+      connected.push(name);
+    } catch (err) {
+      const message = err?.message || String(err);
+      errors.push({ name, error: message });
+      if (!opts.quiet) {
+        console.warn(`[mcp:task] connecting "${name}" failed: ${message}`);
+      }
+      if (client) {
+        try {
+          await client.close();
+        } catch {
+        }
+        const idx = clients2.indexOf(client);
+        if (idx >= 0) clients2.splice(idx, 1);
+      }
+    }
+  }
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    await Promise.all(
+      clients2.map(async (c) => {
+        try {
+          await c.close();
+        } catch {
+        }
+      })
+    );
+  };
+  return { tools, connected, errors, close };
+}
+
+// src/skills/task-scoped.ts
+init_skills();
+import { mkdtemp, writeFile as writeFile5, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join12 } from "path";
+function safeFileName(name, index) {
+  const base = name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return `${base || `skill-${index + 1}`}.md`;
+}
+function escapeFrontmatterValue(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildSkillFile(skill) {
+  const lines = ["---"];
+  lines.push(`name: ${escapeFrontmatterValue(skill.name)}`);
+  lines.push(`description: ${escapeFrontmatterValue(skill.description || skill.name)}`);
+  if (skill.alwaysApply) lines.push("alwaysApply: true");
+  if (skill.globs && skill.globs.length > 0) {
+    lines.push(`globs: [${skill.globs.map((g) => escapeFrontmatterValue(g)).join(", ")}]`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(skill.content);
+  return lines.join("\n");
+}
+async function materializeTaskSkills(skills, taskId) {
+  if (!skills || skills.length === 0) return null;
+  const safeTaskId = taskId.replace(/[^a-zA-Z0-9_-]+/g, "_");
+  const dir = await mkdtemp(join12(tmpdir(), `sparkecoder-task-skills-${safeTaskId}-`));
+  const seen = /* @__PURE__ */ new Set();
+  await Promise.all(
+    skills.map(async (skill, i) => {
+      let fileName = safeFileName(skill.name, i);
+      while (seen.has(fileName)) fileName = `dup-${i}-${fileName}`;
+      seen.add(fileName);
+      await writeFile5(join12(dir, fileName), buildSkillFile(skill), "utf-8");
+    })
+  );
+  const loaded2 = await loadSkillsFromDirectory(dir, { priority: 1, defaultLoadType: "on_demand" });
+  const alwaysSkills = loaded2.filter((s) => s.alwaysApply || s.loadType === "always");
+  const onDemand = loaded2.filter((s) => !(s.alwaysApply || s.loadType === "always"));
+  const always = (await Promise.all(
+    alwaysSkills.map(async (s) => {
+      const withContent = await loadSkillContent(s.name, [dir]);
+      return withContent ? { ...s, content: withContent.content } : null;
+    })
+  )).filter((s) => s !== null);
+  let cleaned = false;
+  const cleanup2 = async () => {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      await rm(dir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  return { dir, always, onDemand, cleanup: cleanup2 };
+}
+
 // src/utils/webhook.ts
 var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
   "task.started",
@@ -8295,51 +9098,55 @@ function clearInterruptController(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;
+// src/agent/index.ts
+init_inbox();
+
+// src/utils/local-device-time.ts
+var LOCAL_TIME_MARKER = "[Local device time:";
+function formatLocalDeviceTimeLine(now = /* @__PURE__ */ new Date()) {
+  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const formatted = now.toLocaleString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZoneName: "short"
+  });
+  return `${LOCAL_TIME_MARKER} ${formatted} (${timeZone})]`;
 }
-function pushToInbox(orchestratorSessionId, event) {
-  const e = entryFor(orchestratorSessionId);
-  e.pending.push(event);
-  if (event.wake === "now") {
-    scheduleFlush(orchestratorSessionId);
-  }
+function hasLocalDeviceTimeLine(text) {
+  return text.includes(LOCAL_TIME_MARKER);
 }
-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);
+function prependLocalDeviceTimeToUserMessage(text, now) {
+  const trimmed = text.trim();
+  if (!trimmed || hasLocalDeviceTimeLine(text)) return text;
+  return `${formatLocalDeviceTimeLine(now)}
+${text}`;
 }
-async function flush(sessionId) {
-  const e = inboxes.get(sessionId);
-  if (!e) return;
-  if (e.timer) {
-    clearTimeout(e.timer);
-    e.timer = void 0;
+function prependLocalDeviceTimeToUserContent(content, now) {
+  if (typeof content === "string") {
+    return prependLocalDeviceTimeToUserMessage(content, now);
   }
-  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;
+  const line = formatLocalDeviceTimeLine(now);
+  if (content.some((p) => p.type === "text" && p.text && hasLocalDeviceTimeLine(p.text))) {
+    return content;
   }
-  try {
-    await flushHandler(sessionId, events);
-  } catch (err) {
-    console.error("[orchestrator-inbox] flush handler threw:", err?.message || err);
+  const userIdx = content.findIndex(
+    (p) => p.type === "text" && p.text?.includes("[USER MESSAGE]")
+  );
+  if (userIdx >= 0 && content[userIdx].text) {
+    const copy = content.map((p) => ({ ...p }));
+    copy[userIdx] = {
+      ...copy[userIdx],
+      text: `${line}
+${copy[userIdx].text}`
+    };
+    return copy;
   }
+  return [{ type: "text", text: line }, ...content];
 }
 
 // src/agent/index.ts
@@ -8533,9 +9340,11 @@ ${prompt}` });
    */
   async stream(options) {
     const config = getConfig();
-    const userContent = this.buildUserMessageContent(options.prompt, options.attachments);
+    const prompt = this.session.config?.role === "orchestrator" ? prependLocalDeviceTimeToUserMessage(options.prompt) : options.prompt;
+    const userContent = this.buildUserMessageContent(prompt, options.attachments);
+    const persistedUserContent = this.session.config?.role === "orchestrator" ? prependLocalDeviceTimeToUserContent(userContent) : userContent;
     if (!options.skipSaveUserMessage) {
-      await this.context.addUserMessage(userContent);
+      await this.context.addUserMessage(persistedUserContent);
     }
     await sessionQueries.updateStatus(this.session.id, "active");
     let systemPrompt = await buildSystemPrompt({
@@ -8613,7 +9422,8 @@ ${personality.trim()}
    */
   async run(options) {
     const config = getConfig();
-    await this.context.addUserMessage(options.prompt);
+    const prompt = this.session.config?.role === "orchestrator" ? prependLocalDeviceTimeToUserMessage(options.prompt) : options.prompt;
+    await this.context.addUserMessage(prompt);
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
@@ -8657,355 +9467,387 @@ ${personality.trim()}
    */
   async runTask(options) {
     const config = getConfig();
-    const maxIterations = options.taskConfig.maxIterations ?? 50;
-    const webhookUrl = options.taskConfig.webhookUrl;
-    const parentTaskId = options.taskConfig.parentTaskId;
-    const fireWebhook = (type, data) => {
-      if (!webhookUrl) return;
-      sendWebhook(webhookUrl, {
-        type,
-        taskId: this.session.id,
-        sessionId: this.session.id,
-        ...parentTaskId ? { parentTaskId } : {},
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        data
-      });
-    };
-    const completion = { signal: null };
-    const onComplete = (signal) => {
-      completion.signal = signal;
-    };
-    let taskRecorder = null;
-    const sessionId = this.session.id;
-    const emit = options.writeSSE;
-    const bashProgressHandler = (progress) => {
-      options.onToolProgress?.({ toolName: "bash", data: progress });
-      if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "bash", data: progress })).catch(() => {
-      });
-      const port = progress.browserStreamPort;
-      if (port && progress.status === "started") {
-        Promise.resolve().then(() => (init_stream_proxy(), stream_proxy_exports)).then(({ getOrCreateProxy: getOrCreateProxy2 }) => {
-          const proxy = getOrCreateProxy2(sessionId, port);
-          if (!taskRecorder) {
-            Promise.resolve().then(() => (init_recorder(), recorder_exports)).then(({ FrameRecorder: FrameRecorder2 }) => {
-              taskRecorder = new FrameRecorder2(sessionId);
-              taskRecorder.start();
-            });
-          }
-          if (proxy.listenerCount("frame") === 0) {
-            proxy.on("frame", (frame) => {
-              taskRecorder?.addFrame(frame);
-              if (emit) emit(JSON.stringify({ type: "browser-frame", data: frame.data, metadata: frame.metadata })).catch(() => {
-              });
-            });
-            proxy.on("status", (s) => {
-              if (emit) emit(JSON.stringify({ type: "browser-status", ...s })).catch(() => {
-              });
-            });
-          }
+    const taskScopedCleanups = [];
+    try {
+      const maxIterations = options.taskConfig.maxIterations ?? 50;
+      const webhookUrl = options.taskConfig.webhookUrl;
+      const parentTaskId = options.taskConfig.parentTaskId;
+      const fireWebhook = (type, data) => {
+        if (!webhookUrl) return;
+        sendWebhook(webhookUrl, {
+          type,
+          taskId: this.session.id,
+          sessionId: this.session.id,
+          ...parentTaskId ? { parentTaskId } : {},
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data
         });
+      };
+      const completion = { signal: null };
+      const onComplete = (signal) => {
+        completion.signal = signal;
+      };
+      let taskMcpTools = {};
+      if (options.mcpServers && options.mcpServers.length > 0) {
+        const mcpConnection = await connectTaskMcpServers(options.mcpServers, { quiet: true });
+        taskScopedCleanups.push(mcpConnection.close);
+        taskMcpTools = mcpConnection.tools;
+        if (mcpConnection.connected.length > 0) {
+          console.log(`[TASK] connected ${mcpConnection.connected.length} task-scoped MCP server(s): ${mcpConnection.connected.join(", ")}`);
+        }
+        for (const e of mcpConnection.errors) {
+          console.warn(`[TASK] task-scoped MCP server "${e.name}" failed to connect: ${e.error}`);
+          if (options.writeSSE) await options.writeSSE(JSON.stringify({ type: "task-mcp-error", data: { name: e.name, error: e.error } }));
+        }
       }
-    };
-    const taskTools = await createTools({
-      sessionId: this.session.id,
-      workingDirectory: this.session.workingDirectory,
-      skillsDirectories: config.resolvedSkillsDirectories,
-      onBashProgress: bashProgressHandler,
-      onWriteFileProgress: (progress) => {
-        options.onToolProgress?.({ toolName: "write_file", data: progress });
-        if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "write_file", data: progress })).catch(() => {
-        });
-      },
-      onSearchProgress: (progress) => {
-        options.onToolProgress?.({ toolName: "explore_agent", data: progress });
-        if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "explore_agent", data: progress })).catch(() => {
+      const materializedSkills = await materializeTaskSkills(options.skills, this.session.id);
+      if (materializedSkills) taskScopedCleanups.push(materializedSkills.cleanup);
+      const taskSkillsDir = materializedSkills?.dir;
+      let taskRecorder = null;
+      const sessionId = this.session.id;
+      const emit = options.writeSSE;
+      const bashProgressHandler = (progress) => {
+        options.onToolProgress?.({ toolName: "bash", data: progress });
+        if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "bash", data: progress })).catch(() => {
         });
-      },
-      taskTools: {
-        outputSchema: options.taskConfig.outputSchema,
-        onComplete,
-        onQuestion: async (question) => {
-          const payload = {
-            questionId: question.questionId,
-            question: question.question,
-            context: question.context,
-            choices: question.choices,
-            status: "pending"
-          };
-          const answerPromise = waitForTaskQuestionAnswer({
-            taskId: this.session.id,
-            questionId: question.questionId,
-            question: question.question,
-            context: question.context,
-            choices: question.choices
+        const port = progress.browserStreamPort;
+        if (port && progress.status === "started") {
+          Promise.resolve().then(() => (init_stream_proxy(), stream_proxy_exports)).then(({ getOrCreateProxy: getOrCreateProxy2 }) => {
+            const proxy = getOrCreateProxy2(sessionId, port);
+            if (!taskRecorder) {
+              Promise.resolve().then(() => (init_recorder(), recorder_exports)).then(({ FrameRecorder: FrameRecorder2 }) => {
+                taskRecorder = new FrameRecorder2(sessionId);
+                taskRecorder.start();
+              });
+            }
+            if (proxy.listenerCount("frame") === 0) {
+              proxy.on("frame", (frame) => {
+                taskRecorder?.addFrame(frame);
+                if (emit) emit(JSON.stringify({ type: "browser-frame", data: frame.data, metadata: frame.metadata })).catch(() => {
+                });
+              });
+              proxy.on("status", (s) => {
+                if (emit) emit(JSON.stringify({ type: "browser-status", ...s })).catch(() => {
+                });
+              });
+            }
           });
-          fireWebhook("task.question", payload);
-          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,
-            answer: answer.answer,
-            answeredBy: answer.answeredBy
-          };
-          fireWebhook("task.question_answered", answeredPayload);
-          if (emit) {
-            await emit(JSON.stringify({ type: "task-question-answered", data: answeredPayload }));
+        }
+      };
+      const taskTools = await createTools({
+        sessionId: this.session.id,
+        workingDirectory: this.session.workingDirectory,
+        onBashProgress: bashProgressHandler,
+        onWriteFileProgress: (progress) => {
+          options.onToolProgress?.({ toolName: "write_file", data: progress });
+          if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "write_file", data: progress })).catch(() => {
+          });
+        },
+        onSearchProgress: (progress) => {
+          options.onToolProgress?.({ toolName: "explore_agent", data: progress });
+          if (emit) emit(JSON.stringify({ type: "tool-progress", toolName: "explore_agent", data: progress })).catch(() => {
+          });
+        },
+        // Add the task-scoped skills temp dir (if any) so load_skill can list
+        // and load the inline skills supplied with this task.
+        skillsDirectories: taskSkillsDir ? [...config.resolvedSkillsDirectories, taskSkillsDir] : config.resolvedSkillsDirectories,
+        taskTools: {
+          outputSchema: options.taskConfig.outputSchema,
+          onComplete,
+          onQuestion: async (question) => {
+            const payload = {
+              questionId: question.questionId,
+              question: question.question,
+              context: question.context,
+              choices: question.choices,
+              status: "pending"
+            };
+            const answerPromise = waitForTaskQuestionAnswer({
+              taskId: this.session.id,
+              questionId: question.questionId,
+              question: question.question,
+              context: question.context,
+              choices: question.choices
+            });
+            fireWebhook("task.question", payload);
+            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,
+              answer: answer.answer,
+              answeredBy: answer.answeredBy
+            };
+            fireWebhook("task.question_answered", answeredPayload);
+            if (emit) {
+              await emit(JSON.stringify({ type: "task-question-answered", data: answeredPayload }));
+            }
+            return answer;
           }
-          return answer;
         }
+      });
+      for (const [name, t] of Object.entries(taskMcpTools)) {
+        taskTools[name] = t;
       }
-    });
-    const baseSystemPrompt = await buildSystemPrompt({
-      workingDirectory: this.session.workingDirectory,
-      skillsDirectories: config.resolvedSkillsDirectories,
-      sessionId: this.session.id,
-      discoveredSkills: config.discoveredSkills,
-      activeFiles: []
-    });
-    const taskAddendum = buildTaskPromptAddendum(options.taskConfig.outputSchema);
-    const systemPrompt = `${baseSystemPrompt}
+      const baseSystemPrompt = await buildSystemPrompt({
+        workingDirectory: this.session.workingDirectory,
+        skillsDirectories: taskSkillsDir ? [...config.resolvedSkillsDirectories, taskSkillsDir] : config.resolvedSkillsDirectories,
+        sessionId: this.session.id,
+        discoveredSkills: config.discoveredSkills,
+        activeFiles: [],
+        taskScopedSkills: materializedSkills ? { always: materializedSkills.always, onDemand: materializedSkills.onDemand } : void 0
+      });
+      const taskAddendum = buildTaskPromptAddendum(options.taskConfig.outputSchema);
+      const systemPrompt = `${baseSystemPrompt}
 
 ${taskAddendum}`;
-    fireWebhook("task.started", { prompt: options.prompt });
-    if (emit) {
-      await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: options.prompt } }));
-    }
-    await this.context.addUserMessage(options.prompt);
-    let iteration = 0;
-    while (iteration < maxIterations) {
-      iteration++;
-      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]
+      fireWebhook("task.started", { prompt: options.prompt });
+      if (emit) {
+        await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: options.prompt } }));
+      }
+      await this.context.addUserMessage(options.prompt);
+      let iteration = 0;
+      while (iteration < maxIterations) {
+        iteration++;
+        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) {
-        await emit(JSON.stringify({ type: "start", messageId: `msg_${Date.now()}` }));
-      }
-      let textStarted = false;
-      let textId = `text_${Date.now()}`;
-      let reasoningId = `reasoning_${Date.now()}`;
-      let reasoningStarted = false;
-      const toolCallStarts = /* @__PURE__ */ new Set();
-      const iterStream = streamText2({
-        model: resolveModel(this.session.model),
-        system: systemPrompt,
-        messages,
-        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 paired = repairToolPairing(stepMessages);
-          const ordered = ensureToolResultsFollowCalls(paired);
-          if (ordered === stepMessages) return {};
-          return { messages: ordered };
-        },
-        onStepFinish: async (step) => {
-          options.onStepFinish?.(step);
-          fireWebhook("task.step_finished", { iteration, text: step.text });
           if (emit) {
-            if (textStarted) {
-              await emit(JSON.stringify({ type: "text-end", id: textId }));
-              textStarted = false;
-              textId = `text_${Date.now()}`;
-            }
-            await emit(JSON.stringify({ type: "finish-step" }));
+            await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: labelled } }));
           }
+          await this.context.addUserMessage(labelled);
         }
-      });
-      for await (const part of iterStream.fullStream) {
-        if (part.type === "text-delta") {
-          if (emit) {
-            if (!textStarted) {
-              await emit(JSON.stringify({ type: "text-start", id: textId }));
-              textStarted = true;
+        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) {
+          await emit(JSON.stringify({ type: "start", messageId: `msg_${Date.now()}` }));
+        }
+        let textStarted = false;
+        let textId = `text_${Date.now()}`;
+        let reasoningId = `reasoning_${Date.now()}`;
+        let reasoningStarted = false;
+        const toolCallStarts = /* @__PURE__ */ new Set();
+        const iterStream = streamText2({
+          model: resolveModel(this.session.model),
+          system: systemPrompt,
+          messages,
+          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 paired = repairToolPairing(stepMessages);
+            const ordered = ensureToolResultsFollowCalls(paired);
+            if (ordered === stepMessages) return {};
+            return { messages: ordered };
+          },
+          onStepFinish: async (step) => {
+            options.onStepFinish?.(step);
+            fireWebhook("task.step_finished", { iteration, text: step.text });
+            if (emit) {
+              if (textStarted) {
+                await emit(JSON.stringify({ type: "text-end", id: textId }));
+                textStarted = false;
+                textId = `text_${Date.now()}`;
+              }
+              await emit(JSON.stringify({ type: "finish-step" }));
             }
-            await emit(JSON.stringify({ type: "text-delta", id: textId, delta: part.text }));
           }
-        } else if (part.type === "reasoning-start") {
-          if (emit) {
-            await emit(JSON.stringify({ type: "reasoning-start", id: reasoningId }));
-            reasoningStarted = true;
-          }
-        } else if (part.type === "reasoning-delta") {
-          if (emit) {
-            await emit(JSON.stringify({ type: "reasoning-delta", id: reasoningId, delta: part.text }));
-          }
-        } else if (part.type === "reasoning-end") {
-          if (emit && reasoningStarted) {
-            await emit(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
-            reasoningStarted = false;
-            reasoningId = `reasoning_${Date.now()}`;
+        });
+        for await (const part of iterStream.fullStream) {
+          if (part.type === "text-delta") {
+            if (emit) {
+              if (!textStarted) {
+                await emit(JSON.stringify({ type: "text-start", id: textId }));
+                textStarted = true;
+              }
+              await emit(JSON.stringify({ type: "text-delta", id: textId, delta: part.text }));
+            }
+          } else if (part.type === "reasoning-start") {
+            if (emit) {
+              await emit(JSON.stringify({ type: "reasoning-start", id: reasoningId }));
+              reasoningStarted = true;
+            }
+          } else if (part.type === "reasoning-delta") {
+            if (emit) {
+              await emit(JSON.stringify({ type: "reasoning-delta", id: reasoningId, delta: part.text }));
+            }
+          } else if (part.type === "reasoning-end") {
+            if (emit && reasoningStarted) {
+              await emit(JSON.stringify({ type: "reasoning-end", id: reasoningId }));
+              reasoningStarted = false;
+              reasoningId = `reasoning_${Date.now()}`;
+            }
+          } else if (part.type === "tool-call-streaming-start") {
+            if (emit) {
+              const p = part;
+              await emit(JSON.stringify({ type: "tool-input-start", toolCallId: p.toolCallId, toolName: p.toolName }));
+              toolCallStarts.add(p.toolCallId);
+            }
+          } else if (part.type === "tool-call-delta") {
+            if (emit) {
+              const p = part;
+              await emit(JSON.stringify({ type: "tool-input-delta", toolCallId: p.toolCallId, argsTextDelta: p.argsTextDelta }));
+            }
+          } else if (part.type === "tool-call") {
+            if (emit) {
+              if (!toolCallStarts.has(part.toolCallId)) {
+                await emit(JSON.stringify({ type: "tool-input-start", toolCallId: part.toolCallId, toolName: part.toolName }));
+                toolCallStarts.add(part.toolCallId);
+              }
+              const safeInput = part.toolName === "write_file" && part.input && typeof part.input === "object" ? truncateWriteFileInput(part.input) : part.input;
+              await emit(JSON.stringify({ type: "tool-input-available", toolCallId: part.toolCallId, toolName: part.toolName, input: safeInput }));
+            }
+          } else if (part.type === "tool-result") {
+            if (emit) {
+              await emit(JSON.stringify({ type: "tool-output-available", toolCallId: part.toolCallId, output: part.output }));
+            }
+          } else if (part.type === "error") {
+            console.error("Task stream error:", part.error);
+            if (emit) {
+              await emit(JSON.stringify({ type: "error", errorText: String(part.error) }));
+            }
           }
-        } else if (part.type === "tool-call-streaming-start") {
-          if (emit) {
-            const p = part;
-            await emit(JSON.stringify({ type: "tool-input-start", toolCallId: p.toolCallId, toolName: p.toolName }));
-            toolCallStarts.add(p.toolCallId);
+        }
+        if (emit && textStarted) {
+          await emit(JSON.stringify({ type: "text-end", id: textId }));
+        }
+        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);
+        const resultText = await iterStream.text;
+        const resultSteps = await iterStream.steps;
+        if (resultText) {
+          options.onText?.(resultText);
+          fireWebhook("task.message", { iteration, text: resultText });
+        }
+        for (const step of resultSteps) {
+          if (step.toolCalls) {
+            for (const tc of step.toolCalls) {
+              options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.input });
+              fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.input });
+            }
           }
-        } else if (part.type === "tool-call-delta") {
-          if (emit) {
-            const p = part;
-            await emit(JSON.stringify({ type: "tool-input-delta", toolCallId: p.toolCallId, argsTextDelta: p.argsTextDelta }));
+          if (step.toolResults) {
+            for (const tr of step.toolResults) {
+              options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.output });
+              fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.output });
+            }
           }
-        } else if (part.type === "tool-call") {
-          if (emit) {
-            if (!toolCallStarts.has(part.toolCallId)) {
-              await emit(JSON.stringify({ type: "tool-input-start", toolCallId: part.toolCallId, toolName: part.toolName }));
-              toolCallStarts.add(part.toolCallId);
+        }
+        if (completion.signal) {
+          const sig = completion.signal;
+          const finalStatus = sig.status;
+          let fileUrls;
+          if (finalStatus === "completed" && sig.result && typeof sig.result === "object") {
+            const resultObj = sig.result;
+            const filePaths = Array.isArray(resultObj.files) ? resultObj.files : [];
+            if (filePaths.length > 0) {
+              fileUrls = await this.uploadTaskFiles(filePaths);
             }
-            const safeInput = part.toolName === "write_file" && part.input && typeof part.input === "object" ? truncateWriteFileInput(part.input) : part.input;
-            await emit(JSON.stringify({ type: "tool-input-available", toolCallId: part.toolCallId, toolName: part.toolName, input: safeInput }));
           }
-        } else if (part.type === "tool-result") {
-          if (emit) {
-            await emit(JSON.stringify({ type: "tool-output-available", toolCallId: part.toolCallId, output: part.output }));
+          const recordingUrls = await this.finishTaskRecording(taskRecorder);
+          const allFileUrls = [...fileUrls || [], ...recordingUrls];
+          const eventType = finalStatus === "completed" ? "task.completed" : "task.failed";
+          fireWebhook(eventType, {
+            status: finalStatus,
+            result: sig.result,
+            error: sig.error,
+            iterations: iteration,
+            fileUrls: allFileUrls.length > 0 ? allFileUrls : void 0,
+            browserRecordingUrls: recordingUrls.length > 0 ? recordingUrls : void 0
+          });
+          const updatedTask2 = {
+            ...options.taskConfig,
+            status: finalStatus,
+            result: sig.result,
+            error: sig.error,
+            iterations: iteration
+          };
+          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));
           }
-        } else if (part.type === "error") {
-          console.error("Task stream error:", part.error);
+          return {
+            status: finalStatus,
+            result: sig.result,
+            error: sig.error,
+            iterations: iteration
+          };
+        }
+        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: "error", errorText: String(part.error) }));
+            await emit(JSON.stringify({ type: "data-user-message", data: { id: `user_${Date.now()}`, content: continuationPrompt } }));
           }
+          await this.context.addUserMessage(continuationPrompt);
         }
       }
-      if (emit && textStarted) {
-        await emit(JSON.stringify({ type: "text-end", id: textId }));
-      }
-      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);
-      const resultText = await iterStream.text;
-      const resultSteps = await iterStream.steps;
-      if (resultText) {
-        options.onText?.(resultText);
-        fireWebhook("task.message", { iteration, text: resultText });
-      }
-      for (const step of resultSteps) {
-        if (step.toolCalls) {
-          for (const tc of step.toolCalls) {
-            options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.input });
-            fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.input });
-          }
-        }
-        if (step.toolResults) {
-          for (const tr of step.toolResults) {
-            options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.output });
-            fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.output });
-          }
-        }
-      }
-      if (completion.signal) {
-        const sig = completion.signal;
-        const finalStatus = sig.status;
-        let fileUrls;
-        if (finalStatus === "completed" && sig.result && typeof sig.result === "object") {
-          const resultObj = sig.result;
-          const filePaths = Array.isArray(resultObj.files) ? resultObj.files : [];
-          if (filePaths.length > 0) {
-            fileUrls = await this.uploadTaskFiles(filePaths);
-          }
-        }
-        const recordingUrls = await this.finishTaskRecording(taskRecorder);
-        const allFileUrls = [...fileUrls || [], ...recordingUrls];
-        const eventType = finalStatus === "completed" ? "task.completed" : "task.failed";
-        fireWebhook(eventType, {
-          status: finalStatus,
-          result: sig.result,
-          error: sig.error,
-          iterations: iteration,
-          fileUrls: allFileUrls.length > 0 ? allFileUrls : void 0,
-          browserRecordingUrls: recordingUrls.length > 0 ? recordingUrls : void 0
-        });
-        const updatedTask2 = {
-          ...options.taskConfig,
-          status: finalStatus,
-          result: sig.result,
-          error: sig.error,
-          iterations: iteration
-        };
-        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,
-          error: sig.error,
-          iterations: iteration
-        };
+      const timeoutError = `Task did not complete within ${maxIterations} iterations`;
+      const timeoutRecordingUrls = await this.finishTaskRecording(taskRecorder);
+      fireWebhook("task.failed", {
+        status: "failed",
+        error: timeoutError,
+        iterations: iteration,
+        browserRecordingUrls: timeoutRecordingUrls.length > 0 ? timeoutRecordingUrls : void 0
+      });
+      const updatedTask = {
+        ...options.taskConfig,
+        status: "failed",
+        error: timeoutError,
+        iterations: iteration
+      };
+      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));
       }
-      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 } }));
+      return { status: "failed", error: timeoutError, iterations: iteration };
+    } finally {
+      for (const cleanup2 of taskScopedCleanups) {
+        try {
+          await cleanup2();
+        } catch {
         }
-        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", {
-      status: "failed",
-      error: timeoutError,
-      iterations: iteration,
-      browserRecordingUrls: timeoutRecordingUrls.length > 0 ? timeoutRecordingUrls : void 0
-    });
-    const updatedTask = {
-      ...options.taskConfig,
-      status: "failed",
-      error: timeoutError,
-      iterations: iteration
-    };
-    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 };
   }
   /**
    * Stop a task-mode browser recording, encode to MP4, upload to GCS.
@@ -9065,11 +9907,11 @@ ${p.text}` : p.text;
       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: join12, basename: basename5 } = await import("path");
+      const { join: join14, basename: basename5 } = await import("path");
       const urls = [];
       for (const filePath of filePaths) {
         try {
-          const fullPath = filePath.startsWith("/") ? filePath : join12(this.session.workingDirectory, filePath);
+          const fullPath = filePath.startsWith("/") ? filePath : join14(this.session.workingDirectory, filePath);
           const fileName = basename5(fullPath);
           const ext = fileName.split(".").pop()?.toLowerCase() || "";
           const mimeMap = {
@@ -9131,7 +9973,7 @@ ${p.text}` : p.text;
         description: originalTool.description || "",
         inputSchema: originalTool.inputSchema || z15.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid8();
+          const toolCallId = toolOptions.toolCallId || nanoid9();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,