@cremini/skillpack 1.2.3 → 1.2.5-beta.1

package/dist/cli.js

@@ -267,6 +267,76 @@ var init_attachment_utils = __esm({
   }
 });
 
+// src/runtime/commands/index.ts
+function resolveCommand(input) {
+  const key = input.split(/\s/)[0].toLowerCase();
+  return COMMAND_ALIASES[key] ?? null;
+}
+function getVisibleCommands() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.visibleInHelp);
+}
+function getTelegramBotCommands() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.visibleInHelp).map((cmd) => ({
+    command: cmd.command,
+    description: cmd.description
+  }));
+}
+var COMMAND_REGISTRY, COMMAND_ALIASES;
+var init_commands = __esm({
+  "src/runtime/commands/index.ts"() {
+    "use strict";
+    COMMAND_REGISTRY = [
+      {
+        command: "help",
+        description: "Show available commands, skills, and usage tips",
+        visibleInHelp: true
+      },
+      {
+        command: "clear",
+        description: "Clear current session and start fresh",
+        visibleInHelp: true
+      },
+      {
+        command: "restart",
+        description: "Restart the server process",
+        visibleInHelp: true
+      },
+      {
+        command: "shutdown",
+        description: "Shut down the server process",
+        visibleInHelp: true
+      },
+      // "new" is a hidden alias for "clear" — not shown in /help
+      {
+        command: "new",
+        description: "Start a new session (alias for /clear)",
+        visibleInHelp: false
+      }
+    ];
+    COMMAND_ALIASES = {
+      "/help": "help",
+      "/clear": "clear",
+      "/new": "clear",
+      "/restart": "restart",
+      "/shutdown": "shutdown"
+    };
+  }
+});
+
+// src/runtime/adapters/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isMessageSender: () => isMessageSender
+});
+function isMessageSender(adapter) {
+  return typeof adapter.sendMessage === "function";
+}
+var init_types = __esm({
+  "src/runtime/adapters/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -307,6 +377,7 @@ function formatSlackInline(text) {
   );
   formatted = formatted.replace(/\*\*([^*\n]+)\*\*/g, "*$1*");
   formatted = formatted.replace(/__([^_\n]+)__/g, "*$1*");
+  formatted = formatted.replace(/^(?:-|\*) /gm, "\u2022 ");
   return formatted;
 }
 function formatTelegramInline(text) {
@@ -386,19 +457,15 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs11 from "fs";
+import fs13 from "fs";
 import TelegramBot from "node-telegram-bot-api";
-var COMMANDS2, MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
+var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
   "src/runtime/adapters/telegram.ts"() {
     "use strict";
     init_markdown();
     init_attachment_utils();
-    COMMANDS2 = {
-      "/clear": "clear",
-      "/restart": "restart",
-      "/shutdown": "shutdown"
-    };
+    init_commands();
     MAX_MESSAGE_LENGTH = 4096;
     ACK_REACTION = {
       type: "emoji",
@@ -410,23 +477,21 @@ var init_telegram = __esm({
       agent = null;
       options;
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.bot = new TelegramBot(this.options.token, { polling: true });
         this.bot.on("message", (msg) => {
           this.handleTelegramMessage(msg).catch((err) => {
             console.error("[Telegram] Error handling message:", err);
           });
         });
-        await this.bot.setMyCommands([
-          { command: "clear", description: "Clear current session and start new" },
-          { command: "restart", description: "Restart the server process" },
-          { command: "shutdown", description: "Shut down the server process" }
-        ]);
+        await this.bot.setMyCommands(getTelegramBotCommands());
         const me = await this.bot.getMe();
         console.log(`[TelegramAdapter] Started as @${me.username}`);
       }
@@ -461,12 +526,21 @@ var init_telegram = __esm({
         const messageId = msg.message_id;
         const text = (msg.text || msg.caption || "").trim();
         const channelId = `telegram-${chatId}`;
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "telegram",
+          {
+            id: String(msg.from?.id || ""),
+            username: msg.from?.username || msg.from?.first_name || ""
+          },
+          text
+        );
         const attachments = await this.extractAttachments(msg, channelId);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(chatId, messageId);
         if (text) {
           const commandKey = text.split(/\s/)[0].toLowerCase();
-          const command = COMMANDS2[commandKey];
+          const command = this.resolveTelegramCommand(commandKey);
           if (command) {
             const result = await this.agent.handleCommand(command, channelId);
             await this.sendSafe(chatId, result.message || `/${command} executed.`);
@@ -490,6 +564,7 @@ var init_telegram = __esm({
               });
               break;
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const userText = text || "(User sent an attachment)";
@@ -521,6 +596,9 @@ var init_telegram = __esm({
           await this.sendFileSafe(chatId, file.filePath, file.caption);
         }
       }
+      resolveTelegramCommand(commandKey) {
+        return resolveCommand(commandKey);
+      }
       // -------------------------------------------------------------------------
       // Send helpers
       // -------------------------------------------------------------------------
@@ -697,7 +775,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs11.existsSync(filePath)) {
+          if (!fs13.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -717,16 +795,18 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs12 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import { App, LogLevel } from "@slack/bolt";
-var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, SlackAdapter;
+var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
   "src/runtime/adapters/slack.ts"() {
     "use strict";
     init_markdown();
     init_attachment_utils();
+    init_commands();
     INLINE_COMMANDS = {
+      "/help": "help",
       "/clear": "clear",
       "/restart": "restart",
       "/shutdown": "shutdown"
@@ -738,6 +818,7 @@ var init_slack = __esm({
     };
     MAX_MESSAGE_LENGTH2 = 3500;
     ACK_REACTION2 = "eyes";
+    PROCESSING_MESSAGE = "_Processing..._";
     SlackAdapter = class {
       name = "slack";
       app = null;
@@ -746,12 +827,14 @@ var init_slack = __esm({
       botUserId = null;
       lastThreadByChannel = /* @__PURE__ */ new Map();
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.app = new App({
           token: this.options.botToken,
           appToken: this.options.appToken,
@@ -807,7 +890,7 @@ var init_slack = __esm({
             console.error("[Slack] Error handling mention:", err);
           }
         });
-        for (const commandName of Object.keys(SLASH_COMMANDS)) {
+        for (const commandName of [...Object.keys(SLASH_COMMANDS), "/new"]) {
           app.command(commandName, async (args) => {
             try {
               await this.handleSlashCommand(args);
@@ -837,6 +920,15 @@ var init_slack = __esm({
         const teamId = this.getTeamId(body, context);
         const channelId = `slack-dm-${teamId}-${event.channel}`;
         const route = { channel: event.channel };
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(client, event);
@@ -867,12 +959,21 @@ var init_slack = __esm({
           threadTs
         );
         const text = this.stripBotMention(event.text || "").trim();
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) {
           await this.sendSafe(
             client,
             route,
-            "Mention me with a message, or use `/clear` to reset this thread."
+            "Mention me with a message, or use `/clear` or `/new` to reset this thread."
           );
           return;
         }
@@ -890,7 +991,7 @@ var init_slack = __esm({
         ack
       }) {
         const commandName = command?.command;
-        const mapped = commandName ? SLASH_COMMANDS[commandName] : void 0;
+        const mapped = commandName ? this.resolveSlashCommand(commandName) : void 0;
         if (!this.agent || !mapped) {
           await this.safeAck(ack, "Unsupported slash command.");
           return;
@@ -916,6 +1017,7 @@ var init_slack = __esm({
         let hasError = false;
         let errorMessage = "";
         const pendingFiles = [];
+        const placeholder = await this.sendPlaceholderMessage(client, route);
         const onEvent = (event) => {
           if (event.type === "text_delta") {
             finalText += event.delta;
@@ -925,6 +1027,7 @@ var init_slack = __esm({
               caption: event.caption
             });
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const result = await this.agent.handleMessage(
@@ -943,13 +1046,25 @@ var init_slack = __esm({
           errorMessage = this.getErrorMessage(err);
         }
         if (hasError) {
-          await this.sendSafe(client, route, `\u274C Error: ${errorMessage}`);
+          await this.sendOrUpdateSafe(
+            client,
+            route,
+            `\u274C Error: ${errorMessage}`,
+            placeholder
+          );
           return;
         }
         if (finalText.trim()) {
-          await this.sendLongMessage(client, route, finalText);
+          await this.sendLongMessage(client, route, finalText, placeholder);
         } else if (pendingFiles.length === 0) {
-          await this.sendSafe(client, route, "(No response generated)");
+          await this.sendOrUpdateSafe(
+            client,
+            route,
+            "(No response generated)",
+            placeholder
+          );
+        } else if (placeholder) {
+          await this.deleteMessageSafe(client, route, placeholder.ts);
         }
         for (const file of pendingFiles) {
           await this.sendFileSafe(client, route, file.filePath, file.caption);
@@ -961,7 +1076,7 @@ var init_slack = __esm({
       async tryHandleInlineCommand(text, channelId, client, route) {
         if (!this.agent) return false;
         const commandKey = text.split(/\s/)[0].toLowerCase();
-        const command = INLINE_COMMANDS[commandKey];
+        const command = this.resolveInlineCommand(commandKey);
         if (!command) return false;
         const result = await this.agent.handleCommand(command, channelId);
         await this.sendSafe(
@@ -971,6 +1086,19 @@ var init_slack = __esm({
         );
         return true;
       }
+      resolveInlineCommand(commandKey) {
+        const resolved = resolveCommand(commandKey);
+        if (resolved) {
+          return resolved;
+        }
+        return INLINE_COMMANDS[commandKey];
+      }
+      resolveSlashCommand(commandName) {
+        if (commandName === "/new") {
+          return "clear";
+        }
+        return SLASH_COMMANDS[commandName];
+      }
       resolveSlashCommandTarget(payload, context) {
         const teamId = this.getTeamId(payload, context);
         const channel = payload?.channel_id;
@@ -988,7 +1116,7 @@ var init_slack = __esm({
         );
         if (!threadTs) {
           return {
-            message: "No active Skillpack thread found in this channel. Mention the bot first, or run the command inside the thread as `@bot /clear`."
+            message: "No active Skillpack thread found in this channel. Mention the bot first, or run the command inside the thread as `@bot /clear` or `@bot /new`."
           };
         }
         return {
@@ -1017,33 +1145,35 @@ var init_slack = __esm({
         return text.replace(mention, "");
       }
       splitMessage(text) {
-        if (text.length <= MAX_MESSAGE_LENGTH2) {
+        if (this.isSlackMessageWithinLimit(text)) {
           return [text];
         }
         const chunks = [];
         let remaining = text;
         while (remaining.length > 0) {
-          if (remaining.length <= MAX_MESSAGE_LENGTH2) {
+          if (this.isSlackMessageWithinLimit(remaining)) {
             chunks.push(remaining);
             break;
           }
-          let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH2);
-          if (splitAt < MAX_MESSAGE_LENGTH2 * 0.5) {
-            splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH2);
-          }
-          if (splitAt < MAX_MESSAGE_LENGTH2 * 0.3) {
-            splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH2);
-          }
-          if (splitAt < 1) {
-            splitAt = MAX_MESSAGE_LENGTH2;
-          }
+          let splitAt = this.findSlackSafeSplitPoint(remaining);
           chunks.push(remaining.slice(0, splitAt));
           remaining = remaining.slice(splitAt).trimStart();
         }
         return chunks;
       }
-      async sendLongMessage(client, route, text) {
-        for (const chunk of this.splitMessage(text)) {
+      async sendLongMessage(client, route, text, placeholder) {
+        const chunks = this.splitMessage(text);
+        if (chunks.length === 0) {
+          return;
+        }
+        if (placeholder) {
+          await this.updateMessageSafe(client, route, placeholder.ts, chunks[0]);
+          for (const chunk of chunks.slice(1)) {
+            await this.sendSafe(client, route, chunk);
+          }
+          return;
+        }
+        for (const chunk of chunks) {
           await this.sendWithRetry(client, route, chunk);
         }
       }
@@ -1054,17 +1184,35 @@ var init_slack = __esm({
           console.error("[Slack] Failed to send message:", err);
         }
       }
+      async sendOrUpdateSafe(client, route, text, placeholder) {
+        if (placeholder) {
+          await this.updateMessageSafe(client, route, placeholder.ts, text);
+          return;
+        }
+        await this.sendSafe(client, route, text);
+      }
+      async sendPlaceholderMessage(client, route) {
+        try {
+          return await this.sendWithRetry(client, route, PROCESSING_MESSAGE);
+        } catch (err) {
+          console.error("[Slack] Failed to send placeholder message:", err);
+          return null;
+        }
+      }
       async sendWithRetry(client, route, text, maxRetries = 3) {
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
           try {
-            await client.chat.postMessage({
+            const response = await client.chat.postMessage({
               channel: route.channel,
               text: formatSlackMessage(text),
               mrkdwn: true,
               thread_ts: route.threadTs,
               reply_broadcast: false
             });
-            return;
+            if (typeof response.ts !== "string") {
+              throw new Error("Slack postMessage response missing ts");
+            }
+            return { ts: response.ts };
           } catch (err) {
             const retryAfter = this.getRetryAfterSeconds(err);
             if (retryAfter && attempt < maxRetries) {
@@ -1079,6 +1227,93 @@ var init_slack = __esm({
             throw err;
           }
         }
+        throw new Error("Slack postMessage failed after retries");
+      }
+      async updateMessageSafe(client, route, ts, text) {
+        try {
+          await this.updateWithRetry(client, route, ts, text);
+        } catch (err) {
+          console.error("[Slack] Failed to update message:", err);
+          await this.deleteMessageSafe(client, route, ts);
+          await this.sendSafe(client, route, text);
+        }
+      }
+      async updateWithRetry(client, route, ts, text, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            await client.chat.update({
+              channel: route.channel,
+              ts,
+              text: formatSlackMessage(text),
+              mrkdwn: true
+            });
+            return;
+          } catch (err) {
+            const retryAfter = this.getRetryAfterSeconds(err);
+            if (retryAfter && attempt < maxRetries) {
+              console.log(
+                `[Slack] Rate limited while updating, retrying after ${retryAfter}s...`
+              );
+              await new Promise(
+                (resolve) => setTimeout(resolve, retryAfter * 1e3)
+              );
+              continue;
+            }
+            throw err;
+          }
+        }
+      }
+      async deleteMessageSafe(client, route, ts) {
+        try {
+          await client.chat.delete({
+            channel: route.channel,
+            ts
+          });
+        } catch (err) {
+          console.error("[Slack] Failed to delete placeholder message:", err);
+        }
+      }
+      isSlackMessageWithinLimit(text) {
+        return formatSlackMessage(text).length <= MAX_MESSAGE_LENGTH2;
+      }
+      findSlackSafeSplitPoint(text) {
+        const preferredBreaks = ["\n\n", "\n", " "];
+        const minSplit = Math.floor(MAX_MESSAGE_LENGTH2 * 0.3);
+        for (const token of preferredBreaks) {
+          const index = this.findBestSlackSplitBefore(text, token);
+          if (index >= minSplit) {
+            return index;
+          }
+        }
+        let low = 1;
+        let high = text.length;
+        let best = Math.min(text.length, MAX_MESSAGE_LENGTH2);
+        while (low <= high) {
+          const mid = Math.floor((low + high) / 2);
+          const candidate = text.slice(0, mid);
+          if (this.isSlackMessageWithinLimit(candidate)) {
+            best = mid;
+            low = mid + 1;
+          } else {
+            high = mid - 1;
+          }
+        }
+        return Math.max(1, best);
+      }
+      findBestSlackSplitBefore(text, token) {
+        let fromIndex = Math.min(text.length, MAX_MESSAGE_LENGTH2);
+        while (fromIndex > 0) {
+          const index = text.lastIndexOf(token, fromIndex);
+          if (index < 0) {
+            return -1;
+          }
+          const splitAt = index + token.length;
+          if (this.isSlackMessageWithinLimit(text.slice(0, splitAt))) {
+            return splitAt;
+          }
+          fromIndex = index - 1;
+        }
+        return -1;
       }
       async tryAckReaction(client, event) {
         try {
@@ -1196,12 +1431,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs12.existsSync(filePath)) {
+          if (!fs14.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path11.basename(filePath);
-          const fileContent = fs12.readFileSync(filePath);
+          const filename = path13.basename(filePath);
+          const fileContent = fs14.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1218,20 +1453,6 @@ var init_slack = __esm({
   }
 });
 
-// src/runtime/adapters/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isMessageSender: () => isMessageSender
-});
-function isMessageSender(adapter) {
-  return typeof adapter.sendMessage === "function";
-}
-var init_types = __esm({
-  "src/runtime/adapters/types.ts"() {
-    "use strict";
-  }
-});
-
 // src/runtime/adapters/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -2242,15 +2463,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path13 from "path";
-import fs14 from "fs";
+import path15 from "path";
+import fs16 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path12 from "path";
-import fs13 from "fs";
+import path14 from "path";
+import fs15 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -2258,8 +2479,8 @@ import { exec } from "child_process";
 // src/runtime/agent.ts
 init_config();
 init_attachment_utils();
-import path8 from "path";
-import fs8 from "fs";
+import path9 from "path";
+import fs9 from "fs";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -5115,6 +5336,67 @@ ${lines.join("\n")}`
   };
 }
 
+// src/runtime/commands/help-command.ts
+init_commands();
+import fs8 from "fs";
+import path8 from "path";
+function buildHelpMessage(rootDir) {
+  const sections = [];
+  const commands = getVisibleCommands();
+  const commandLines = commands.map(
+    (cmd) => `- \`/${cmd.command}\` \u2014 ${cmd.description}`
+  );
+  sections.push(`\u{1F4CB} **Available Commands**
+
+${commandLines.join("\n")}`);
+  const configPath = path8.resolve(rootDir, "skillpack.json");
+  const skills = readInstalledSkills(configPath);
+  if (skills.length > 0) {
+    const skillLines = skills.map(
+      (skill) => `- **${skill.name}**${skill.description ? ` \u2014 ${skill.description}` : ""}`
+    );
+    sections.push(
+      `\u{1F9E9} **Installed Skills** (${skills.length})
+
+${skillLines.join("\n")}`
+    );
+  } else {
+    sections.push("\u{1F9E9} **Installed Skills**\nNo skills installed.");
+  }
+  sections.push(
+    [
+      "\u23F0 **Scheduled Tasks**",
+      "",
+      "You can set up recurring tasks using natural language. For example:",
+      "",
+      '- "Send me a daily market briefing every morning at 9 AM"',
+      `- "Summarize this week's trading data every Friday at 6 PM"`,
+      '- "Check for new announcements every 30 minutes"',
+      "",
+      "I will handle the cron scheduling automatically."
+    ].join("\n")
+  );
+  return sections.join("\n\n");
+}
+function handleHelpCommand(rootDir) {
+  return {
+    success: true,
+    message: buildHelpMessage(rootDir)
+  };
+}
+function readInstalledSkills(configPath) {
+  if (!fs8.existsSync(configPath)) {
+    return [];
+  }
+  try {
+    const raw = fs8.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return Array.isArray(config.skills) ? config.skills : [];
+  } catch {
+    return [];
+  }
+}
+
 // src/runtime/agent.ts
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
@@ -5127,24 +5409,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 (!fs8.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs9.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path8.resolve(rootDir, "skillpack.json");
-  const skillDir = path8.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path8.join(skillDir, "SKILL.md");
+  const packConfigPath = path9.resolve(rootDir, "skillpack.json");
+  const skillDir = path9.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path9.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs8.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
+    fs9.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs9.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path8.join(srcDir, entry.name);
-      const destPath = path8.join(destDir, entry.name);
+      const srcPath = path9.join(srcDir, entry.name);
+      const destPath = path9.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -5153,17 +5435,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs8.readFileSync(srcPath, "utf-8");
-        fs8.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs9.readFileSync(srcPath, "utf-8");
+        fs9.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs8.copyFileSync(srcPath, destPath);
+      fs9.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs8.existsSync(skillDir)) {
+  if (!fs9.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs8.existsSync(skillPath)) {
+  if (!fs9.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -5191,11 +5473,11 @@ function overrideBuiltinSkillCreator(base, materializedSkill) {
   };
 }
 function readOptionalPackPromptFile(filePath) {
-  if (!fs8.existsSync(filePath)) {
+  if (!fs9.existsSync(filePath)) {
     return void 0;
   }
   try {
-    const content = fs8.readFileSync(filePath, "utf-8").trim();
+    const content = fs9.readFileSync(filePath, "utf-8").trim();
     return content.length > 0 ? content : void 0;
   } catch (error) {
     console.warn(`[PackAgent] Warning: Could not read ${filePath}:`, error);
@@ -5203,8 +5485,8 @@ function readOptionalPackPromptFile(filePath) {
   }
 }
 function buildPackPromptBlock(rootDir) {
-  const agentsPath = path8.resolve(rootDir, PACK_AGENTS_FILE);
-  const soulPath = path8.resolve(rootDir, PACK_SOUL_FILE);
+  const agentsPath = path9.resolve(rootDir, PACK_AGENTS_FILE);
+  const soulPath = path9.resolve(rootDir, PACK_SOUL_FILE);
   const agentsContent = readOptionalPackPromptFile(agentsPath);
   const soulContent = readOptionalPackPromptFile(soulPath);
   if (!agentsContent && !soulContent) {
@@ -5270,7 +5552,7 @@ var PackAgent = class {
   authStorage;
   constructor(options) {
     this.options = options;
-    const configPath = path8.resolve(options.rootDir, "data", "config.json");
+    const configPath = path9.resolve(options.rootDir, "data", "config.json");
     const backend = new ConfigFileAuthBackend(configPath);
     this.authStorage = AuthStorage.fromStorage(backend);
     const providerMeta = SUPPORTED_PROVIDERS[options.provider];
@@ -5321,24 +5603,24 @@ var PackAgent = class {
       if (resolvedModel && baseUrl) {
         log(`[PackAgent] Overriding ${provider}/${modelId} baseUrl -> ${baseUrl}`);
       }
-      const sessionDir = path8.resolve(
+      const sessionDir = path9.resolve(
         rootDir,
         "data",
         "sessions",
         channelId
       );
-      fs8.mkdirSync(sessionDir, { recursive: true });
+      fs9.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path8.resolve(
+      const workspaceDir = path9.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs8.mkdirSync(workspaceDir, { recursive: true });
+      fs9.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path8.resolve(rootDir, "skills");
+      const skillsPath = path9.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -5529,6 +5811,8 @@ ${text}`;
   }
   async handleCommand(command, channelId) {
     switch (command) {
+      case "help":
+        return handleHelpCommand(this.options.rootDir);
       case "new":
       case "clear": {
         const cs = this.channels.get(channelId);
@@ -5537,9 +5821,9 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path8.resolve(rootDir, "data", "sessions", channelId);
-        if (fs8.existsSync(sessionDir)) {
-          fs8.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path9.resolve(rootDir, "data", "sessions", channelId);
+        if (fs9.existsSync(sessionDir)) {
+          fs9.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
         return {
@@ -5584,26 +5868,27 @@ ${text}`;
   /** Reserved: restore a historical session */
   async restoreSession(_sessionId) {
   }
+  getActiveChannelIds() {
+    return Array.from(this.channels.keys());
+  }
 };
 
 // src/runtime/adapters/web.ts
 init_config();
-import fs9 from "fs";
-import path9 from "path";
+init_commands();
+import fs10 from "fs";
+import path10 from "path";
 import { WebSocketServer } from "ws";
 function getPackConfig(rootDir) {
-  const raw = fs9.readFileSync(path9.join(rootDir, "skillpack.json"), "utf-8");
+  const raw = fs10.readFileSync(path10.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
-var COMMANDS = {
-  "/new": "new",
-  "/clear": "clear",
-  "/restart": "restart",
-  "/shutdown": "shutdown"
-};
 function parseCommand(text) {
-  const trimmed = text.trim().toLowerCase();
-  return COMMANDS[trimmed] ?? null;
+  return resolveCommand(text.trim().toLowerCase());
+}
+function sendWsEvent(ws, event) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(event));
 }
 function getRuntimeConfigSignature(config) {
   return JSON.stringify({
@@ -5619,9 +5904,11 @@ var WebAdapter = class {
   name = "web";
   wss = null;
   agent = null;
+  ipcBroadcaster = null;
   async start(ctx) {
     const { agent, server, app, rootDir, lifecycle } = ctx;
     this.agent = agent;
+    this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
     const currentConf = configManager.getConfig();
     let apiKey = currentConf.apiKey || "";
     let currentProvider = currentConf.provider || "openai";
@@ -5744,23 +6031,23 @@ var WebAdapter = class {
         res.status(400).json({ error: "Missing 'path' query parameter" });
         return;
       }
-      const resolvedPath = path9.resolve(filePath);
-      const dataDir = path9.resolve(rootDir, "data");
+      const resolvedPath = path10.resolve(filePath);
+      const dataDir = path10.resolve(rootDir, "data");
       if (!resolvedPath.startsWith(dataDir)) {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (!fs9.existsSync(resolvedPath)) {
+      if (!fs10.existsSync(resolvedPath)) {
         res.status(404).json({ error: "File not found" });
         return;
       }
-      const filename = path9.basename(resolvedPath);
+      const filename = path10.basename(resolvedPath);
       res.setHeader("Content-Type", "application/octet-stream");
       res.setHeader(
         "Content-Disposition",
         `attachment; filename="${filename}"`
       );
-      fs9.createReadStream(resolvedPath).pipe(res);
+      fs10.createReadStream(resolvedPath).pipe(res);
     });
     const getScheduler = () => {
       const schedulerAdapter = ctx.adapterMap?.get("scheduler");
@@ -5881,21 +6168,15 @@ var WebAdapter = class {
         const command = parseCommand(text);
         if (command) {
           const result2 = await agent.handleCommand(command, channelId);
-          ws.send(
-            JSON.stringify({
-              type: "command_result",
-              command,
-              ...result2
-            })
-          );
-          if (command === "clear" || command === "new") {
-            ws.send(JSON.stringify({ done: true }));
+          if (result2.message) {
+            sendWsEvent(ws, { type: "text_delta", delta: result2.message });
           }
+          ws.send(JSON.stringify({ done: true }));
           return;
         }
         const onEvent = (event) => {
-          if (ws.readyState !== ws.OPEN) return;
-          ws.send(JSON.stringify(event));
+          sendWsEvent(ws, event);
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         const result = await agent.handleMessage("web", channelId, text, onEvent);
         if (result.errorMessage) {
@@ -5913,6 +6194,367 @@ var WebAdapter = class {
   }
 };
 
+// src/runtime/adapters/ipc.ts
+init_config();
+
+// src/runtime/services/conversation.ts
+import fs11 from "fs";
+import path11 from "path";
+import {
+  parseSessionEntries
+} from "@mariozechner/pi-coding-agent";
+var ConversationService = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Scan data/sessions and return conversation summaries sorted by recency.
+   */
+  listConversations(activeChannels) {
+    const sessionsDir = path11.resolve(this.rootDir, "data", "sessions");
+    const channelIds = new Set(activeChannels);
+    if (fs11.existsSync(sessionsDir)) {
+      for (const entry of fs11.readdirSync(sessionsDir)) {
+        const channelDir = path11.join(sessionsDir, entry);
+        try {
+          if (fs11.statSync(channelDir).isDirectory()) {
+            channelIds.add(entry);
+          }
+        } catch {
+        }
+      }
+    }
+    const results = [];
+    for (const channelId of channelIds) {
+      const channelDir = path11.join(sessionsDir, channelId);
+      const sessionFile = this.findLatestSessionFile(channelDir);
+      let messageCount = 0;
+      let lastMessageAt = "";
+      let lastMessagePreview = "";
+      if (sessionFile) {
+        const entries = this.loadEntries(sessionFile);
+        const messages = entries.filter(
+          (entry) => entry.type === "message"
+        );
+        messageCount = messages.length;
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage) {
+          lastMessageAt = lastMessage.timestamp;
+          lastMessagePreview = this.extractTextPreview(lastMessage, 100);
+        }
+      }
+      results.push({
+        channelId,
+        platform: this.detectPlatform(channelId),
+        sessionFile,
+        messageCount,
+        lastMessageAt,
+        lastMessagePreview
+      });
+    }
+    return results.sort((a, b) => {
+      const recency = (b.lastMessageAt || "").localeCompare(a.lastMessageAt || "");
+      if (recency !== 0) return recency;
+      return a.channelId.localeCompare(b.channelId);
+    });
+  }
+  /**
+   * Load latest messages for a channel in a simplified format.
+   */
+  getMessages(channelId, limit = 100) {
+    const channelDir = path11.resolve(
+      this.rootDir,
+      "data",
+      "sessions",
+      channelId
+    );
+    const sessionFile = this.findLatestSessionFile(channelDir);
+    if (!sessionFile) return [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 100;
+    if (safeLimit === 0) return [];
+    const entries = this.loadEntries(sessionFile);
+    const messages = [];
+    for (const entry of entries) {
+      if (entry.type !== "message") continue;
+      const role = entry.message?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const text = this.extractText(entry.message);
+      if (!text) continue;
+      const toolCalls = role === "assistant" ? this.extractToolCallSummaries(entry.message) : void 0;
+      messages.push({
+        id: entry.id,
+        role,
+        text,
+        timestamp: entry.timestamp,
+        toolCalls
+      });
+    }
+    return messages.slice(-safeLimit);
+  }
+  findLatestSessionFile(channelDir) {
+    if (!fs11.existsSync(channelDir)) return null;
+    let stats;
+    try {
+      stats = fs11.statSync(channelDir);
+    } catch {
+      return null;
+    }
+    if (!stats.isDirectory()) return null;
+    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path11.join(channelDir, files[0]) : null;
+  }
+  loadEntries(filePath) {
+    try {
+      const content = fs11.readFileSync(filePath, "utf-8");
+      const fileEntries = parseSessionEntries(content);
+      return fileEntries.filter((entry) => entry.type !== "session");
+    } catch (err) {
+      console.warn(`[ConversationService] Failed to load ${filePath}:`, err);
+      return [];
+    }
+  }
+  extractText(message) {
+    if (!message?.content) return "";
+    if (typeof message.content === "string") return message.content.trim();
+    if (!Array.isArray(message.content)) return "";
+    return message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  }
+  extractTextPreview(entry, maxLen) {
+    const text = this.extractText(entry.message);
+    return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+  }
+  extractToolCallSummaries(message) {
+    if (!Array.isArray(message?.content)) return void 0;
+    const toolCalls = message.content.filter((item) => item?.type === "toolCall").map((item) => ({
+      name: typeof item?.name === "string" && item.name ? item.name : "unknown",
+      isError: false
+    }));
+    return toolCalls.length > 0 ? toolCalls : void 0;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+};
+
+// src/runtime/adapters/ipc.ts
+init_types();
+var IpcAdapter = class {
+  name = "ipc";
+  agent = null;
+  rootDir = "";
+  adapterMap = null;
+  conversationService = null;
+  messageListener;
+  started = false;
+  async start(ctx) {
+    if (typeof process.send !== "function") {
+      return;
+    }
+    this.agent = ctx.agent;
+    this.rootDir = ctx.rootDir;
+    this.adapterMap = ctx.adapterMap ?? null;
+    this.conversationService = new ConversationService(ctx.rootDir);
+    this.messageListener = (message) => {
+      if (!this.isIpcRequest(message)) return;
+      void this.handleRequest(message);
+    };
+    process.on("message", this.messageListener);
+    this.started = true;
+    console.log("[IpcAdapter] Started");
+  }
+  async stop() {
+    if (this.messageListener) {
+      process.off("message", this.messageListener);
+      this.messageListener = void 0;
+    }
+    if (this.started) {
+      console.log("[IpcAdapter] Stopped");
+    }
+    this.started = false;
+  }
+  notifyReady(port) {
+    this.sendIpc({
+      type: "ready",
+      port
+    });
+  }
+  broadcastInbound(channelId, platform, sender, text) {
+    this.sendIpc({
+      type: "inbound_message",
+      channelId,
+      platform,
+      sender,
+      text,
+      timestamp: Date.now()
+    });
+  }
+  broadcastAgentEvent(channelId, event) {
+    this.sendIpc({
+      type: "agent_event",
+      channelId,
+      event
+    });
+  }
+  isIpcRequest(message) {
+    if (!message || typeof message !== "object") return false;
+    const maybe = message;
+    return typeof maybe.id === "string" && typeof maybe.type === "string";
+  }
+  async handleRequest(request) {
+    if (!this.agent || !this.conversationService) {
+      this.replyError(request.id, "IPC adapter is not ready yet");
+      return;
+    }
+    try {
+      switch (request.type) {
+        case "get_conversations": {
+          const activeChannels = new Set(this.agent.getActiveChannelIds());
+          const conversations = this.conversationService.listConversations(activeChannels);
+          this.reply(request.id, conversations);
+          return;
+        }
+        case "get_messages": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const messages = this.conversationService.getMessages(
+            request.channelId,
+            request.limit ?? 100
+          );
+          this.reply(request.id, messages);
+          return;
+        }
+        case "send_message": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          if (typeof request.text !== "string") {
+            this.replyError(request.id, "text is required");
+            return;
+          }
+          const platform = this.detectPlatform(request.channelId);
+          let fullText = "";
+          const result = await this.agent.handleMessage(
+            platform,
+            request.channelId,
+            request.text,
+            (event) => {
+              if (event.type === "text_delta") {
+                fullText += event.delta;
+              }
+              this.broadcastAgentEvent(request.channelId, event);
+            }
+          );
+          if (fullText.trim() && platform !== "web" && platform !== "scheduler") {
+            const adapter = this.adapterMap?.get(platform);
+            if (adapter && isMessageSender(adapter)) {
+              await adapter.sendMessage(request.channelId, fullText);
+            }
+          }
+          this.reply(request.id, {
+            ...result,
+            text: fullText
+          });
+          return;
+        }
+        case "command": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const result = await this.agent.handleCommand(request.command, request.channelId);
+          this.reply(request.id, result);
+          return;
+        }
+        case "get_config": {
+          this.reply(request.id, configManager.getConfig());
+          return;
+        }
+        case "update_config": {
+          configManager.save(this.rootDir, request.updates || {});
+          const updated = configManager.getConfig();
+          const provider = updated.provider || "openai";
+          this.agent.updateAuth(provider, updated.apiKey);
+          this.reply(request.id, updated);
+          return;
+        }
+        case "get_status": {
+          this.reply(request.id, {
+            status: "running",
+            pid: process.pid
+          });
+          return;
+        }
+        case "get_scheduled_jobs": {
+          const scheduler = this.getSchedulerAdapter();
+          this.reply(request.id, scheduler ? scheduler.listJobs() : []);
+          return;
+        }
+        case "add_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.addJob(request.job);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+        case "remove_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.removeJob(request.name);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+      }
+    } catch (err) {
+      this.replyError(
+        request.id,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  getSchedulerAdapter() {
+    const adapter = this.adapterMap?.get("scheduler");
+    if (!adapter) return null;
+    return adapter;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+  sendIpc(payload) {
+    if (typeof process.send === "function") {
+      process.send(payload);
+    }
+  }
+  reply(id, data) {
+    this.sendIpc({ id, type: "result", data });
+  }
+  replyError(id, message) {
+    this.sendIpc({ id, type: "error", message });
+  }
+};
+
 // src/runtime/server.ts
 init_config();
 
@@ -5989,28 +6631,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs10 from "fs";
+import fs12 from "fs";
 import os from "os";
-import path10 from "path";
-var SKILLPACK_HOME = path10.join(os.homedir(), ".skillpack");
-var LEGACY_REGISTRY_FILE = path10.join(SKILLPACK_HOME, "registry.json");
-var REGISTRY_DIR = path10.join(SKILLPACK_HOME, "registry.d");
+import path12 from "path";
+var SKILLPACK_HOME = path12.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path12.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path12.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs10.existsSync(SKILLPACK_HOME)) {
-    fs10.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs12.existsSync(SKILLPACK_HOME)) {
+    fs12.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs10.existsSync(REGISTRY_DIR)) {
-    fs10.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs12.existsSync(REGISTRY_DIR)) {
+    fs12.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path10.resolve(dir);
+  const resolved = path12.resolve(dir);
   try {
-    return fs10.realpathSync(resolved);
+    return fs12.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -6019,7 +6661,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path10.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path12.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -6027,11 +6669,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs10.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path10.join(REGISTRY_DIR, file));
+  return fs12.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path12.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs10.readFileSync(filePath, "utf-8");
+    const raw = fs12.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;
@@ -6064,8 +6706,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs10.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs10.renameSync(tmpPath, entryPath);
+  fs12.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs12.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -6073,14 +6715,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs10.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs12.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs10.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs12.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -6093,7 +6735,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs10.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs12.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -6146,7 +6788,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path12.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path14.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -6161,8 +6803,8 @@ async function startServer(options) {
   const packConfig = loadConfig(canonicalRootDir);
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId;
-  const packageRoot = path12.resolve(__dirname, "..");
-  const webDir = fs13.existsSync(path12.join(rootDir, "web")) ? path12.join(rootDir, "web") : path12.join(packageRoot, "web");
+  const packageRoot = path14.resolve(__dirname, "..");
+  const webDir = fs15.existsSync(path14.join(rootDir, "web")) ? path14.join(rootDir, "web") : path14.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -6190,8 +6832,31 @@ async function startServer(options) {
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
+  const hasIpcChannel = typeof process.send === "function";
+  const ipcAdapter = new IpcAdapter();
+  if (hasIpcChannel) {
+    await ipcAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      adapterMap
+    });
+    adapters.push(ipcAdapter);
+    adapterMap.set(ipcAdapter.name, ipcAdapter);
+  }
+  const ipcBroadcaster = hasIpcChannel ? ipcAdapter : void 0;
   const webAdapter = new WebAdapter();
-  await webAdapter.start({ agent, server, app, rootDir, lifecycle, adapterMap });
+  await webAdapter.start({
+    agent,
+    server,
+    app,
+    rootDir,
+    lifecycle,
+    adapterMap,
+    ipcBroadcaster
+  });
   adapters.push(webAdapter);
   adapterMap.set(webAdapter.name, webAdapter);
   if (dataConfig.adapters?.telegram?.token) {
@@ -6200,7 +6865,15 @@ async function startServer(options) {
       const telegramAdapter = new TelegramAdapter2({
         token: dataConfig.adapters.telegram.token
       });
-      await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
+      await telegramAdapter.start({
+        agent,
+        server,
+        app,
+        rootDir,
+        lifecycle,
+        adapterMap,
+        ipcBroadcaster
+      });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
     } catch (err) {
@@ -6220,7 +6893,15 @@ async function startServer(options) {
           botToken: slackConfig.botToken,
           appToken: slackConfig.appToken
         });
-        await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
+        await slackAdapter.start({
+          agent,
+          server,
+          app,
+          rootDir,
+          lifecycle,
+          adapterMap,
+          ipcBroadcaster
+        });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
       } catch (err) {
@@ -6283,6 +6964,9 @@ async function startServer(options) {
     } catch (err) {
       console.warn("  [Registry] Could not register pack:", err);
     }
+    if (hasIpcChannel) {
+      ipcAdapter.notifyReady(typeof actualPort === "number" ? actualPort : port);
+    }
     if (!daemonRun) {
       const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
       exec(cmd, (err) => {
@@ -6330,23 +7014,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path13.resolve(
+  const templateDir = path15.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path13.join(templateDir, file);
-    const dest = path13.join(workDir, file);
-    if (fs14.existsSync(src)) {
-      fs14.copyFileSync(src, dest);
+    const src = path15.join(templateDir, file);
+    const dest = path15.join(workDir, file);
+    if (fs16.existsSync(src)) {
+      fs16.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs14.chmodSync(dest, 493);
+        fs16.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path13.resolve(directory) : process.cwd();
-  fs14.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path15.resolve(directory) : process.cwd();
+  fs16.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([
@@ -6391,9 +7075,9 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs15 from "fs";
+import fs17 from "fs";
 var packageJson = JSON.parse(
-  fs15.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs17.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);