@cremini/skillpack 1.2.10 → 1.2.12

package/dist/cli.js

@@ -42,6 +42,11 @@ function validateScheduledJobConfig(value, sourceLabel, index) {
     );
   }
   const job = value;
+  if (typeof job.id !== "string" || !job.id.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].id" is required`
+    );
+  }
   if (typeof job.name !== "string" || !job.name.trim()) {
     throw new Error(
       `Invalid job config from ${sourceLabel}: "jobs[${index}].name" is required`
@@ -92,16 +97,16 @@ function validateJobFileShape(value, sourceLabel) {
   if (!Array.isArray(jobFile.jobs)) {
     throw new Error(`Invalid job config from ${sourceLabel}: "jobs" must be an array`);
   }
-  const names = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
   jobFile.jobs.forEach((job, index) => {
     validateScheduledJobConfig(job, sourceLabel, index);
-    const normalizedName = job.name.trim().toLowerCase();
-    if (names.has(normalizedName)) {
+    const normalizedId = job.id.trim().toLowerCase();
+    if (ids.has(normalizedId)) {
       throw new Error(
-        `Invalid job config from ${sourceLabel}: duplicate job name "${job.name}" is not allowed`
+        `Invalid job config from ${sourceLabel}: duplicate job id "${job.id}" is not allowed`
       );
     }
-    names.add(normalizedName);
+    ids.add(normalizedId);
   });
 }
 function normalizeJobFile(jobFile) {
@@ -115,6 +120,7 @@ function normalizeScheduledJobConfig(job) {
   const normalizedCron = normalizeJobCron(job.cron);
   const normalizedTimezone = typeof job.timezone === "string" && job.timezone.trim() ? job.timezone.trim() : void 0;
   return {
+    id: job.id.trim(),
     name: job.name.trim(),
     ...normalizedCron ? { cron: normalizedCron } : {},
     prompt: job.prompt,
@@ -286,8 +292,16 @@ var init_commands = __esm({
 // src/runtime/adapters/types.ts
 var types_exports = {};
 __export(types_exports, {
+  detectPlatformFromChannelId: () => detectPlatformFromChannelId,
   isMessageSender: () => isMessageSender
 });
+function detectPlatformFromChannelId(channelId) {
+  if (channelId.startsWith("telegram-")) return "telegram";
+  if (channelId.startsWith("slack-")) return "slack";
+  if (channelId.startsWith("feishu-")) return "feishu";
+  if (channelId.startsWith("scheduler-")) return "scheduler";
+  return "web";
+}
 function isMessageSender(adapter) {
   return typeof adapter.sendMessage === "function";
 }
@@ -417,7 +431,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs17 from "fs";
+import fs14 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -735,7 +749,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs17.existsSync(filePath)) {
+          if (!fs14.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -755,8 +769,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs18 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path15 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
@@ -1391,12 +1405,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs18.existsSync(filePath)) {
+          if (!fs15.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path17.basename(filePath);
-          const fileContent = fs18.readFileSync(filePath);
+          const filename = path15.basename(filePath);
+          const fileContent = fs15.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1413,6 +1427,297 @@ var init_slack = __esm({
   }
 });
 
+// src/runtime/adapters/feishu.ts
+var feishu_exports = {};
+__export(feishu_exports, {
+  FeishuAdapter: () => FeishuAdapter,
+  normalizeFeishuMessage: () => normalizeFeishuMessage,
+  parseFeishuChannelId: () => parseFeishuChannelId
+});
+import fs16 from "fs";
+import path16 from "path";
+import * as Lark from "@larksuiteoapi/node-sdk";
+function parseFeishuChannelId(channelId) {
+  if (!channelId.startsWith("feishu-")) {
+    throw new Error(`[Feishu] Invalid channelId: ${channelId}`);
+  }
+  const chatId = channelId.replace("feishu-", "").trim();
+  if (!chatId) {
+    throw new Error(`[Feishu] Invalid channelId: ${channelId}`);
+  }
+  return chatId;
+}
+function normalizeFeishuMessage(message) {
+  if (message.chatType === "group" && !message.mentionedBot) {
+    return { action: "ignore" };
+  }
+  if (message.rawContentType !== "text") {
+    return { action: "unsupported" };
+  }
+  const text = message.content.trim();
+  if (!text) {
+    return { action: "ignore" };
+  }
+  return {
+    action: "handle",
+    text
+  };
+}
+var MAX_MESSAGE_LENGTH3, ACK_REACTION3, UNSUPPORTED_MESSAGE_REPLY, FILE_DELIVERY_FAILED_REPLY, FeishuAdapter;
+var init_feishu = __esm({
+  "src/runtime/adapters/feishu.ts"() {
+    "use strict";
+    init_commands();
+    MAX_MESSAGE_LENGTH3 = 1800;
+    ACK_REACTION3 = "THUMBSUP";
+    UNSUPPORTED_MESSAGE_REPLY = "Only text messages are currently supported. Please send plain text.";
+    FILE_DELIVERY_FAILED_REPLY = "A file was generated, but Feishu could not deliver it.";
+    FeishuAdapter = class {
+      name = "feishu";
+      channel = null;
+      agent = null;
+      ipcBroadcaster = null;
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      async start(ctx) {
+        this.agent = ctx.agent;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
+        this.channel = Lark.createLarkChannel({
+          appId: this.options.appId,
+          appSecret: this.options.appSecret,
+          loggerLevel: Lark.LoggerLevel.info,
+          transport: "websocket",
+          source: "skillpack",
+          policy: {
+            dmMode: "open",
+            requireMention: false
+          }
+        });
+        this.channel.on("message", (message) => {
+          void this.handleIncomingMessage(message).catch((error) => {
+            console.error("[Feishu] Error handling message:", error);
+          });
+        });
+        this.channel.on("error", (error) => {
+          console.error("[Feishu] Channel error:", error);
+        });
+        await this.channel.connect();
+        const botName = this.channel.botIdentity?.name;
+        console.log(
+          botName ? `[FeishuAdapter] Started as ${botName}` : "[FeishuAdapter] Started"
+        );
+      }
+      async stop() {
+        if (this.channel) {
+          await this.channel.disconnect();
+          this.channel = null;
+        }
+        console.log("[FeishuAdapter] Stopped");
+      }
+      async sendMessage(channelId, text) {
+        if (!this.channel) {
+          throw new Error("[Feishu] Channel not initialized");
+        }
+        const chatId = parseFeishuChannelId(channelId);
+        await this.sendLongMessage(chatId, text);
+      }
+      async sendFile(channelId, filePath, caption) {
+        if (!this.channel) {
+          throw new Error("[Feishu] Channel not initialized");
+        }
+        const chatId = parseFeishuChannelId(channelId);
+        const sent = await this.sendFileSafe(chatId, filePath, caption);
+        if (!sent) {
+          throw new Error(`[Feishu] Failed to send file: ${filePath}`);
+        }
+      }
+      async handleIncomingMessage(message) {
+        if (!this.channel || !this.agent) {
+          return;
+        }
+        const decision = normalizeFeishuMessage(message);
+        if (decision.action === "ignore") {
+          return;
+        }
+        await this.tryAckReaction(message.messageId);
+        const channelId = `feishu-${message.chatId}`;
+        if (decision.action === "unsupported") {
+          await this.sendSafe(message.chatId, UNSUPPORTED_MESSAGE_REPLY, message.messageId);
+          return;
+        }
+        const userText = decision.text;
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "feishu",
+          {
+            id: message.senderId,
+            username: message.senderName || message.senderId
+          },
+          userText
+        );
+        const command = this.resolveCommand(userText);
+        if (command) {
+          const result = await this.agent.handleCommand(command, channelId);
+          await this.sendSafe(
+            message.chatId,
+            result.message || `/${command} executed.`,
+            message.messageId
+          );
+          return;
+        }
+        let finalText = "";
+        let hasError = false;
+        let errorMessage = "";
+        const pendingFiles = [];
+        const onEvent = (event) => {
+          switch (event.type) {
+            case "text_delta":
+              finalText += event.delta;
+              break;
+            case "file_output":
+              pendingFiles.push({
+                filePath: event.filePath,
+                caption: event.caption
+              });
+              break;
+          }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
+        };
+        try {
+          const result = await this.agent.handleMessage(
+            "feishu",
+            channelId,
+            userText,
+            onEvent
+          );
+          if (result.errorMessage) {
+            hasError = true;
+            errorMessage = result.errorMessage;
+          }
+        } catch (error) {
+          hasError = true;
+          errorMessage = error instanceof Error ? error.message : String(error);
+        }
+        if (hasError) {
+          await this.sendSafe(message.chatId, `Error: ${errorMessage}`, message.messageId);
+          return;
+        }
+        if (finalText.trim()) {
+          await this.sendLongMessage(message.chatId, finalText, message.messageId);
+        } else if (pendingFiles.length === 0) {
+          await this.sendSafe(message.chatId, "(No response generated)", message.messageId);
+        }
+        let sentFileCount = 0;
+        for (const file of pendingFiles) {
+          if (await this.sendFileSafe(
+            message.chatId,
+            file.filePath,
+            file.caption,
+            message.messageId
+          )) {
+            sentFileCount += 1;
+          }
+        }
+        if (pendingFiles.length > 0 && sentFileCount === 0) {
+          await this.sendSafe(
+            message.chatId,
+            FILE_DELIVERY_FAILED_REPLY,
+            message.messageId
+          );
+        }
+      }
+      resolveCommand(text) {
+        return resolveCommand(text);
+      }
+      async sendLongMessage(chatId, text, replyTo) {
+        for (const chunk of this.splitMessage(text)) {
+          await this.sendSafe(chatId, chunk, replyTo);
+        }
+      }
+      splitMessage(text) {
+        if (text.length <= MAX_MESSAGE_LENGTH3) {
+          return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+          if (remaining.length <= MAX_MESSAGE_LENGTH3) {
+            chunks.push(remaining);
+            break;
+          }
+          let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH3);
+          if (splitAt < MAX_MESSAGE_LENGTH3 * 0.5) {
+            splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH3);
+          }
+          if (splitAt < MAX_MESSAGE_LENGTH3 * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH3);
+          }
+          if (splitAt < 1) {
+            splitAt = MAX_MESSAGE_LENGTH3;
+          }
+          chunks.push(remaining.slice(0, splitAt));
+          remaining = remaining.slice(splitAt).trimStart();
+        }
+        return chunks;
+      }
+      async tryAckReaction(messageId) {
+        if (!this.channel) {
+          return;
+        }
+        try {
+          await this.channel.addReaction(messageId, ACK_REACTION3);
+        } catch (error) {
+          console.error("[Feishu] Failed to add ack reaction:", error);
+        }
+      }
+      async sendFileSafe(chatId, filePath, caption, replyTo) {
+        if (!this.channel) {
+          return false;
+        }
+        try {
+          if (!fs16.existsSync(filePath)) {
+            console.error(`[Feishu] File not found for sending: ${filePath}`);
+            return false;
+          }
+          if (caption?.trim()) {
+            await this.sendSafe(chatId, caption, replyTo);
+          }
+          await this.channel.send(
+            chatId,
+            {
+              file: {
+                source: filePath,
+                fileName: path16.basename(filePath)
+              }
+            },
+            replyTo ? { replyTo } : void 0
+          );
+          return true;
+        } catch (error) {
+          console.error("[Feishu] Failed to send file:", error);
+          return false;
+        }
+      }
+      async sendSafe(chatId, text, replyTo) {
+        if (!this.channel) {
+          return;
+        }
+        try {
+          await this.channel.send(
+            chatId,
+            { markdown: text },
+            replyTo ? { replyTo } : void 0
+          );
+        } catch (error) {
+          console.error("[Feishu] Failed to send message:", error);
+        }
+      }
+    };
+  }
+});
+
 // src/runtime/adapters/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -1427,31 +1732,36 @@ function isValidTimezone(tz) {
     return false;
   }
 }
-function isValidJobName(name) {
-  return VALID_JOB_NAME.test(name) && name.length <= 64;
+function isValidJobId(id) {
+  return id.length > 0 && id.length <= 128 && !INVALID_JOB_ID_CHARS.test(id);
 }
 function isRecurringJob(jobConfig) {
   return hasJobSchedule(jobConfig);
 }
-var VALID_JOB_NAME, SchedulerAdapter;
+var INVALID_JOB_ID_CHARS, SchedulerAdapter;
 var init_scheduler = __esm({
   "src/runtime/adapters/scheduler.ts"() {
     "use strict";
     init_job_config();
     init_job_schedule();
-    VALID_JOB_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+    INVALID_JOB_ID_CHARS = /[\\/\r\n]/;
     SchedulerAdapter = class {
       name = "scheduler";
       agent;
       rootDir = "";
+      ipcBroadcaster = null;
       notifyFn = async () => {
       };
       jobs = /* @__PURE__ */ new Map();
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.notifyFn = ctx.notify || (async () => {
         });
+        console.log(
+          `[Scheduler] IPC broadcaster ${this.ipcBroadcaster ? "attached" : "not available"} for agent events`
+        );
         const jobConfigs = loadJobFile(this.rootDir).jobs;
         let scheduledCount = 0;
         let disabledCount = 0;
@@ -1488,8 +1798,8 @@ var init_scheduler = __esm({
       registerJob(jobConfig) {
         const normalizedConfig = normalizeScheduledJobConfig(jobConfig);
         const normalizedCron = normalizeJobCron(normalizedConfig.cron);
-        if (!isValidJobName(normalizedConfig.name)) {
-          const msg = `[Scheduler] Invalid job name "${normalizedConfig.name}": must match ${VALID_JOB_NAME} and be \u226464 chars`;
+        if (!isValidJobId(normalizedConfig.id)) {
+          const msg = `[Scheduler] Invalid job id "${normalizedConfig.id}": must be non-empty, must not contain "/", "\\\\", or line breaks, and must be \u2264128 chars`;
           console.error(msg);
           return { registered: false, message: msg };
         }
@@ -1505,7 +1815,7 @@ var init_scheduler = __esm({
             return { registered: false, message: msg };
           }
         }
-        this.removeFromMap(normalizedConfig.name);
+        this.removeFromMap(normalizedConfig.id);
         let task = null;
         if (normalizedCron && normalizedConfig.enabled !== false) {
           task = this.createCronTask(normalizedConfig);
@@ -1521,7 +1831,7 @@ var init_scheduler = __esm({
             `[Scheduler] Job "${normalizedConfig.name}" registered as one-time (manual trigger only)`
           );
         }
-        this.jobs.set(normalizedConfig.name, {
+        this.jobs.set(normalizedConfig.id, {
           config: normalizedConfig,
           task,
           running: false,
@@ -1537,8 +1847,8 @@ var init_scheduler = __esm({
        * Returns { text, notifyFailed } so callers can produce accurate status.
        */
       async runJob(jobConfig) {
-        const channelId = `scheduler-${jobConfig.name}`;
-        const job = this.jobs.get(jobConfig.name);
+        const channelId = `scheduler-${jobConfig.id}`;
+        const job = this.jobs.get(jobConfig.id);
         if (job?.running) {
           console.warn(
             `[Scheduler] Job "${jobConfig.name}" is already running, skipping this trigger`
@@ -1549,8 +1859,27 @@ var init_scheduler = __esm({
         console.log(`[Scheduler] Running job "${jobConfig.name}"`);
         let fullText = "";
         let agentFailed = false;
+        let loggedFirstTextDelta = false;
+        let sawAgentStart = false;
+        let sawAgentEnd = false;
         const pendingFiles = [];
         const onEvent = (event) => {
+          if (event.type === "agent_start") {
+            sawAgentStart = true;
+          } else if (event.type === "agent_end") {
+            sawAgentEnd = true;
+          }
+          if (event.type === "agent_start" || event.type === "agent_end") {
+            console.log(
+              `[Scheduler] Forwarding ${event.type} for ${channelId} (ipc=${this.ipcBroadcaster ? "yes" : "no"})`
+            );
+          } else if (event.type === "text_delta" && !loggedFirstTextDelta) {
+            loggedFirstTextDelta = true;
+            console.log(
+              `[Scheduler] Forwarding first text_delta for ${channelId} (${event.delta.length} chars, ipc=${this.ipcBroadcaster ? "yes" : "no"})`
+            );
+          }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
           if (event.type === "text_delta") fullText += event.delta;
           if (event.type === "file_output") {
             pendingFiles.push({
@@ -1568,6 +1897,7 @@ var init_scheduler = __esm({
             onEvent,
             void 0
           );
+          this.ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent);
           if (result.errorMessage) {
             fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u6267\u884C\u5931\u8D25\uFF1A${result.errorMessage}`;
             agentFailed = true;
@@ -1576,6 +1906,7 @@ var init_scheduler = __esm({
             if (job) job.lastError = void 0;
           }
         } catch (err) {
+          this.ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent);
           const errorMsg = err instanceof Error ? err.message : String(err);
           fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u5F02\u5E38\uFF1A${errorMsg}`;
           agentFailed = true;
@@ -1612,10 +1943,19 @@ var init_scheduler = __esm({
         return { text: fullText, notifyFailed };
       }
       async clearJobContext(channelId) {
+        console.log(`[Scheduler] Clearing context for ${channelId}`);
         const result = await this.agent.handleCommand("clear", channelId);
         if (!result.success) {
           throw new Error(result.message || `Failed to clear context for ${channelId}`);
         }
+        console.log(`[Scheduler] Context cleared for ${channelId}`);
+      }
+      ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent) {
+        if (!sawAgentStart || sawAgentEnd) {
+          return;
+        }
+        console.log(`[Scheduler] Synthesizing agent_end for ${channelId}`);
+        onEvent({ type: "agent_end" });
       }
       // -------------------------------------------------------------------------
       // Dynamic management API
@@ -1624,7 +1964,7 @@ var init_scheduler = __esm({
        * Add a new job, persist to job.json.
        */
       addJob(jobConfig) {
-        if (this.jobs.has(jobConfig.name)) {
+        if (this.jobs.has(jobConfig.id)) {
           return {
             success: false,
             message: `Job "${jobConfig.name}" already exists. Remove it first.`
@@ -1645,21 +1985,23 @@ var init_scheduler = __esm({
       /**
        * Remove a job and persist to job.json.
        */
-      removeJob(name) {
-        if (!this.jobs.has(name)) {
-          return { success: false, message: `Job "${name}" not found.` };
+      removeJob(id) {
+        const job = this.jobs.get(id);
+        if (!job) {
+          return { success: false, message: `Job "${id}" not found.` };
         }
-        this.removeFromMap(name);
+        this.removeFromMap(id);
         this.persistJobs();
-        return { success: true, message: `Job "${name}" removed.` };
+        return { success: true, message: `Job "${job.config.name}" removed.` };
       }
-      updateJob(name, updates) {
-        const job = this.jobs.get(name);
+      updateJob(id, updates) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         const nextConfig = {
-          name,
+          id: job.config.id,
+          name: job.config.name,
           cron: updates.cron,
           prompt: updates.prompt,
           notify: updates.notify,
@@ -1673,21 +2015,21 @@ var init_scheduler = __esm({
         this.persistJobs();
         return {
           success: true,
-          message: `Job "${name}" updated.`
+          message: `Job "${job.config.name}" updated.`
         };
       }
       /**
        * Enable or disable a job and persist.
        */
-      setEnabled(name, enabled) {
-        const job = this.jobs.get(name);
+      setEnabled(id, enabled) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         if (!isRecurringJob(job.config)) {
           return {
             success: false,
-            message: `Job "${name}" does not have a schedule and cannot be enabled or disabled.`
+            message: `Job "${job.config.name}" does not have a schedule and cannot be enabled or disabled.`
           };
         }
         job.config.enabled = enabled;
@@ -1701,33 +2043,33 @@ var init_scheduler = __esm({
         this.persistJobs();
         return {
           success: true,
-          message: `Job "${name}" ${enabled ? "enabled" : "disabled"}.`
+          message: `Job "${job.config.name}" ${enabled ? "enabled" : "disabled"}.`
         };
       }
       /**
        * Manually trigger a job (runs immediately, ignoring cron schedule).
        */
-      async triggerJob(name) {
-        const job = this.jobs.get(name);
+      async triggerJob(id) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         const { text, notifyFailed } = await this.runJob(job.config);
         if (!text) {
           return {
             success: true,
-            message: `Job "${name}" triggered but produced no output.`
+            message: `Job "${job.config.name}" triggered but produced no output.`
           };
         }
         if (notifyFailed) {
           return {
             success: true,
-            message: `Job "${name}" executed, but notification to ${job.config.notify.adapter} failed. Check logs.`
+            message: `Job "${job.config.name}" executed, but notification to ${job.config.notify.adapter} failed. Check logs.`
           };
         }
         return {
           success: true,
-          message: `Job "${name}" triggered. Result sent to ${job.config.notify.adapter}.`
+          message: `Job "${job.config.name}" triggered. Result sent to ${job.config.notify.adapter}.`
         };
       }
       /**
@@ -1737,6 +2079,7 @@ var init_scheduler = __esm({
         const result = [];
         for (const [, job] of this.jobs) {
           result.push({
+            id: job.config.id,
             name: job.config.name,
             ...job.config.cron ? { cron: job.config.cron } : {},
             prompt: job.config.prompt,
@@ -1757,11 +2100,11 @@ var init_scheduler = __esm({
       /**
        * Stop the cron task and remove a job from the map (does NOT persist).
        */
-      removeFromMap(name) {
-        const existing = this.jobs.get(name);
+      removeFromMap(id) {
+        const existing = this.jobs.get(id);
         if (existing) {
           existing.task?.stop();
-          this.jobs.delete(name);
+          this.jobs.delete(id);
         }
       }
       /**
@@ -2480,23 +2823,23 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path19 from "path";
-import fs20 from "fs";
+import path18 from "path";
+import fs18 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path18 from "path";
-import fs19 from "fs";
+import path17 from "path";
+import fs17 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
 
 // src/runtime/agent.ts
-import path13 from "path";
-import fs13 from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
+import path11 from "path";
+import fs10 from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -2726,40 +3069,238 @@ var ConfigFileAuthBackend = class {
 // src/runtime/agent.ts
 init_attachment_utils();
 
-// src/runtime/artifacts/query-service.ts
-function clampLimit(limit, fallback, max) {
-  if (!Number.isFinite(limit)) {
-    return fallback;
+// src/runtime/custom-tools/delegated-custom-tool-client.ts
+import { randomUUID } from "crypto";
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function assertToolDefinitions(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid delegated custom tool definitions response");
+  }
+  for (const definition of value) {
+    if (!isObject(definition) || typeof definition.name !== "string" || typeof definition.label !== "string" || typeof definition.description !== "string" || !isObject(definition.parameters)) {
+      throw new Error("Invalid delegated custom tool definition");
+    }
   }
-  const normalized = Math.floor(limit);
-  return Math.max(1, Math.min(normalized, max));
 }
-function clampOffset(offset) {
-  if (!Number.isFinite(offset)) {
-    return 0;
+function assertToolResult(value) {
+  if (!isObject(value) || !Array.isArray(value.content)) {
+    throw new Error("Invalid delegated custom tool result");
   }
-  return Math.max(0, Math.floor(offset));
 }
-var ResultsQueryService = class {
-  constructor(resultStore) {
-    this.resultStore = resultStore;
-  }
-  async listRecentArtifacts(options = {}) {
-    return this.resultStore.listRecentArtifacts({
-      channelId: options.channelId,
-      limit: clampLimit(options.limit, 100, 500),
-      offset: clampOffset(options.offset)
+var DelegatedCustomToolClient = class {
+  constructor(transport = process, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
+    this.transport.on("message", this.handleMessage);
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  timeoutMs;
+  disposed = false;
+  isAvailable() {
+    return typeof this.transport.send === "function" && this.transport.connected !== false;
+  }
+  async listDefinitions() {
+    if (!this.isAvailable()) {
+      return [];
+    }
+    const data = await this.sendRequest("get_custom_tool_definitions");
+    assertToolDefinitions(data);
+    return data;
+  }
+  async executeTool(input) {
+    const data = await this.sendRequest("execute_custom_tool", input);
+    assertToolResult(data);
+    return data;
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.transport.off("message", this.handleMessage);
+    this.rejectAllPending(new Error("Delegated custom tool client disposed"));
+  }
+  sendRequest(type, payload) {
+    if (!this.isAvailable()) {
+      throw new Error("Delegated custom tool IPC channel is not available");
+    }
+    const id = randomUUID();
+    const request = {
+      id,
+      type,
+      ...payload || {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Delegated custom tool request timed out: ${type}`));
+      }, this.timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(request);
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
+  handleMessage = (message) => {
+    if (!isObject(message)) {
+      return;
+    }
+    const payload = message;
+    if (typeof payload.id !== "string" || payload.type !== "result" && payload.type !== "error") {
+      return;
+    }
+    const pending = this.pendingRequests.get(payload.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(payload.id);
+    if (payload.type === "error") {
+      pending.reject(new Error(payload.message));
+      return;
+    }
+    pending.resolve(payload.data);
+  };
+  rejectAllPending(error) {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pendingRequests.delete(id);
+    }
+  }
 };
 
-// src/runtime/artifacts/snapshot-service.ts
-import { randomUUID } from "crypto";
-import fs9 from "fs";
+// src/runtime/custom-tools/delegated-custom-tool-factory.ts
+function toAgentToolResult(result) {
+  return {
+    content: result.content,
+    details: result.details
+  };
+}
+function createDelegatedCustomTools(definitions, client, runContextRef) {
+  return definitions.map((definition) => ({
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    promptSnippet: definition.promptSnippet,
+    promptGuidelines: definition.promptGuidelines,
+    parameters: definition.parameters,
+    async execute(toolCallId, params) {
+      const runContext = runContextRef.current;
+      if (!runContext) {
+        throw new Error(
+          `Delegated custom tool ${definition.name} is not available outside an active run.`
+        );
+      }
+      return toAgentToolResult(
+        await client.executeTool({
+          toolName: definition.name,
+          toolCallId,
+          runContext,
+          params
+        })
+      );
+    }
+  }));
+}
+
+// src/runtime/host-ipc/host-ipc-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function isObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+var HostIpcClient = class {
+  constructor(transport = process, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
+    this.transport.on("message", this.handleMessage);
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  timeoutMs;
+  disposed = false;
+  isAvailable() {
+    return typeof this.transport.send === "function" && this.transport.connected !== false;
+  }
+  async notifyChannelSessionCleared(input) {
+    if (!this.isAvailable()) {
+      return;
+    }
+    await this.sendRequest("channel_session_cleared", input);
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.transport.off("message", this.handleMessage);
+    this.rejectAllPending(new Error("Host IPC client disposed"));
+  }
+  sendRequest(type, payload) {
+    if (!this.isAvailable()) {
+      throw new Error("Host IPC channel is not available");
+    }
+    const id = randomUUID2();
+    const request = {
+      id,
+      type,
+      ...payload || {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Host IPC request timed out: ${type}`));
+      }, this.timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(request);
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  handleMessage = (message) => {
+    if (!isObject2(message)) {
+      return;
+    }
+    const payload = message;
+    if (typeof payload.id !== "string" || payload.type !== "result" && payload.type !== "error") {
+      return;
+    }
+    const pending = this.pendingRequests.get(payload.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(payload.id);
+    if (payload.type === "error") {
+      pending.reject(new Error(payload.message));
+      return;
+    }
+    pending.resolve(payload.data);
+  };
+  rejectAllPending(error) {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pendingRequests.delete(id);
+    }
+  }
+};
+
+// src/runtime/tools/send-file-tool.ts
+import fs8 from "fs";
 import path9 from "path";
+import { Type } from "@sinclair/typebox";
 
 // src/runtime/files/metadata.ts
-import fs8 from "fs";
 import path8 from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
@@ -2789,419 +3330,14 @@ function isWithinDirectory(parentDir, targetPath) {
   const relativePath = path8.relative(path8.resolve(parentDir), path8.resolve(targetPath));
   return relativePath !== ".." && !relativePath.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relativePath);
 }
-function toPackRelativePath(rootDir, filePath) {
-  const resolvedRoot = path8.resolve(rootDir);
-  const resolvedFile = path8.resolve(filePath);
-  if (!isWithinDirectory(resolvedRoot, resolvedFile)) {
-    throw new Error(`Path is outside the pack root: ${resolvedFile}`);
-  }
-  return path8.relative(resolvedRoot, resolvedFile).split(path8.sep).join("/");
-}
-function resolvePackFile(rootDir, filePath) {
-  if (!path8.isAbsolute(filePath)) {
-    throw new Error(`filePath must be absolute: ${filePath}`);
-  }
-  const resolvedPath = path8.resolve(filePath);
-  if (!isWithinDirectory(rootDir, resolvedPath)) {
-    throw new Error(`File is outside the pack root: ${resolvedPath}`);
-  }
-  if (!fs8.existsSync(resolvedPath)) {
-    throw new Error(`File not found: ${resolvedPath}`);
-  }
-  const stats = fs8.statSync(resolvedPath);
-  if (!stats.isFile()) {
-    throw new Error(`Path is not a file: ${resolvedPath}`);
-  }
-  fs8.accessSync(resolvedPath, fs8.constants.R_OK);
-  return {
-    resolvedPath,
-    fileName: path8.basename(resolvedPath),
-    mimeType: detectMimeType(resolvedPath),
-    sizeBytes: stats.size
-  };
-}
-
-// src/runtime/artifacts/snapshot-service.ts
-function sanitizeFileName(fileName) {
-  const sanitized = fileName.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  return sanitized || "artifact";
-}
-function formatSnapshotStamp(isoDate) {
-  const normalized = isoDate.replace(/\D+/g, "").slice(0, 14);
-  return normalized || String(Date.now());
-}
-var ArtifactSnapshotService = class {
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  createSnapshots(runId, artifacts, declaredAt) {
-    if (artifacts.length === 0) {
-      return [];
-    }
-    const artifactsRoot = path9.resolve(this.rootDir, "data", "artifacts");
-    const runDir = path9.join(artifactsRoot, runId);
-    const tempDir = path9.join(
-      artifactsRoot,
-      `.tmp-${runId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-    );
-    const snapshots = [];
-    const movedPaths = [];
-    const snapshotNames = artifacts.map((artifact) => [
-      formatSnapshotStamp(declaredAt),
-      randomUUID(),
-      sanitizeFileName(artifact.fileName)
-    ].join("-"));
-    fs9.mkdirSync(artifactsRoot, { recursive: true });
-    fs9.mkdirSync(tempDir, { recursive: true });
-    try {
-      snapshotNames.forEach((snapshotName, index) => {
-        fs9.copyFileSync(
-          artifacts[index].filePath,
-          path9.join(tempDir, snapshotName)
-        );
-      });
-      fs9.mkdirSync(runDir, { recursive: true });
-      snapshotNames.forEach((snapshotName, index) => {
-        const artifact = artifacts[index];
-        const tempSnapshotPath = path9.join(tempDir, snapshotName);
-        const finalSnapshotPath = path9.join(runDir, snapshotName);
-        fs9.renameSync(tempSnapshotPath, finalSnapshotPath);
-        movedPaths.push(finalSnapshotPath);
-        snapshots.push({
-          declaredAt,
-          originalPath: toPackRelativePath(this.rootDir, artifact.filePath),
-          snapshotPath: path9.join("data", "artifacts", runId, snapshotName).split(path9.sep).join("/"),
-          fileName: artifact.fileName,
-          mimeType: artifact.mimeType,
-          sizeBytes: artifact.sizeBytes,
-          title: artifact.title,
-          isPrimary: artifact.isPrimary
-        });
-      });
-      fs9.rmSync(tempDir, { recursive: true, force: true });
-      return snapshots;
-    } catch (error) {
-      fs9.rmSync(tempDir, { recursive: true, force: true });
-      movedPaths.forEach((filePath) => fs9.rmSync(filePath, { force: true }));
-      this.removeEmptyRunDirectory(runDir);
-      throw error;
-    }
-  }
-  removeSnapshots(snapshotPaths) {
-    const visitedRunDirs = /* @__PURE__ */ new Set();
-    for (const snapshotPath of snapshotPaths) {
-      const resolvedPath = path9.resolve(this.rootDir, snapshotPath);
-      fs9.rmSync(resolvedPath, { force: true });
-      visitedRunDirs.add(path9.dirname(resolvedPath));
-    }
-    visitedRunDirs.forEach((runDir) => this.removeEmptyRunDirectory(runDir));
-  }
-  removeEmptyRunDirectory(runDir) {
-    try {
-      if (!fs9.existsSync(runDir)) {
-        return;
-      }
-      if (fs9.readdirSync(runDir).length === 0) {
-        fs9.rmdirSync(runDir);
-      }
-    } catch {
-    }
-  }
-};
-
-// src/runtime/artifacts/persistence-service.ts
-var ArtifactPersistenceService = class {
-  constructor(snapshotService, resultStore) {
-    this.snapshotService = snapshotService;
-    this.resultStore = resultStore;
-  }
-  async saveArtifacts(input) {
-    const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
-    const snapshots = this.snapshotService.createSnapshots(
-      input.runId,
-      input.artifacts,
-      declaredAt
-    );
-    try {
-      await this.resultStore.insertArtifacts({
-        runId: input.runId,
-        channelId: input.channelId,
-        artifacts: snapshots
-      });
-      return snapshots.length;
-    } catch (error) {
-      this.snapshotService.removeSnapshots(
-        snapshots.map((artifact) => artifact.snapshotPath)
-      );
-      throw error;
-    }
-  }
-};
-
-// src/runtime/artifacts/store.ts
-import fs10 from "fs";
-import path10 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-import sqlite3 from "sqlite3";
-function mapArtifactRow(row) {
-  return {
-    artifactId: row.artifact_id,
-    runId: row.run_id,
-    channelId: row.channel_id,
-    originalPath: row.original_path,
-    snapshotPath: row.snapshot_path,
-    fileName: row.file_name,
-    mimeType: row.mime_type,
-    sizeBytes: row.size_bytes,
-    title: row.title,
-    isPrimary: row.is_primary === 1,
-    declaredAt: row.declared_at
-  };
-}
-var ResultStore = class {
-  db = null;
-  ready;
-  constructor(rootDir) {
-    const dataDir = path10.resolve(rootDir, "data");
-    fs10.mkdirSync(dataDir, { recursive: true });
-    this.ready = this.initialize(path10.join(dataDir, "result-v2.db"));
-  }
-  async initialize(databasePath) {
-    this.db = await openDatabase(databasePath);
-    await this.exec("PRAGMA journal_mode = WAL");
-    await this.exec(`
-      CREATE TABLE IF NOT EXISTS artifacts (
-        artifact_id TEXT PRIMARY KEY,
-        run_id TEXT NOT NULL,
-        channel_id TEXT NOT NULL,
-        original_path TEXT NOT NULL,
-        snapshot_path TEXT NOT NULL,
-        file_name TEXT NOT NULL,
-        mime_type TEXT,
-        size_bytes INTEGER NOT NULL,
-        title TEXT,
-        is_primary INTEGER NOT NULL DEFAULT 0,
-        declared_at TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_artifacts_channel_declared_at
-      ON artifacts(channel_id, declared_at DESC);
-    `);
-  }
-  async insertArtifacts(input) {
-    await this.ready;
-    if (input.artifacts.length === 0) {
-      return;
-    }
-    const insertArtifact = `
-      INSERT INTO artifacts (
-        artifact_id,
-        run_id,
-        channel_id,
-        original_path,
-        snapshot_path,
-        file_name,
-        mime_type,
-        size_bytes,
-        title,
-        is_primary,
-        declared_at
-      ) VALUES (
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?,
-        ?
-      )
-    `;
-    await this.exec("BEGIN");
-    try {
-      for (const artifact of input.artifacts) {
-        await this.run(insertArtifact, [
-          randomUUID2(),
-          input.runId,
-          input.channelId,
-          artifact.originalPath,
-          artifact.snapshotPath,
-          artifact.fileName,
-          artifact.mimeType ?? null,
-          artifact.sizeBytes,
-          artifact.title ?? null,
-          artifact.isPrimary ? 1 : 0,
-          artifact.declaredAt
-        ]);
-      }
-      await this.exec("COMMIT");
-    } catch (error) {
-      await this.rollback();
-      throw error;
-    }
-  }
-  async listRecentArtifacts(options = {}) {
-    await this.ready;
-    const limit = options.limit ?? 100;
-    const offset = options.offset ?? 0;
-    const conditions = [];
-    const params = [];
-    if (options.channelId) {
-      conditions.push("channel_id = ?");
-      params.push(options.channelId);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const rows = await this.all(`
-      SELECT *
-      FROM artifacts
-      ${whereClause}
-      ORDER BY declared_at DESC, rowid DESC
-      LIMIT ? OFFSET ?
-    `, [...params, limit, offset]);
-    return rows.map(mapArtifactRow);
-  }
-  getDatabase() {
-    if (!this.db) {
-      throw new Error("Result store database is not ready");
-    }
-    return this.db;
-  }
-  exec(sql) {
-    const db = this.getDatabase();
-    return new Promise((resolve, reject) => {
-      db.exec(sql, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-  run(sql, params = []) {
-    const db = this.getDatabase();
-    return new Promise((resolve, reject) => {
-      db.run(sql, params, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-  all(sql, params = []) {
-    const db = this.getDatabase();
-    return new Promise((resolve, reject) => {
-      db.all(sql, params, (error, rows) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(rows);
-      });
-    });
-  }
-  async rollback() {
-    try {
-      await this.exec("ROLLBACK");
-    } catch {
-    }
-  }
-};
-function openDatabase(databasePath) {
-  return new Promise((resolve, reject) => {
-    const db = new sqlite3.Database(databasePath, (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(db);
-    });
-  });
-}
-
-// src/runtime/artifacts/save-artifacts-tool.ts
-import { Type } from "@sinclair/typebox";
-var ArtifactItem = Type.Object({
-  filePath: Type.String({
-    description: "Absolute path to the artifact file. The file must exist, be readable, and be inside the current pack root."
-  }),
-  title: Type.Optional(
-    Type.String({
-      description: "Optional short title shown in the dashboard."
-    })
-  ),
-  isPrimary: Type.Optional(
-    Type.Boolean({
-      description: "Mark this artifact as a primary output."
-    })
-  )
-});
-var SaveArtifactsParams = Type.Object({
-  artifacts: Type.Array(ArtifactItem, {
-    minItems: 1,
-    description: "The artifact files to save for this run."
-  })
-});
-function textResult(text) {
-  return { content: [{ type: "text", text }], details: void 0 };
-}
-function normalizeOptionalText(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function createSaveArtifactsTool(rootDir, saveCallbackRef) {
-  return {
-    name: "save_artifacts",
-    label: "Save Artifacts",
-    description: [
-      "Save the final output files produced by this run.",
-      "Always use this for user-facing deliverables that are part of the final result.",
-      "Do not use this for intermediate, temporary, draft, or scratch files.",
-      "Each filePath must be an absolute path inside the current pack root."
-    ].join("\n"),
-    promptSnippet: "save_artifacts: Save final result files for this task. Always call this for user-facing final deliverables, and never for intermediate files. Use absolute paths inside the current pack root.",
-    promptGuidelines: [
-      "Whenever you create a final result file for the user, call `save_artifacts` before finishing the response.",
-      "Do not call `save_artifacts` for intermediate, temporary, draft, or scratch files."
-    ],
-    parameters: SaveArtifactsParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const saveArtifacts = saveCallbackRef.current;
-      if (!saveArtifacts) {
-        throw new Error("Artifact saving is not available for this run.");
-      }
-      const artifacts = params.artifacts.map((artifact) => {
-        const metadata = resolvePackFile(rootDir, artifact.filePath);
-        return {
-          filePath: metadata.resolvedPath,
-          fileName: metadata.fileName,
-          mimeType: metadata.mimeType,
-          sizeBytes: metadata.sizeBytes,
-          title: normalizeOptionalText(artifact.title),
-          isPrimary: artifact.isPrimary === true
-        };
-      });
-      const savedCount = await saveArtifacts(artifacts);
-      return textResult(`Saved ${savedCount} artifact(s).`);
-    }
-  };
-}
 
 // src/runtime/tools/send-file-tool.ts
-import fs11 from "fs";
-import path11 from "path";
-import { Type as Type2 } from "@sinclair/typebox";
-var SendFileParams = Type2.Object({
-  filePath: Type2.String({
+var SendFileParams = Type.Object({
+  filePath: Type.String({
     description: "Absolute path to the file to send to the user. The file must exist and be readable."
   }),
-  caption: Type2.Optional(
-    Type2.String({
+  caption: Type.Optional(
+    Type.String({
       description: "Optional caption or description to accompany the file."
     })
   )
@@ -3215,13 +3351,13 @@ function createSendFileTool(fileOutputCallbackRef) {
     parameters: SendFileParams,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const { filePath, caption } = params;
-      if (!fs11.existsSync(filePath)) {
+      if (!fs8.existsSync(filePath)) {
         return {
           content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
           details: void 0
         };
       }
-      const stats = fs11.statSync(filePath);
+      const stats = fs8.statSync(filePath);
       if (!stats.isFile()) {
         return {
           content: [
@@ -3230,7 +3366,7 @@ function createSendFileTool(fileOutputCallbackRef) {
           details: void 0
         };
       }
-      const filename = path11.basename(filePath);
+      const filename = path9.basename(filePath);
       const mimeType = detectMimeType(filePath);
       const callback = fileOutputCallbackRef.current;
       if (callback) {
@@ -3257,53 +3393,75 @@ function createSendFileTool(fileOutputCallbackRef) {
 }
 
 // src/runtime/tools/manage-schedule-tool.ts
-import { Type as Type3 } from "@sinclair/typebox";
-var ManageScheduleParams = Type3.Object({
-  action: Type3.Union(
+import { randomUUID as randomUUID3 } from "crypto";
+import { Type as Type2 } from "@sinclair/typebox";
+var ManageScheduleParams = Type2.Object({
+  action: Type2.Union(
     [
-      Type3.Literal("add"),
-      Type3.Literal("list"),
-      Type3.Literal("remove"),
-      Type3.Literal("trigger"),
-      Type3.Literal("enable"),
-      Type3.Literal("disable")
+      Type2.Literal("add"),
+      Type2.Literal("list"),
+      Type2.Literal("remove"),
+      Type2.Literal("trigger"),
+      Type2.Literal("enable"),
+      Type2.Literal("disable")
     ],
     { description: "The action to perform." }
   ),
-  name: Type3.Optional(
-    Type3.String({
-      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
+  name: Type2.Optional(
+    Type2.String({
+      description: "Display name for the scheduled task. Required for add/remove/trigger/enable/disable."
     })
   ),
-  cron: Type3.Optional(
-    Type3.String({
+  cron: Type2.Optional(
+    Type2.String({
       description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
     })
   ),
-  prompt: Type3.Optional(
-    Type3.String({
+  prompt: Type2.Optional(
+    Type2.String({
       description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
     })
   ),
-  timezone: Type3.Optional(
-    Type3.String({
+  timezone: Type2.Optional(
+    Type2.String({
       description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
     })
   ),
-  notifyAdapter: Type3.Optional(
-    Type3.String({
-      description: "Optional target adapter for notifications. If omitted, the current chat is used when supported (Telegram, Slack, or Web)."
+  notifyAdapter: Type2.Optional(
+    Type2.String({
+      description: "Optional target adapter for notifications. If omitted, the current chat is used when supported (Telegram, Slack, Feishu, or Web)."
     })
   ),
-  notifyChannelId: Type3.Optional(
-    Type3.String({
+  notifyChannelId: Type2.Optional(
+    Type2.String({
       description: "Optional target channelId for notifications. Must be provided together with notifyAdapter when overriding the default target."
     })
   )
 });
-function textResult2(text) {
+function textResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
+function resolveJobId(scheduler, nameOrId) {
+  const jobs = scheduler.listJobs();
+  const byId = jobs.find((job) => job.id === nameOrId);
+  if (byId) {
+    return { ok: true, jobId: byId.id };
+  }
+  const byName = jobs.filter((job) => job.name === nameOrId);
+  if (byName.length === 1) {
+    return { ok: true, jobId: byName[0].id };
+  }
+  if (byName.length > 1) {
+    return {
+      ok: false,
+      message: `Error: Multiple scheduled tasks share the name '${nameOrId}'. Rename one of them before using this action.`
+    };
+  }
+  return {
+    ok: false,
+    message: `Error: Scheduled task '${nameOrId}' was not found.`
+  };
+}
 function getDefaultNotifyTarget(adapter, channelId) {
   if (adapter === "telegram" && channelId.startsWith("telegram-")) {
     return { adapter: "telegram", channelId };
@@ -3311,12 +3469,15 @@ function getDefaultNotifyTarget(adapter, channelId) {
   if (adapter === "slack" && channelId.startsWith("slack-")) {
     return { adapter: "slack", channelId };
   }
+  if (adapter === "feishu" && channelId.startsWith("feishu-")) {
+    return { adapter: "feishu", channelId };
+  }
   if (adapter === "web") {
     return { adapter: "web", channelId };
   }
   return null;
 }
-function createManageScheduleTool(schedulerRef, adapter, channelId) {
+function createManageScheduleTool(schedulerRef, adapter, channelId, generateJobId = randomUUID3) {
   return {
     name: "manage_scheduled_task",
     label: "Manage Scheduled Task",
@@ -3324,11 +3485,11 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
       "Manage scheduled tasks (cron jobs) that automatically execute prompts and push results to IM channels.",
       "",
       "Actions:",
-      "- add: Create a new scheduled task. Requires: name, cron, prompt. Notifications default to the current Telegram, Slack, or Web chat. You can override the destination with notifyAdapter + notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
+      "- add: Create a new scheduled task. Requires: name, cron, prompt. Notifications default to the current Telegram, Slack, Feishu, or Web chat. You can override the destination with notifyAdapter + notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
       "- list: List all scheduled tasks with their status.",
-      "- remove: Remove a scheduled task by name.",
-      "- trigger: Manually trigger a scheduled task by name (runs immediately).",
-      "- enable: Enable a disabled scheduled task.",
+      "- remove: Remove a scheduled task by display name.",
+      "- trigger: Manually trigger a scheduled task by display name (runs immediately).",
+      "- enable: Enable a disabled scheduled task by display name.",
       "- disable: Disable a scheduled task without removing it.",
       "",
       "Cron expression format: '* * * * *' (minute hour day month weekday)",
@@ -3341,7 +3502,7 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const scheduler = schedulerRef.current;
       if (!scheduler) {
-        return textResult2(
+        return textResult(
           "Error: Scheduler is not available. The scheduled task system may not be initialized."
         );
       }
@@ -3349,24 +3510,24 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
         case "list": {
           const jobs = scheduler.listJobs();
           if (jobs.length === 0) {
-            return textResult2("No scheduled tasks configured.");
+            return textResult("No scheduled tasks configured.");
           }
           const lines = jobs.map(
             (j) => `- **${j.name}**: \`${j.cron}\` \u2192 ${j.notify.adapter}:${j.notify.channelId} [${j.enabled ? "enabled" : "disabled"}]${j.running ? " (running)" : ""}${j.lastRunAt ? ` (last: ${j.lastRunAt})` : ""}`
           );
-          return textResult2(
+          return textResult(
             `Scheduled tasks (${jobs.length}):
 ${lines.join("\n")}`
           );
         }
         case "add": {
           if (!params.name || !params.cron || !params.prompt) {
-            return textResult2(
+            return textResult(
               "Error: 'name', 'cron', and 'prompt' are required for adding a task."
             );
           }
           if (params.notifyAdapter && !params.notifyChannelId || !params.notifyAdapter && params.notifyChannelId) {
-            return textResult2(
+            return textResult(
               "Error: 'notifyAdapter' and 'notifyChannelId' must be provided together when overriding the notification target."
             );
           }
@@ -3375,11 +3536,12 @@ ${lines.join("\n")}`
             channelId: params.notifyChannelId
           } : getDefaultNotifyTarget(adapter, channelId);
           if (!notify) {
-            return textResult2(
+            return textResult(
               "Error: No default notification target is available for this chat. Provide 'notifyAdapter' and 'notifyChannelId'."
             );
           }
           const jobConfig = {
+            id: generateJobId(),
             name: params.name,
             cron: params.cron,
             prompt: params.prompt,
@@ -3388,46 +3550,62 @@ ${lines.join("\n")}`
             timezone: params.timezone
           };
           const result = scheduler.addJob(jobConfig);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         case "remove": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for removing a task."
             );
           }
-          const result = scheduler.removeJob(params.name);
-          return textResult2(result.message);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.removeJob(resolved.jobId);
+          return textResult(result.message);
         }
         case "trigger": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for triggering a task."
             );
           }
-          const result = await scheduler.triggerJob(params.name);
-          return textResult2(result.message);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = await scheduler.triggerJob(resolved.jobId);
+          return textResult(result.message);
         }
         case "enable": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for enabling a task."
             );
           }
-          const result = scheduler.setEnabled(params.name, true);
-          return textResult2(result.message);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.setEnabled(resolved.jobId, true);
+          return textResult(result.message);
         }
         case "disable": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for disabling a task."
             );
           }
-          const result = scheduler.setEnabled(params.name, false);
-          return textResult2(result.message);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.setEnabled(resolved.jobId, false);
+          return textResult(result.message);
         }
         default:
-          return textResult2(
+          return textResult(
             `Error: Unknown action '${params.action}'. Use: add, list, remove, trigger, enable, disable.`
           );
       }
@@ -3437,8 +3615,8 @@ ${lines.join("\n")}`
 
 // src/runtime/commands/help-command.ts
 init_commands();
-import fs12 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function buildHelpMessage(rootDir) {
   const sections = [];
   const commands = getVisibleCommands();
@@ -3448,7 +3626,7 @@ function buildHelpMessage(rootDir) {
   sections.push(`\u{1F4CB} **Available Commands**
 
 ${commandLines.join("\n")}`);
-  const configPath = path12.resolve(rootDir, "skillpack.json");
+  const configPath = path10.resolve(rootDir, "skillpack.json");
   const skills = readInstalledSkills(configPath);
   if (skills.length > 0) {
     const skillLines = skills.map(
@@ -3484,11 +3662,11 @@ function handleHelpCommand(rootDir) {
   };
 }
 function readInstalledSkills(configPath) {
-  if (!fs12.existsSync(configPath)) {
+  if (!fs9.existsSync(configPath)) {
     return [];
   }
   try {
-    const raw = fs12.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return Array.isArray(config.skills) ? config.skills : [];
   } catch {
@@ -3497,6 +3675,7 @@ function readInstalledSkills(configPath) {
 }
 
 // src/runtime/agent.ts
+init_types();
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
 var write = (data) => DEBUG && process.stdout.write(data);
@@ -3508,24 +3687,24 @@ var BUILTIN_SKILL_CREATOR_TEMPLATE_DIR = fileURLToPath(
 var PACK_AGENTS_FILE = "AGENTS.md";
 var PACK_SOUL_FILE = "SOUL.md";
 function materializeBuiltinSkillCreator(rootDir, skillsPath) {
-  if (!fs13.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs10.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path13.resolve(rootDir, "skillpack.json");
-  const skillDir = path13.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path13.join(skillDir, "SKILL.md");
+  const packConfigPath = path11.resolve(rootDir, "skillpack.json");
+  const skillDir = path11.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path11.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs13.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs13.readdirSync(srcDir, { withFileTypes: true })) {
+    fs10.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs10.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path13.join(srcDir, entry.name);
-      const destPath = path13.join(destDir, entry.name);
+      const srcPath = path11.join(srcDir, entry.name);
+      const destPath = path11.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -3534,17 +3713,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs13.readFileSync(srcPath, "utf-8");
-        fs13.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs10.readFileSync(srcPath, "utf-8");
+        fs10.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs13.copyFileSync(srcPath, destPath);
+      fs10.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs13.existsSync(skillDir)) {
+  if (!fs10.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs13.existsSync(skillPath)) {
+  if (!fs10.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -3572,11 +3751,11 @@ function overrideBuiltinSkillCreator(base, materializedSkill) {
   };
 }
 function readOptionalPackPromptFile(filePath) {
-  if (!fs13.existsSync(filePath)) {
+  if (!fs10.existsSync(filePath)) {
     return void 0;
   }
   try {
-    const content = fs13.readFileSync(filePath, "utf-8").trim();
+    const content = fs10.readFileSync(filePath, "utf-8").trim();
     return content.length > 0 ? content : void 0;
   } catch (error) {
     console.warn(`[PackAgent] Warning: Could not read ${filePath}:`, error);
@@ -3584,8 +3763,8 @@ function readOptionalPackPromptFile(filePath) {
   }
 }
 function buildPackPromptBlock(rootDir) {
-  const agentsPath = path13.resolve(rootDir, PACK_AGENTS_FILE);
-  const soulPath = path13.resolve(rootDir, PACK_SOUL_FILE);
+  const agentsPath = path11.resolve(rootDir, PACK_AGENTS_FILE);
+  const soulPath = path11.resolve(rootDir, PACK_SOUL_FILE);
   const agentsContent = readOptionalPackPromptFile(agentsPath);
   const soulContent = readOptionalPackPromptFile(soulPath);
   if (!agentsContent && !soulContent) {
@@ -3636,21 +3815,22 @@ function getAssistantDiagnostics(message) {
   return { stopReason, errorMessage, hasText: text.length > 0, toolCalls };
 }
 function getLifecycleTrigger(channelId) {
-  if (channelId.startsWith("telegram-")) return "telegram";
-  if (channelId.startsWith("slack-")) return "slack";
-  return "web";
+  const platform = detectPlatformFromChannelId(channelId);
+  return platform === "scheduler" ? "web" : platform;
 }
 var PackAgent = class {
   options;
   channels = /* @__PURE__ */ new Map();
   pendingSessionCreations = /* @__PURE__ */ new Map();
-  schedulerRef = { current: null };
+  schedulerRef = {
+    current: null
+  };
   authStorage;
-  artifactPersistenceService;
+  delegatedCustomToolClient = new DelegatedCustomToolClient();
+  hostIpcClient = new HostIpcClient();
   constructor(options) {
     this.options = options;
-    this.artifactPersistenceService = options.artifactPersistenceService;
-    const configPath = path13.resolve(options.rootDir, "data", "config.json");
+    const configPath = path11.resolve(options.rootDir, "data", "config.json");
     const backend = new ConfigFileAuthBackend(configPath);
     this.authStorage = AuthStorage.fromStorage(backend);
     const providerMeta = SUPPORTED_PROVIDERS[options.provider];
@@ -3677,13 +3857,20 @@ var PackAgent = class {
   setScheduler(scheduler) {
     this.schedulerRef.current = scheduler;
   }
-  createCustomTools(adapter, channelId, fileOutputCallbackRef, finalArtifactsSaveCallbackRef) {
+  async createCustomTools(adapter, channelId, fileOutputCallbackRef, delegatedToolRunContextRef) {
+    const delegatedDefinitions = await this.delegatedCustomToolClient.listDefinitions();
     const tools = [
       createSendFileTool(fileOutputCallbackRef),
-      createSaveArtifactsTool(this.options.rootDir, finalArtifactsSaveCallbackRef)
+      ...createDelegatedCustomTools(
+        delegatedDefinitions,
+        this.delegatedCustomToolClient,
+        delegatedToolRunContextRef
+      )
     ];
     if (adapter !== "scheduler") {
-      tools.push(createManageScheduleTool(this.schedulerRef, adapter, channelId));
+      tools.push(
+        createManageScheduleTool(this.schedulerRef, adapter, channelId)
+      );
     }
     return tools;
   }
@@ -3701,7 +3888,9 @@ var PackAgent = class {
       const modelRegistry = new ModelRegistry(authStorage);
       if (baseUrl && modelId) {
         const apiProtocol = this.options.apiProtocol ?? "openai-completions";
-        log(`[PackAgent] Registering custom model ${provider}/${modelId} api=${apiProtocol} baseUrl=${baseUrl}`);
+        log(
+          `[PackAgent] Registering custom model ${provider}/${modelId} api=${apiProtocol} baseUrl=${baseUrl}`
+        );
         modelRegistry.registerProvider(provider, {
           baseUrl,
           apiKey: this.options.apiKey,
@@ -3722,26 +3911,23 @@ var PackAgent = class {
       const resolvedModel = modelRegistry.find(provider, modelId);
       const model = resolvedModel && baseUrl && !this.options.apiProtocol ? { ...resolvedModel, baseUrl } : resolvedModel;
       if (resolvedModel && baseUrl) {
-        log(`[PackAgent] Resolved ${provider}/${modelId} api=${resolvedModel.api} baseUrl=${baseUrl}`);
+        log(
+          `[PackAgent] Resolved ${provider}/${modelId} api=${resolvedModel.api} baseUrl=${baseUrl}`
+        );
       }
-      const sessionDir = path13.resolve(
-        rootDir,
-        "data",
-        "sessions",
-        channelId
-      );
-      fs13.mkdirSync(sessionDir, { recursive: true });
+      const sessionDir = path11.resolve(rootDir, "data", "sessions", channelId);
+      fs10.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path13.resolve(
+      const workspaceDir = path11.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs13.mkdirSync(workspaceDir, { recursive: true });
+      fs10.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path13.resolve(rootDir, "skills");
+      const skillsPath = path11.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -3754,14 +3940,22 @@ var PackAgent = class {
       }
       const packPromptFiles = buildPackPromptBlock(rootDir);
       if (packPromptFiles.agentsContent) {
-        log(`[PackAgent] Loaded pack policy from: ${packPromptFiles.agentsPath}`);
+        log(
+          `[PackAgent] Loaded pack policy from: ${packPromptFiles.agentsPath}`
+        );
       } else {
-        log(`[PackAgent] No pack policy file found at: ${packPromptFiles.agentsPath}`);
+        log(
+          `[PackAgent] No pack policy file found at: ${packPromptFiles.agentsPath}`
+        );
       }
       if (packPromptFiles.soulContent) {
-        log(`[PackAgent] Loaded pack persona from: ${packPromptFiles.soulPath}`);
+        log(
+          `[PackAgent] Loaded pack persona from: ${packPromptFiles.soulPath}`
+        );
       } else {
-        log(`[PackAgent] No pack persona file found at: ${packPromptFiles.soulPath}`);
+        log(
+          `[PackAgent] No pack persona file found at: ${packPromptFiles.soulPath}`
+        );
       }
       log(
         `[PackAgent] Pack prompt injection: ${packPromptFiles.promptBlock ? "enabled" : "disabled"}`
@@ -3779,14 +3973,14 @@ var PackAgent = class {
       const fileOutputCallbackRef = {
         current: null
       };
-      const finalArtifactsSaveCallbackRef = {
+      const delegatedToolRunContextRef = {
         current: null
       };
-      const customTools = this.createCustomTools(
+      const customTools = await this.createCustomTools(
         adapter,
         channelId,
         fileOutputCallbackRef,
-        finalArtifactsSaveCallbackRef
+        delegatedToolRunContextRef
       );
       const { session } = await createAgentSession({
         cwd: workspaceDir,
@@ -3803,7 +3997,7 @@ var PackAgent = class {
         running: false,
         pending: Promise.resolve(),
         fileOutputCallbackRef,
-        finalArtifactsSaveCallbackRef
+        delegatedToolRunContextRef
       };
       this.channels.set(channelId, channelSession);
       return channelSession;
@@ -3820,18 +4014,16 @@ var PackAgent = class {
     const run = async () => {
       cs.running = true;
       let turnHadVisibleOutput = false;
-      const runId = randomUUID3();
+      const runId = randomUUID4();
       let unsubscribe = () => void 0;
       try {
         cs.fileOutputCallbackRef.current = (event) => {
           onEvent(event);
         };
-        cs.finalArtifactsSaveCallbackRef.current = (artifacts) => {
-          return this.artifactPersistenceService.saveArtifacts({
-            runId,
-            channelId,
-            artifacts
-          });
+        cs.delegatedToolRunContextRef.current = {
+          runId,
+          channelId,
+          adapter
         };
         unsubscribe = cs.session.subscribe((event) => {
           switch (event.type) {
@@ -3847,7 +4039,10 @@ var PackAgent = class {
               if (event.message?.role === "user") {
                 log(JSON.stringify(event.message.content, null, 2));
               }
-              onEvent({ type: "message_start", role: event.message?.role ?? "" });
+              onEvent({
+                type: "message_start",
+                role: event.message?.role ?? ""
+              });
               break;
             case "message_update":
               if (event.assistantMessageEvent?.type === "text_delta") {
@@ -3914,18 +4109,26 @@ var PackAgent = class {
         let promptText = text;
         const promptOptions = {};
         if (attachments && attachments.length > 0) {
-          const imageAttachments = attachments.filter((a) => isImageMime(a.mimeType));
-          const nonImageAttachments = attachments.filter((a) => !isImageMime(a.mimeType));
+          const imageAttachments = attachments.filter(
+            (a) => isImageMime(a.mimeType)
+          );
+          const nonImageAttachments = attachments.filter(
+            (a) => !isImageMime(a.mimeType)
+          );
           if (imageAttachments.length > 0) {
             promptOptions.images = attachmentsToImageContent(imageAttachments);
-            log(`[PackAgent] Passing ${imageAttachments.length} image(s) to LLM`);
+            log(
+              `[PackAgent] Passing ${imageAttachments.length} image(s) to LLM`
+            );
           }
           if (nonImageAttachments.length > 0) {
             const attachmentPrompt = formatAttachmentsPrompt(nonImageAttachments);
             promptText = `${attachmentPrompt}
 
 ${text}`;
-            log(`[PackAgent] Injecting ${nonImageAttachments.length} non-image attachment(s) into prompt`);
+            log(
+              `[PackAgent] Injecting ${nonImageAttachments.length} non-image attachment(s) into prompt`
+            );
           }
         }
         await cs.session.prompt(promptText, promptOptions);
@@ -3948,12 +4151,15 @@ ${text}`;
       } finally {
         cs.running = false;
         cs.fileOutputCallbackRef.current = null;
-        cs.finalArtifactsSaveCallbackRef.current = null;
+        cs.delegatedToolRunContextRef.current = null;
         unsubscribe();
       }
     };
     const resultPromise = cs.pending.catch(() => void 0).then(run);
-    cs.pending = resultPromise.then(() => void 0, () => void 0);
+    cs.pending = resultPromise.then(
+      () => void 0,
+      () => void 0
+    );
     return resultPromise;
   }
   async handleCommand(command, channelId) {
@@ -3968,11 +4174,12 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path13.resolve(rootDir, "data", "sessions", channelId);
-        if (fs13.existsSync(sessionDir)) {
-          fs13.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path11.resolve(rootDir, "data", "sessions", channelId);
+        if (fs10.existsSync(sessionDir)) {
+          fs10.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
+        await this.hostIpcClient.notifyChannelSessionCleared({ channelId });
         return {
           success: true,
           message: command === "new" ? "New session started." : "Session cleared."
@@ -4021,14 +4228,16 @@ ${text}`;
 };
 
 // src/runtime/adapters/web.ts
-import fs15 from "fs";
-import path15 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import fs12 from "fs";
+import path13 from "path";
 import { WebSocketServer } from "ws";
 init_commands();
 
 // src/runtime/services/conversation.ts
-import fs14 from "fs";
-import path14 from "path";
+init_types();
+import fs11 from "fs";
+import path12 from "path";
 import {
   parseSessionEntries
 } from "@mariozechner/pi-coding-agent";
@@ -4046,17 +4255,17 @@ var ConversationService = class {
       includeLegacyWeb = true,
       allowedPlatforms
     } = options;
-    const sessionsDir = path14.resolve(this.rootDir, "data", "sessions");
+    const sessionsDir = path12.resolve(this.rootDir, "data", "sessions");
     const channelIds = new Set(activeChannels);
     const allowedPlatformSet = allowedPlatforms ? new Set(allowedPlatforms) : null;
     if (includeDefaultWeb) {
       channelIds.add(DEFAULT_WEB_CHANNEL_ID);
     }
-    if (fs14.existsSync(sessionsDir)) {
-      for (const entry of fs14.readdirSync(sessionsDir)) {
-        const channelDir = path14.join(sessionsDir, entry);
+    if (fs11.existsSync(sessionsDir)) {
+      for (const entry of fs11.readdirSync(sessionsDir)) {
+        const channelDir = path12.join(sessionsDir, entry);
         try {
-          if (!fs14.statSync(channelDir).isDirectory()) {
+          if (!fs11.statSync(channelDir).isDirectory()) {
             continue;
           }
           const platform = this.detectPlatform(entry);
@@ -4080,7 +4289,7 @@ var ConversationService = class {
       if (!includeLegacyWeb && this.isLegacyWebConversation(channelId)) {
         continue;
       }
-      const channelDir = path14.join(sessionsDir, channelId);
+      const channelDir = path12.join(sessionsDir, channelId);
       const sessionFile = this.findLatestSessionFile(channelDir);
       let messageCount = 0;
       let lastMessageAt = "";
@@ -4124,7 +4333,7 @@ var ConversationService = class {
    * Load latest messages for a channel in a simplified format.
    */
   getMessages(channelId, limit = 100) {
-    const channelDir = path14.resolve(
+    const channelDir = path12.resolve(
       this.rootDir,
       "data",
       "sessions",
@@ -4213,20 +4422,20 @@ var ConversationService = class {
     return messages.slice(-safeLimit);
   }
   findLatestSessionFile(channelDir) {
-    if (!fs14.existsSync(channelDir)) return null;
+    if (!fs11.existsSync(channelDir)) return null;
     let stats;
     try {
-      stats = fs14.statSync(channelDir);
+      stats = fs11.statSync(channelDir);
     } catch {
       return null;
     }
     if (!stats.isDirectory()) return null;
-    const files = fs14.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
-    return files[0] ? path14.join(channelDir, files[0]) : null;
+    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path12.join(channelDir, files[0]) : null;
   }
   loadEntries(filePath) {
     try {
-      const content = fs14.readFileSync(filePath, "utf-8");
+      const content = fs11.readFileSync(filePath, "utf-8");
       const fileEntries = parseSessionEntries(content);
       return fileEntries.filter(
         (entry) => entry.type !== "session"
@@ -4410,10 +4619,7 @@ var ConversationService = class {
     return parts[parts.length - 1] || filePath;
   }
   detectPlatform(channelId) {
-    if (channelId.startsWith("telegram-")) return "telegram";
-    if (channelId.startsWith("slack-")) return "slack";
-    if (channelId.startsWith("scheduler-")) return "scheduler";
-    return "web";
+    return detectPlatformFromChannelId(channelId);
   }
   isLegacyWebConversation(channelId) {
     return channelId.startsWith("web-");
@@ -4422,7 +4628,7 @@ var ConversationService = class {
 
 // src/runtime/adapters/web.ts
 function getPackConfig(rootDir) {
-  const raw = fs15.readFileSync(path15.join(rootDir, "skillpack.json"), "utf-8");
+  const raw = fs12.readFileSync(path13.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
 function parseCommand(text) {
@@ -4441,7 +4647,9 @@ function getRuntimeConfigSignature(config) {
     apiProtocol: config.apiProtocol || "",
     telegramToken: config.adapters?.telegram?.token || "",
     slackBotToken: config.adapters?.slack?.botToken || "",
-    slackAppToken: config.adapters?.slack?.appToken || ""
+    slackAppToken: config.adapters?.slack?.appToken || "",
+    feishuAppId: config.adapters?.feishu?.appId || "",
+    feishuAppSecret: config.adapters?.feishu?.appSecret || ""
   });
 }
 function parsePositiveInt(value, fallback) {
@@ -4452,7 +4660,7 @@ function parsePositiveInt(value, fallback) {
   return Math.floor(parsed);
 }
 function resolveDownloadFilePath(rootDir, filePath) {
-  const resolvedPath = path15.isAbsolute(filePath) ? path15.resolve(filePath) : path15.resolve(rootDir, filePath);
+  const resolvedPath = path13.isAbsolute(filePath) ? path13.resolve(filePath) : path13.resolve(rootDir, filePath);
   return isWithinDirectory(rootDir, resolvedPath) ? resolvedPath : null;
 }
 var WebAdapter = class {
@@ -4467,7 +4675,6 @@ var WebAdapter = class {
     this.agent = agent;
     this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
     this.conversationService = new ConversationService(rootDir);
-    const resultsQueryService = ctx.resultsQueryService ?? null;
     const currentConf = configManager.getConfig();
     let apiKey = currentConf.apiKey || "";
     let currentProvider = currentConf.provider || "openai";
@@ -4611,17 +4818,6 @@ var WebAdapter = class {
         )
       );
     });
-    app.get("/api/results/artifacts", async (req, res) => {
-      if (!resultsQueryService) {
-        res.status(503).json({ error: "Results query service is not available" });
-        return;
-      }
-      res.json(await resultsQueryService.listRecentArtifacts({
-        channelId: typeof req.query.channelId === "string" ? req.query.channelId : void 0,
-        limit: parsePositiveInt(req.query.limit, 100),
-        offset: parsePositiveInt(req.query.offset, 0)
-      }));
-    });
     app.get("/api/files", (req, res) => {
       const filePath = req.query.path;
       if (!filePath) {
@@ -4633,17 +4829,17 @@ var WebAdapter = class {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs12.existsSync(resolvedPath)) {
         res.status(404).json({ error: "File not found" });
         return;
       }
-      const filename = path15.basename(resolvedPath);
+      const filename = path13.basename(resolvedPath);
       res.setHeader("Content-Type", "application/octet-stream");
       res.setHeader(
         "Content-Disposition",
         `attachment; filename="${filename}"`
       );
-      fs15.createReadStream(resolvedPath).pipe(res);
+      fs12.createReadStream(resolvedPath).pipe(res);
     });
     const getScheduler = () => {
       const schedulerAdapter = ctx.adapterMap?.get("scheduler");
@@ -4664,7 +4860,15 @@ var WebAdapter = class {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const { name, cron: cronExpr, prompt, notify, enabled, timezone } = req.body;
+      const {
+        id,
+        name,
+        cron: cronExpr,
+        prompt,
+        notify,
+        enabled,
+        timezone
+      } = req.body;
       if (!name || !prompt || !notify?.adapter || !notify?.channelId) {
         res.status(400).json({
           success: false,
@@ -4673,6 +4877,7 @@ var WebAdapter = class {
         return;
       }
       const result = scheduler.addJob({
+        id: typeof id === "string" && id.trim() ? id.trim() : randomUUID5(),
         name,
         ...typeof cronExpr === "string" ? { cron: cronExpr } : {},
         prompt,
@@ -4682,25 +4887,25 @@ var WebAdapter = class {
       });
       res.json(result);
     });
-    app.delete("/api/scheduler/jobs/:name", (req, res) => {
+    app.delete("/api/scheduler/jobs/:jobId", (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const result = scheduler.removeJob(req.params.name);
+      const result = scheduler.removeJob(req.params.jobId);
       res.json(result);
     });
-    app.post("/api/scheduler/jobs/:name/trigger", async (req, res) => {
+    app.post("/api/scheduler/jobs/:jobId/trigger", async (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const result = await scheduler.triggerJob(req.params.name);
+      const result = await scheduler.triggerJob(req.params.jobId);
       res.json(result);
     });
-    app.patch("/api/scheduler/jobs/:name", (req, res) => {
+    app.patch("/api/scheduler/jobs/:jobId", (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
@@ -4711,7 +4916,7 @@ var WebAdapter = class {
         res.status(400).json({ success: false, message: "Field 'enabled' (boolean) is required" });
         return;
       }
-      const result = scheduler.setEnabled(req.params.name, enabled);
+      const result = scheduler.setEnabled(req.params.jobId, enabled);
       res.json(result);
     });
     this.wss = new WebSocketServer({ noServer: true });
@@ -4828,13 +5033,28 @@ var WebAdapter = class {
 
 // src/runtime/adapters/ipc.ts
 init_types();
+var IPC_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  "get_conversations",
+  "create_conversation",
+  "get_messages",
+  "send_message",
+  "command",
+  "get_config",
+  "update_config",
+  "get_status",
+  "get_scheduled_jobs",
+  "add_scheduled_job",
+  "update_scheduled_job",
+  "set_scheduled_job_enabled",
+  "trigger_scheduled_job",
+  "remove_scheduled_job"
+]);
 var IpcAdapter = class {
   name = "ipc";
   agent = null;
   rootDir = "";
   adapterMap = null;
   conversationService = null;
-  resultsQueryService = null;
   createdChannels = /* @__PURE__ */ new Set();
   messageListener;
   started = false;
@@ -4846,7 +5066,6 @@ var IpcAdapter = class {
     this.rootDir = ctx.rootDir;
     this.adapterMap = ctx.adapterMap ?? null;
     this.conversationService = new ConversationService(ctx.rootDir);
-    this.resultsQueryService = ctx.resultsQueryService ?? null;
     this.messageListener = (message) => {
       if (!this.isIpcRequest(message)) return;
       void this.handleRequest(message);
@@ -4891,7 +5110,7 @@ var IpcAdapter = class {
   isIpcRequest(message) {
     if (!message || typeof message !== "object") return false;
     const maybe = message;
-    return typeof maybe.id === "string" && typeof maybe.type === "string";
+    return typeof maybe.id === "string" && typeof maybe.type === "string" && IPC_REQUEST_TYPES.has(maybe.type);
   }
   async handleRequest(request) {
     if (!this.agent || !this.conversationService) {
@@ -4930,18 +5149,6 @@ var IpcAdapter = class {
           this.reply(request.id, messages);
           return;
         }
-        case "get_recent_artifacts": {
-          if (!this.resultsQueryService) {
-            this.replyError(request.id, "Results query service is not available");
-            return;
-          }
-          this.reply(request.id, await this.resultsQueryService.listRecentArtifacts({
-            channelId: request.channelId,
-            limit: request.limit,
-            offset: request.offset
-          }));
-          return;
-        }
         case "send_message": {
           if (!request.channelId || typeof request.channelId !== "string") {
             this.replyError(request.id, "channelId is required");
@@ -5030,7 +5237,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.updateJob(request.name, request.updates);
+          const result = scheduler.updateJob(request.jobId, request.updates);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -5044,7 +5251,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.setEnabled(request.name, request.enabled);
+          const result = scheduler.setEnabled(request.jobId, request.enabled);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -5058,7 +5265,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = await scheduler.triggerJob(request.name);
+          const result = await scheduler.triggerJob(request.jobId);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -5072,7 +5279,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.removeJob(request.name);
+          const result = scheduler.removeJob(request.jobId);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -5094,10 +5301,7 @@ var IpcAdapter = class {
     return adapter;
   }
   detectPlatform(channelId) {
-    if (channelId.startsWith("telegram-")) return "telegram";
-    if (channelId.startsWith("slack-")) return "slack";
-    if (channelId.startsWith("scheduler-")) return "scheduler";
-    return "web";
+    return detectPlatformFromChannelId(channelId);
   }
   sendIpc(payload) {
     if (typeof process.send === "function") {
@@ -5185,28 +5389,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs16 from "fs";
+import fs13 from "fs";
 import os from "os";
-import path16 from "path";
-var SKILLPACK_HOME = path16.join(os.homedir(), ".skillpack");
-var LEGACY_REGISTRY_FILE = path16.join(SKILLPACK_HOME, "registry.json");
-var REGISTRY_DIR = path16.join(SKILLPACK_HOME, "registry.d");
+import path14 from "path";
+var SKILLPACK_HOME = path14.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path14.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path14.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs16.existsSync(SKILLPACK_HOME)) {
-    fs16.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs13.existsSync(SKILLPACK_HOME)) {
+    fs13.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs16.existsSync(REGISTRY_DIR)) {
-    fs16.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs13.existsSync(REGISTRY_DIR)) {
+    fs13.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path16.resolve(dir);
+  const resolved = path14.resolve(dir);
   try {
-    return fs16.realpathSync(resolved);
+    return fs13.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -5215,7 +5419,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path16.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path14.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -5223,11 +5427,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs16.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path16.join(REGISTRY_DIR, file));
+  return fs13.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path14.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs16.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
       return null;
@@ -5260,8 +5464,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs16.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs16.renameSync(tmpPath, entryPath);
+  fs13.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs13.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -5269,14 +5473,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs16.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs13.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs16.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs13.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -5289,7 +5493,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs16.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs13.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -5342,7 +5546,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path18.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path17.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -5358,8 +5562,8 @@ async function startServer(options) {
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = dataConfig.modelId?.trim() || (SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId);
   const apiProtocol = dataConfig.apiProtocol;
-  const packageRoot = path18.resolve(__dirname, "..");
-  const webDir = fs19.existsSync(path18.join(rootDir, "web")) ? path18.join(rootDir, "web") : path18.join(packageRoot, "web");
+  const packageRoot = path17.resolve(__dirname, "..");
+  const webDir = fs17.existsSync(path17.join(rootDir, "web")) ? path17.join(rootDir, "web") : path17.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -5377,13 +5581,6 @@ async function startServer(options) {
     });
   });
   const lifecycle = new Lifecycle(server);
-  const resultStore = new ResultStore(rootDir);
-  const artifactSnapshotService = new ArtifactSnapshotService(rootDir);
-  const artifactPersistenceService = new ArtifactPersistenceService(
-    artifactSnapshotService,
-    resultStore
-  );
-  const resultsQueryService = new ResultsQueryService(resultStore);
   const agent = new PackAgent({
     apiKey,
     rootDir,
@@ -5391,14 +5588,16 @@ async function startServer(options) {
     modelId,
     baseUrl,
     apiProtocol,
-    lifecycleHandler: lifecycle,
-    artifactPersistenceService
+    lifecycleHandler: lifecycle
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
   const hasIpcChannel = typeof process.send === "function";
   const ipcAdapter = new IpcAdapter();
   const webEnabled = runtimeMode === "standalone";
+  console.log(
+    `[Runtime] IPC channel ${hasIpcChannel ? "available" : "not available"} (mode=${runtimeMode})`
+  );
   if (hasIpcChannel) {
     await ipcAdapter.start({
       agent,
@@ -5406,8 +5605,7 @@ async function startServer(options) {
       app,
       rootDir,
       lifecycle,
-      adapterMap,
-      resultsQueryService
+      adapterMap
     });
     adapters.push(ipcAdapter);
     adapterMap.set(ipcAdapter.name, ipcAdapter);
@@ -5422,8 +5620,7 @@ async function startServer(options) {
       rootDir,
       lifecycle,
       adapterMap,
-      ipcBroadcaster,
-      resultsQueryService
+      ipcBroadcaster
     });
     adapters.push(webAdapter);
     adapterMap.set(webAdapter.name, webAdapter);
@@ -5441,8 +5638,7 @@ async function startServer(options) {
         rootDir,
         lifecycle,
         adapterMap,
-        ipcBroadcaster,
-        resultsQueryService
+        ipcBroadcaster
       });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
@@ -5470,8 +5666,7 @@ async function startServer(options) {
           rootDir,
           lifecycle,
           adapterMap,
-          ipcBroadcaster,
-          resultsQueryService
+          ipcBroadcaster
         });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
@@ -5480,6 +5675,35 @@ async function startServer(options) {
       }
     }
   }
+  const feishuConfig = dataConfig.adapters?.feishu;
+  if (feishuConfig?.appId || feishuConfig?.appSecret) {
+    if (!feishuConfig.appId || !feishuConfig.appSecret) {
+      console.warn(
+        "[Feishu] Skipped: both adapters.feishu.appId and adapters.feishu.appSecret are required."
+      );
+    } else {
+      try {
+        const { FeishuAdapter: FeishuAdapter2 } = await Promise.resolve().then(() => (init_feishu(), feishu_exports));
+        const feishuAdapter = new FeishuAdapter2({
+          appId: feishuConfig.appId,
+          appSecret: feishuConfig.appSecret
+        });
+        await feishuAdapter.start({
+          agent,
+          server,
+          app,
+          rootDir,
+          lifecycle,
+          adapterMap,
+          ipcBroadcaster
+        });
+        adapters.push(feishuAdapter);
+        adapterMap.set(feishuAdapter.name, feishuAdapter);
+      } catch (err) {
+        console.error("[Feishu] Failed to start:", err);
+      }
+    }
+  }
   const { isMessageSender: isMessageSender2 } = await Promise.resolve().then(() => (init_types(), types_exports));
   const notifyFn = async (adapterName, channelId, text) => {
     const adapter = adapterMap.get(adapterName);
@@ -5503,7 +5727,7 @@ async function startServer(options) {
       lifecycle,
       notify: notifyFn,
       adapterMap,
-      resultsQueryService
+      ipcBroadcaster
     });
     adapters.push(schedulerAdapter);
     adapterMap.set(schedulerAdapter.name, schedulerAdapter);
@@ -5591,23 +5815,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path19.resolve(
+  const templateDir = path18.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path19.join(templateDir, file);
-    const dest = path19.join(workDir, file);
-    if (fs20.existsSync(src)) {
-      fs20.copyFileSync(src, dest);
+    const src = path18.join(templateDir, file);
+    const dest = path18.join(workDir, file);
+    if (fs18.existsSync(src)) {
+      fs18.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs20.chmodSync(dest, 493);
+        fs18.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path19.resolve(directory) : process.cwd();
-  fs20.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path18.resolve(directory) : process.cwd();
+  fs18.mkdirSync(workDir, { recursive: true });
   if (!configExists(workDir)) {
     console.log(chalk4.blue("\n  No skillpack.json found. Let's set one up.\n"));
     const { name, description } = await inquirer2.prompt([
@@ -5651,14 +5875,14 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs21 from "fs";
-import path20 from "path";
+import fs19 from "fs";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var packageJson = JSON.parse(
-  fs21.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs19.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
-var cliFilePath = path20.resolve(fileURLToPath3(import.meta.url));
+var cliFilePath = path19.resolve(fileURLToPath3(import.meta.url));
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);
 program.command("create [directory]").description("Create a skills pack interactively").option("--config <path-or-url>", "Initialize from a local or remote skillpack.json").action(async (directory, options) => {
   await createCommand(directory, options);
@@ -5679,7 +5903,7 @@ program.command("zip").description("Package the current pack as a zip file (skil
 function normalizeUserArgs(argv) {
   if (argv.length === 0) return argv;
   const firstArg = argv[0];
-  if (firstArg && path20.resolve(firstArg) === cliFilePath) {
+  if (firstArg && path19.resolve(firstArg) === cliFilePath) {
     return argv.slice(1);
   }
   return argv;