@cremini/skillpack 1.1.3 → 1.1.4

package/dist/cli.js

@@ -1,16 +1,717 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runtime/adapters/markdown.ts
+function unwrapMarkdownSourceBlocks(text) {
+  return text.replace(
+    MARKDOWN_SOURCE_BLOCK_RE,
+    (_, content) => content.trim()
+  );
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttribute(text) {
+  return escapeHtml(text).replace(/"/g, "&quot;");
+}
+function protect(text, pattern, placeholders, render) {
+  const nextText = text.replace(pattern, (...args) => {
+    const match = args[0];
+    const groups = args.slice(1, -2);
+    const token = `${PLACEHOLDER_START}${placeholders.length}${PLACEHOLDER_END}`;
+    placeholders.push(render(match, ...groups));
+    return token;
+  });
+  return nextText;
+}
+function restore(text, placeholders) {
+  return text.replace(
+    new RegExp(`${PLACEHOLDER_START}(\\d+)${PLACEHOLDER_END}`, "g"),
+    (_, index) => placeholders[Number(index)] ?? ""
+  );
+}
+function formatSlackInline(text) {
+  let formatted = text;
+  formatted = formatted.replace(LINK_RE, (_, label, url) => {
+    return `<${url}|${label}>`;
+  });
+  formatted = formatted.replace(
+    /^(#{1,6})[ \t]+(.+)$/gm,
+    (_, __, content) => `*${content.trim()}*`
+  );
+  formatted = formatted.replace(/\*\*([^*\n]+)\*\*/g, "*$1*");
+  formatted = formatted.replace(/__([^_\n]+)__/g, "*$1*");
+  return formatted;
+}
+function formatTelegramInline(text) {
+  let formatted = escapeHtml(text);
+  formatted = formatted.replace(LINK_RE, (_, label, url) => {
+    return `<a href="${escapeHtmlAttribute(url)}">${escapeHtml(label)}</a>`;
+  });
+  formatted = formatted.replace(
+    /^(#{1,6})[ \t]+(.+)$/gm,
+    (_, __, content) => `<b>${content.trim()}</b>`
+  );
+  formatted = formatted.replace(/\*\*([^*\n]+)\*\*/g, "<b>$1</b>");
+  formatted = formatted.replace(/__([^_\n]+)__/g, "<b>$1</b>");
+  formatted = formatted.replace(
+    /(^|[^\w<])\*([^*\n]+)\*(?=[^\w>]|$)/g,
+    "$1<i>$2</i>"
+  );
+  formatted = formatted.replace(
+    /(^|[^\w<])_([^_\n]+)_(?=[^\w>]|$)/g,
+    "$1<i>$2</i>"
+  );
+  formatted = formatted.replace(/^(?:-|\*) /gm, "\u2022 ");
+  return formatted;
+}
+function formatSlackMessage(text) {
+  const unwrapped = unwrapMarkdownSourceBlocks(text);
+  const placeholders = [];
+  const withFenced = protect(
+    unwrapped,
+    FENCED_CODE_BLOCK_RE,
+    placeholders,
+    (block) => block
+  );
+  const withInline = protect(
+    withFenced,
+    INLINE_CODE_RE,
+    placeholders,
+    (_match, code) => `\`${code}\``
+  );
+  return restore(formatSlackInline(withInline), placeholders);
+}
+function formatTelegramMessage(text) {
+  const unwrapped = unwrapMarkdownSourceBlocks(text);
+  const placeholders = [];
+  const withFenced = protect(
+    unwrapped,
+    FENCED_CODE_BLOCK_RE,
+    placeholders,
+    (block) => {
+      const content = block.replace(/^```[^\n]*\n/, "").replace(/\n```$/, "");
+      return `<pre><code>${escapeHtml(content)}</code></pre>`;
+    }
+  );
+  const withInline = protect(
+    withFenced,
+    INLINE_CODE_RE,
+    placeholders,
+    (_match, code) => `<code>${escapeHtml(code)}</code>`
+  );
+  return restore(formatTelegramInline(withInline), placeholders);
+}
+var MARKDOWN_SOURCE_BLOCK_RE, FENCED_CODE_BLOCK_RE, INLINE_CODE_RE, LINK_RE, PLACEHOLDER_START, PLACEHOLDER_END;
+var init_markdown = __esm({
+  "src/runtime/adapters/markdown.ts"() {
+    "use strict";
+    MARKDOWN_SOURCE_BLOCK_RE = /```(?:md|markdown)\s*\n([\s\S]*?)```/gi;
+    FENCED_CODE_BLOCK_RE = /```[^\n]*\n[\s\S]*?```/g;
+    INLINE_CODE_RE = /`([^`\n]+)`/g;
+    LINK_RE = /\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;
+    PLACEHOLDER_START = "\uE000";
+    PLACEHOLDER_END = "\uE001";
+  }
+});
+
+// src/runtime/adapters/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  TelegramAdapter: () => TelegramAdapter
+});
+import TelegramBot from "node-telegram-bot-api";
+var COMMANDS2, MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
+var init_telegram = __esm({
+  "src/runtime/adapters/telegram.ts"() {
+    "use strict";
+    init_markdown();
+    COMMANDS2 = {
+      "/clear": "clear",
+      "/restart": "restart",
+      "/shutdown": "shutdown"
+    };
+    MAX_MESSAGE_LENGTH = 4096;
+    ACK_REACTION = {
+      type: "emoji",
+      emoji: "\u{1F440}"
+    };
+    TelegramAdapter = class {
+      name = "telegram";
+      bot = null;
+      agent = null;
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      async start(ctx) {
+        this.agent = ctx.agent;
+        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" }
+        ]);
+        const me = await this.bot.getMe();
+        console.log(`[TelegramAdapter] Started as @${me.username}`);
+      }
+      async stop() {
+        if (this.bot) {
+          await this.bot.stopPolling();
+          this.bot = null;
+        }
+        console.log("[TelegramAdapter] Stopped");
+      }
+      // -------------------------------------------------------------------------
+      // Message handler
+      // -------------------------------------------------------------------------
+      async handleTelegramMessage(msg) {
+        if (!this.bot || !this.agent) return;
+        const chatId = msg.chat.id;
+        const messageId = msg.message_id;
+        const text = msg.text?.trim();
+        if (!text) return;
+        const channelId = `telegram-${chatId}`;
+        await this.tryAckReaction(chatId, messageId);
+        const commandKey = text.split(/\s/)[0].toLowerCase();
+        const command = COMMANDS2[commandKey];
+        if (command) {
+          const result = await this.agent.handleCommand(command, channelId);
+          await this.sendSafe(chatId, result.message || `/${command} executed.`);
+          return;
+        }
+        await this.bot.sendChatAction(chatId, "typing");
+        let finalText = "";
+        let hasError = false;
+        let errorMessage = "";
+        const onEvent = (event) => {
+          switch (event.type) {
+            case "text_delta":
+              finalText += event.delta;
+              break;
+          }
+        };
+        try {
+          const result = await this.agent.handleMessage(channelId, text, onEvent);
+          if (result.errorMessage) {
+            hasError = true;
+            errorMessage = result.errorMessage;
+          }
+        } catch (err) {
+          hasError = true;
+          errorMessage = String(err);
+        }
+        if (hasError) {
+          await this.sendSafe(chatId, `\u274C Error: ${errorMessage}`);
+          return;
+        }
+        if (!finalText.trim()) {
+          await this.sendSafe(chatId, "(No response generated)");
+          return;
+        }
+        await this.sendLongMessage(chatId, finalText);
+      }
+      // -------------------------------------------------------------------------
+      // Send helpers
+      // -------------------------------------------------------------------------
+      /**
+       * Send a message, splitting into chunks if too long.
+       */
+      async sendLongMessage(chatId, text) {
+        const chunks = this.splitMessage(text);
+        for (const chunk of chunks) {
+          await this.sendWithRetry(chatId, chunk);
+        }
+      }
+      /**
+       * React to the incoming message to show the bot has started processing it.
+       */
+      async tryAckReaction(chatId, messageId) {
+        try {
+          await this.bot?.setMessageReaction(chatId, messageId, {
+            reaction: [ACK_REACTION],
+            is_big: false
+          });
+        } catch (err) {
+          console.error("[Telegram] Failed to add ack reaction:", err);
+        }
+      }
+      /**
+       * Split text into chunks respecting Telegram's message length limit.
+       * Tries to split at paragraph boundaries.
+       */
+      splitMessage(text) {
+        if (text.length <= MAX_MESSAGE_LENGTH) {
+          return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+          if (remaining.length <= MAX_MESSAGE_LENGTH) {
+            chunks.push(remaining);
+            break;
+          }
+          let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH);
+          if (splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+            splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+          }
+          if (splitAt < MAX_MESSAGE_LENGTH * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+          }
+          if (splitAt < 1) {
+            splitAt = MAX_MESSAGE_LENGTH;
+          }
+          chunks.push(remaining.slice(0, splitAt));
+          remaining = remaining.slice(splitAt).trimStart();
+        }
+        return chunks;
+      }
+      /**
+       * Send a message with automatic retry on 429 (rate limit).
+       */
+      async sendWithRetry(chatId, text, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            await this.bot.sendMessage(chatId, formatTelegramMessage(text), {
+              parse_mode: "HTML"
+            });
+            return;
+          } catch (err) {
+            if (err?.response?.statusCode === 429 && attempt < maxRetries) {
+              const retryAfter = err.response?.body?.parameters?.retry_after || 5;
+              console.log(
+                `[Telegram] Rate limited, retrying after ${retryAfter}s...`
+              );
+              await new Promise(
+                (resolve) => setTimeout(resolve, retryAfter * 1e3)
+              );
+              continue;
+            }
+            throw err;
+          }
+        }
+      }
+      /**
+       * Safe send that catches and logs errors.
+       */
+      async sendSafe(chatId, text) {
+        try {
+          await this.sendWithRetry(chatId, text);
+        } catch (err) {
+          console.error("[Telegram] Failed to send message:", err);
+        }
+      }
+    };
+  }
+});
+
+// src/runtime/adapters/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  SlackAdapter: () => SlackAdapter
+});
+import { App, LogLevel } from "@slack/bolt";
+var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, SlackAdapter;
+var init_slack = __esm({
+  "src/runtime/adapters/slack.ts"() {
+    "use strict";
+    init_markdown();
+    INLINE_COMMANDS = {
+      "/clear": "clear",
+      "/restart": "restart",
+      "/shutdown": "shutdown"
+    };
+    SLASH_COMMANDS = {
+      "/skillpack-clear": "clear",
+      "/skillpack-restart": "restart",
+      "/skillpack-shutdown": "shutdown"
+    };
+    MAX_MESSAGE_LENGTH2 = 3500;
+    ACK_REACTION2 = "eyes";
+    SlackAdapter = class {
+      name = "slack";
+      app = null;
+      agent = null;
+      options;
+      botUserId = null;
+      lastThreadByChannel = /* @__PURE__ */ new Map();
+      constructor(options) {
+        this.options = options;
+      }
+      async start(ctx) {
+        this.agent = ctx.agent;
+        this.app = new App({
+          token: this.options.botToken,
+          appToken: this.options.appToken,
+          socketMode: true,
+          ignoreSelf: true,
+          logLevel: LogLevel.INFO
+        });
+        const auth = await this.app.client.auth.test({
+          token: this.options.botToken
+        });
+        this.botUserId = typeof auth.user_id === "string" ? auth.user_id : null;
+        this.registerListeners(this.app);
+        await this.app.start();
+        const identity = this.botUserId ? `<@${this.botUserId}>` : "Slack bot";
+        console.log(`[SlackAdapter] Started as ${identity}`);
+      }
+      async stop() {
+        if (this.app) {
+          await this.app.stop();
+          this.app = null;
+        }
+        console.log("[SlackAdapter] Stopped");
+      }
+      // -------------------------------------------------------------------------
+      // Listener registration
+      // -------------------------------------------------------------------------
+      registerListeners(app) {
+        app.event("message", async (args) => {
+          try {
+            await this.handleDirectMessage(args);
+          } catch (err) {
+            console.error("[Slack] Error handling DM:", err);
+          }
+        });
+        app.event("app_mention", async (args) => {
+          try {
+            await this.handleMention(args);
+          } catch (err) {
+            console.error("[Slack] Error handling mention:", err);
+          }
+        });
+        for (const commandName of Object.keys(SLASH_COMMANDS)) {
+          app.command(commandName, async (args) => {
+            try {
+              await this.handleSlashCommand(args);
+            } catch (err) {
+              console.error(`[Slack] Error handling ${commandName}:`, err);
+              await this.safeAck(
+                args.ack,
+                `\u274C Error: ${this.getErrorMessage(err)}`
+              );
+            }
+          });
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Event handlers
+      // -------------------------------------------------------------------------
+      async handleDirectMessage({
+        event,
+        body,
+        context,
+        client
+      }) {
+        if (!this.agent || !this.isSupportedDmEvent(event)) {
+          return;
+        }
+        const text = (event.text || "").trim();
+        if (!text) return;
+        const teamId = this.getTeamId(body, context);
+        const channelId = `slack-dm-${teamId}-${event.channel}`;
+        const route = { channel: event.channel };
+        await this.tryAckReaction(client, event);
+        if (await this.tryHandleInlineCommand(text, channelId, client, route)) {
+          return;
+        }
+        await this.runAgent(channelId, text, client, route);
+      }
+      async handleMention({
+        event,
+        body,
+        context,
+        client
+      }) {
+        if (!this.agent || !this.isSupportedMentionEvent(event)) {
+          return;
+        }
+        const teamId = this.getTeamId(body, context);
+        const threadTs = event.thread_ts || event.ts;
+        const channelId = `slack-thread-${teamId}-${event.channel}-${threadTs}`;
+        const route = {
+          channel: event.channel,
+          threadTs
+        };
+        this.lastThreadByChannel.set(
+          this.getChannelKey(teamId, event.channel),
+          threadTs
+        );
+        const text = this.stripBotMention(event.text || "").trim();
+        if (!text) {
+          await this.sendSafe(
+            client,
+            route,
+            "Mention me with a message, or use `/clear` to reset this thread."
+          );
+          return;
+        }
+        await this.tryAckReaction(client, event);
+        if (await this.tryHandleInlineCommand(text, channelId, client, route)) {
+          return;
+        }
+        await this.runAgent(channelId, text, client, route);
+      }
+      async handleSlashCommand({
+        command,
+        body,
+        context,
+        ack
+      }) {
+        const commandName = command?.command;
+        const mapped = commandName ? SLASH_COMMANDS[commandName] : void 0;
+        if (!this.agent || !mapped) {
+          await this.safeAck(ack, "Unsupported slash command.");
+          return;
+        }
+        const resolved = this.resolveSlashCommandTarget(body || command, context);
+        if (!resolved.channelId) {
+          await this.safeAck(ack, resolved.message);
+          return;
+        }
+        const result = await this.agent.handleCommand(mapped, resolved.channelId);
+        const parts = [result.message || `${commandName} executed.`];
+        if (resolved.note) {
+          parts.push(resolved.note);
+        }
+        await this.safeAck(ack, parts.join("\n"));
+      }
+      // -------------------------------------------------------------------------
+      // Agent bridge
+      // -------------------------------------------------------------------------
+      async runAgent(channelId, text, client, route) {
+        if (!this.agent) return;
+        let finalText = "";
+        let hasError = false;
+        let errorMessage = "";
+        const onEvent = (event) => {
+          if (event.type === "text_delta") {
+            finalText += event.delta;
+          }
+        };
+        try {
+          const result = await this.agent.handleMessage(channelId, text, onEvent);
+          if (result.errorMessage) {
+            hasError = true;
+            errorMessage = result.errorMessage;
+          }
+        } catch (err) {
+          hasError = true;
+          errorMessage = this.getErrorMessage(err);
+        }
+        if (hasError) {
+          await this.sendSafe(client, route, `\u274C Error: ${errorMessage}`);
+          return;
+        }
+        if (!finalText.trim()) {
+          await this.sendSafe(client, route, "(No response generated)");
+          return;
+        }
+        await this.sendLongMessage(client, route, finalText);
+      }
+      // -------------------------------------------------------------------------
+      // Helpers
+      // -------------------------------------------------------------------------
+      async tryHandleInlineCommand(text, channelId, client, route) {
+        if (!this.agent) return false;
+        const commandKey = text.split(/\s/)[0].toLowerCase();
+        const command = INLINE_COMMANDS[commandKey];
+        if (!command) return false;
+        const result = await this.agent.handleCommand(command, channelId);
+        await this.sendSafe(
+          client,
+          route,
+          result.message || `${commandKey} executed.`
+        );
+        return true;
+      }
+      resolveSlashCommandTarget(payload, context) {
+        const teamId = this.getTeamId(payload, context);
+        const channel = payload?.channel_id;
+        if (!channel) {
+          return { message: "Missing Slack channel context." };
+        }
+        if (this.isDmChannelId(channel)) {
+          return {
+            channelId: `slack-dm-${teamId}-${channel}`,
+            message: ""
+          };
+        }
+        const threadTs = this.lastThreadByChannel.get(
+          this.getChannelKey(teamId, channel)
+        );
+        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`."
+          };
+        }
+        return {
+          channelId: `slack-thread-${teamId}-${channel}-${threadTs}`,
+          message: "",
+          note: "Applied to the most recent active Skillpack thread in this channel."
+        };
+      }
+      isSupportedDmEvent(event) {
+        if (!event || event.type !== "message") return false;
+        if (event.channel_type !== "im") return false;
+        if (event.subtype) return false;
+        if (event.bot_id) return false;
+        if (!event.user || typeof event.text !== "string") return false;
+        return true;
+      }
+      isSupportedMentionEvent(event) {
+        if (!event || event.type !== "app_mention") return false;
+        if (event.subtype) return false;
+        if (event.bot_id) return false;
+        if (!event.user || typeof event.text !== "string") return false;
+        return true;
+      }
+      stripBotMention(text) {
+        const mention = this.botUserId ? new RegExp(`^\\s*<@${this.escapeRegExp(this.botUserId)}>\\s*`) : /^\s*<@[^>]+>\s*/;
+        return text.replace(mention, "");
+      }
+      splitMessage(text) {
+        if (text.length <= MAX_MESSAGE_LENGTH2) {
+          return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+          if (remaining.length <= MAX_MESSAGE_LENGTH2) {
+            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;
+          }
+          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)) {
+          await this.sendWithRetry(client, route, chunk);
+        }
+      }
+      async sendSafe(client, route, text) {
+        try {
+          await this.sendWithRetry(client, route, text);
+        } catch (err) {
+          console.error("[Slack] Failed to send message:", err);
+        }
+      }
+      async sendWithRetry(client, route, text, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            await client.chat.postMessage({
+              channel: route.channel,
+              text: formatSlackMessage(text),
+              mrkdwn: true,
+              thread_ts: route.threadTs,
+              reply_broadcast: false
+            });
+            return;
+          } catch (err) {
+            const retryAfter = this.getRetryAfterSeconds(err);
+            if (retryAfter && attempt < maxRetries) {
+              console.log(
+                `[Slack] Rate limited, retrying after ${retryAfter}s...`
+              );
+              await new Promise(
+                (resolve) => setTimeout(resolve, retryAfter * 1e3)
+              );
+              continue;
+            }
+            throw err;
+          }
+        }
+      }
+      async tryAckReaction(client, event) {
+        try {
+          await client.reactions.add({
+            channel: event.channel,
+            timestamp: event.ts,
+            name: ACK_REACTION2
+          });
+        } catch (err) {
+          console.error("[Slack] Failed to add ack reaction:", err);
+        }
+      }
+      async safeAck(ack, message) {
+        if (!ack) return;
+        try {
+          await ack(message);
+        } catch (err) {
+          console.error("[Slack] Failed to ack slash command:", err);
+        }
+      }
+      getRetryAfterSeconds(err) {
+        const candidates = [
+          err?.data?.retryAfter,
+          err?.retryAfter,
+          err?.headers?.["retry-after"],
+          err?.data?.headers?.["retry-after"]
+        ];
+        for (const value of candidates) {
+          const seconds = Number(value);
+          if (Number.isFinite(seconds) && seconds > 0) {
+            return seconds;
+          }
+        }
+        return null;
+      }
+      getTeamId(payload, context) {
+        return context?.teamId || payload?.team_id || payload?.team?.id || payload?.authorizations?.[0]?.team_id || "unknown";
+      }
+      getChannelKey(teamId, channelId) {
+        return `${teamId}:${channelId}`;
+      }
+      isDmChannelId(channelId) {
+        return channelId.startsWith("D");
+      }
+      getErrorMessage(err) {
+        return err instanceof Error ? err.message : String(err);
+      }
+      escapeRegExp(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+    };
+  }
+});
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk8 from "chalk";
+import chalk5 from "chalk";
 
 // src/commands/create.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import inquirer from "inquirer";
 import chalk3 from "chalk";
 
-// src/core/pack-config.ts
+// src/pack-config.ts
 import fs from "fs";
 import path from "path";
 var PACK_FILE = "skillpack.json";
@@ -113,13 +814,13 @@ function configExists(workDir) {
   return fs.existsSync(getPackPath(workDir));
 }
 
-// src/core/bundler.ts
-import fs4 from "fs";
-import path4 from "path";
+// src/commands/zip.ts
+import fs3 from "fs";
+import path3 from "path";
 import archiver from "archiver";
 import chalk2 from "chalk";
 
-// src/core/skill-manager.ts
+// src/skill-manager.ts
 import { spawnSync } from "child_process";
 import fs2 from "fs";
 import path2 from "path";
@@ -282,149 +983,17 @@ function refreshDescriptionsAndSave(workDir, config) {
   saveConfig(workDir, config);
   return config;
 }
-function removeSkill(workDir, skillName) {
-  const config = loadConfig(workDir);
-  const normalizedName = normalizeName(skillName);
-  const nextSkills = config.skills.filter(
-    (skill) => normalizeName(skill.name) !== normalizedName
-  );
-  if (nextSkills.length === config.skills.length) {
-    console.log(chalk.yellow(`Skill not found: ${skillName}`));
-    return false;
-  }
-  config.skills = nextSkills;
-  saveConfig(workDir, config);
-  const installedMatches = scanInstalledSkills(workDir).filter(
-    (skill) => normalizeName(skill.name) === normalizedName
-  );
-  if (installedMatches.length === 0) {
-    console.log(
-      chalk.yellow(`Removed config for ${skillName}, but no installed files were found`)
-    );
-    return true;
-  }
-  for (const skill of installedMatches) {
-    if (fs2.existsSync(skill.dir)) {
-      fs2.rmSync(skill.dir, { recursive: true, force: true });
-    }
-  }
-  console.log(chalk.green(`Removed skill: ${skillName}`));
-  return true;
-}
 
-// src/core/runtime-template.ts
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath } from "url";
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
-var EXECUTABLE_RUNTIME_FILES = /* @__PURE__ */ new Set(["start.sh", "start.bat"]);
-function isExecutableRuntimeFile(relativePath) {
-  return EXECUTABLE_RUNTIME_FILES.has(relativePath);
-}
-function withExecuteBits(mode) {
-  return mode | 73;
-}
-function getRuntimeDir() {
-  const projectRoot = path3.resolve(__dirname, "..");
-  return path3.join(projectRoot, "runtime");
-}
-function assertRuntimeDirExists(runtimeDir) {
-  if (!fs3.existsSync(runtimeDir)) {
-    throw new Error(`Runtime directory not found: ${runtimeDir}`);
-  }
-}
-function collectRuntimeTemplateEntries(runtimeDir) {
-  assertRuntimeDirExists(runtimeDir);
-  const entries = [];
-  function visit(currentDir, relativeDir = "") {
-    const dirEntries = fs3.readdirSync(currentDir, { withFileTypes: true });
-    for (const dirEntry of dirEntries) {
-      if (dirEntry.name === "node_modules") {
-        continue;
-      }
-      const currentRelative = relativeDir ? path3.posix.join(relativeDir, dirEntry.name) : dirEntry.name;
-      if (currentRelative === "server/src" || currentRelative === "server/tsconfig.json") {
-        continue;
-      }
-      const absolutePath = path3.join(currentDir, dirEntry.name);
-      const relativePath = relativeDir ? path3.posix.join(relativeDir, dirEntry.name) : dirEntry.name;
-      const stats = fs3.statSync(absolutePath);
-      if (dirEntry.isDirectory()) {
-        entries.push({
-          absolutePath,
-          relativePath,
-          stats,
-          type: "directory"
-        });
-        visit(absolutePath, relativePath);
-        continue;
-      }
-      if (dirEntry.isFile()) {
-        entries.push({
-          absolutePath,
-          relativePath,
-          stats,
-          type: "file"
-        });
-      }
-    }
-  }
-  visit(runtimeDir);
-  return entries;
-}
-function copyRuntimeTemplate(runtimeDir, workDir) {
-  const entries = collectRuntimeTemplateEntries(runtimeDir);
-  for (const entry of entries) {
-    const destinationPath = path3.join(workDir, entry.relativePath);
-    if (entry.type === "directory") {
-      fs3.mkdirSync(destinationPath, { recursive: true });
-      continue;
-    }
-    fs3.mkdirSync(path3.dirname(destinationPath), { recursive: true });
-    fs3.copyFileSync(entry.absolutePath, destinationPath);
-    fs3.chmodSync(destinationPath, entry.stats.mode);
-  }
-}
-function ensureRuntimeLaunchersExecutable(workDir) {
-  for (const relativePath of EXECUTABLE_RUNTIME_FILES) {
-    const filePath = path3.join(workDir, relativePath);
-    if (!fs3.existsSync(filePath)) {
-      continue;
-    }
-    const currentMode = fs3.statSync(filePath).mode;
-    fs3.chmodSync(filePath, withExecuteBits(currentMode));
-  }
-}
-function addRuntimeFiles(archive, runtimeDir, prefix) {
-  const entries = collectRuntimeTemplateEntries(runtimeDir);
-  for (const entry of entries) {
-    const archivePath = `${prefix}/${entry.relativePath}`;
-    if (entry.type === "directory") {
-      archive.append("", {
-        name: `${archivePath}/`,
-        mode: entry.stats.mode
-      });
-      continue;
-    }
-    archive.file(entry.absolutePath, {
-      name: archivePath,
-      mode: isExecutableRuntimeFile(entry.relativePath) ? withExecuteBits(entry.stats.mode) : entry.stats.mode
-    });
-  }
-}
-
-// src/core/bundler.ts
-async function bundle(workDir) {
+// src/commands/zip.ts
+async function zipCommand(workDir) {
   const config = loadConfig(workDir);
   const zipName = `${config.name}.zip`;
-  const zipPath = path4.join(workDir, zipName);
-  const runtimeDir = getRuntimeDir();
-  assertRuntimeDirExists(runtimeDir);
+  const zipPath = path3.join(workDir, zipName);
   installConfiguredSkills(workDir, config);
   syncSkillDescriptions(workDir, config);
   saveConfig(workDir, config);
   console.log(chalk2.blue(`Packaging ${config.name}...`));
-  const output = fs4.createWriteStream(zipPath);
+  const output = fs3.createWriteStream(zipPath);
   const archive = archiver("zip", { zlib: { level: 9 } });
   return new Promise((resolve, reject) => {
     output.on("close", () => {
@@ -441,11 +1010,18 @@ async function bundle(workDir) {
     archive.file(getPackPath(workDir), {
       name: `${prefix}/${PACK_FILE}`
     });
-    const skillsDir = path4.join(workDir, "skills");
-    if (fs4.existsSync(skillsDir)) {
+    const skillsDir = path3.join(workDir, "skills");
+    if (fs3.existsSync(skillsDir)) {
       archive.directory(skillsDir, `${prefix}/skills`);
     }
-    addRuntimeFiles(archive, runtimeDir, prefix);
+    const startSh = path3.join(workDir, "start.sh");
+    if (fs3.existsSync(startSh)) {
+      archive.file(startSh, { name: `${prefix}/start.sh`, mode: 493 });
+    }
+    const startBat = path3.join(workDir, "start.bat");
+    if (fs3.existsSync(startBat)) {
+      archive.file(startBat, { name: `${prefix}/start.bat` });
+    }
     archive.finalize();
   });
 }
@@ -473,11 +1049,92 @@ function parseSourceInput(value) {
     inlineSkillNames: inlineSkillValue.split(/[,\s]+/).map((name) => name.trim()).filter(Boolean)
   };
 }
-async function createCommand(directory) {
-  const workDir = directory ? path5.resolve(directory) : process.cwd();
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function readConfigSource(source) {
+  let raw = "";
+  if (isHttpUrl(source)) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download config: ${response.status} ${response.statusText}`
+      );
+    }
+    raw = await response.text();
+  } else {
+    const filePath = path4.resolve(source);
+    raw = fs4.readFileSync(filePath, "utf-8");
+  }
+  const parsed = JSON.parse(raw);
+  validateConfigShape(parsed, source);
+  return parsed;
+}
+function copyStartTemplates(workDir) {
+  const templateDir = path4.resolve(
+    new URL("../templates", import.meta.url).pathname
+  );
+  for (const file of ["start.sh", "start.bat"]) {
+    const src = path4.join(templateDir, file);
+    const dest = path4.join(workDir, file);
+    if (fs4.existsSync(src)) {
+      fs4.copyFileSync(src, dest);
+      if (file === "start.sh") {
+        fs4.chmodSync(dest, 493);
+      }
+    } else {
+      console.warn(chalk3.yellow(`  [warn] Template not found: ${src}`));
+    }
+  }
+}
+async function createCommand(directory, options = {}) {
+  const workDir = directory ? path4.resolve(directory) : process.cwd();
   if (directory) {
-    fs5.mkdirSync(workDir, { recursive: true });
+    fs4.mkdirSync(workDir, { recursive: true });
   }
+  if (options.config) {
+    await initFromConfig(workDir, options.config);
+    return;
+  }
+  await interactiveCreate(workDir);
+}
+async function initFromConfig(workDir, configSource) {
+  if (configExists(workDir)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `A ${PACK_FILE} file already exists in this directory. Overwrite it?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk3.yellow("Cancelled"));
+      return;
+    }
+  }
+  const config = await readConfigSource(configSource);
+  saveConfig(workDir, config);
+  console.log(chalk3.blue(`
+  Initialize ${config.name} from ${configSource}
+`));
+  installConfiguredSkills(workDir, config);
+  refreshDescriptionsAndSave(workDir, config);
+  copyStartTemplates(workDir);
+  console.log(chalk3.green(`
+  ${PACK_FILE} saved`));
+  console.log(chalk3.green(`  start.sh / start.bat created`));
+  console.log(chalk3.green(`  Initialization complete.
+`));
+  console.log(chalk3.dim(`  Run npx @cremini/skillpack run . to start
+`));
+}
+async function interactiveCreate(workDir) {
   if (configExists(workDir)) {
     const { overwrite } = await inquirer.prompt([
       {
@@ -568,261 +1225,867 @@ async function createCommand(directory) {
       {
         type: "input",
         name: "prompt",
-        message: isFirst ? `Prompt #${promptIndex} (required):` : `Prompt #${promptIndex} (leave blank to finish):`,
-        validate: isFirst ? (value) => value.trim() ? true : "The first Prompt cannot be empty" : void 0
+        message: isFirst ? `Prompt #${promptIndex} (leave blank to skip):` : `Prompt #${promptIndex} (leave blank to finish):`
       }
     ]);
-    if (!isFirst && !prompt.trim()) {
+    if (!prompt.trim()) {
       break;
     }
     config.prompts.push(prompt.trim());
     promptIndex++;
   }
-  const { shouldBundle } = await inquirer.prompt([
+  const { shouldZip } = await inquirer.prompt([
     {
       type: "confirm",
-      name: "shouldBundle",
-      message: "Bundle as a zip now?",
+      name: "shouldZip",
+      message: "Package as a zip now?",
       default: true
     }
   ]);
   saveConfig(workDir, config);
+  copyStartTemplates(workDir);
   console.log(chalk3.green(`
-  ${PACK_FILE} saved
+  ${PACK_FILE} saved`));
+  console.log(chalk3.green(`  start.sh / start.bat created
 `));
   if (requestedSkills.length > 0) {
     installConfiguredSkills(workDir, config);
     refreshDescriptionsAndSave(workDir, config);
   }
-  if (shouldBundle) {
-    await bundle(workDir);
+  if (shouldZip) {
+    await zipCommand(workDir);
   }
   console.log(chalk3.green("\n  Done!"));
-  if (!shouldBundle) {
+  if (!shouldZip) {
     console.log(
-      chalk3.dim("  Run npx @cremini/skillpack build to create the zip\n")
+      chalk3.dim(
+        "  Run npx @cremini/skillpack run . to start\n  Run npx @cremini/skillpack zip to create the zip\n"
+      )
     );
   }
 }
 
-// src/commands/init.ts
-import fs6 from "fs";
-import path6 from "path";
+// src/commands/run.ts
+import path9 from "path";
+import fs9 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
-function isHttpUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
+
+// src/runtime/server.ts
+import express from "express";
+import path8 from "path";
+import fs8 from "fs";
+import { fileURLToPath } from "url";
+import { createServer } from "http";
+import { exec } from "child_process";
+
+// src/runtime/agent.ts
+import path5 from "path";
+import fs5 from "fs";
+import {
+  AuthStorage,
+  createAgentSession,
+  createCodingTools,
+  ModelRegistry,
+  SessionManager,
+  DefaultResourceLoader
+} from "@mariozechner/pi-coding-agent";
+var DEBUG = true;
+var log = (...args) => DEBUG && console.log(...args);
+var write = (data) => DEBUG && process.stdout.write(data);
+function getAssistantDiagnostics(message) {
+  if (!message || message.role !== "assistant") {
+    return null;
   }
+  const stopReason = message.stopReason ?? "unknown";
+  const errorMessage = message.errorMessage || (stopReason === "error" || stopReason === "aborted" ? `Request ${stopReason}` : "");
+  const content = Array.isArray(message.content) ? message.content : [];
+  const text = content.filter((item) => item?.type === "text").map((item) => item.text || "").join("").trim();
+  const toolCalls = content.filter(
+    (item) => item?.type === "toolCall"
+  ).length;
+  return { stopReason, errorMessage, hasText: text.length > 0, toolCalls };
 }
-async function readConfigSource(source) {
-  let raw = "";
-  if (isHttpUrl(source)) {
-    const response = await fetch(source);
-    if (!response.ok) {
-      throw new Error(`Failed to download config: ${response.status} ${response.statusText}`);
+function getLifecycleTrigger(channelId) {
+  if (channelId.startsWith("telegram-")) return "telegram";
+  if (channelId.startsWith("slack-")) return "slack";
+  return "web";
+}
+var PackAgent = class {
+  options;
+  channels = /* @__PURE__ */ new Map();
+  pendingSessionCreations = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Lazily create (or return existing) session for a channel.
+   */
+  async getOrCreateSession(channelId) {
+    const existing = this.channels.get(channelId);
+    if (existing) return existing;
+    const pendingCreation = this.pendingSessionCreations.get(channelId);
+    if (pendingCreation) return pendingCreation;
+    const createSessionPromise = (async () => {
+      const { apiKey, rootDir, provider, modelId } = this.options;
+      const authStorage = AuthStorage.inMemory({
+        [provider]: { type: "api_key", key: apiKey }
+      });
+      authStorage.setRuntimeApiKey(provider, apiKey);
+      const modelRegistry = new ModelRegistry(authStorage);
+      const model = modelRegistry.find(provider, modelId);
+      const sessionDir = path5.resolve(
+        rootDir,
+        "data",
+        "sessions",
+        channelId
+      );
+      fs5.mkdirSync(sessionDir, { recursive: true });
+      const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
+      log(`[PackAgent] Session dir: ${sessionDir}`);
+      const workspaceDir = path5.resolve(
+        rootDir,
+        "data",
+        "workspaces",
+        channelId
+      );
+      fs5.mkdirSync(workspaceDir, { recursive: true });
+      log(`[PackAgent] Workspace dir: ${workspaceDir}`);
+      const skillsPath = path5.resolve(rootDir, "skills");
+      log(`[PackAgent] Loading skills from: ${skillsPath}`);
+      const resourceLoader = new DefaultResourceLoader({
+        cwd: rootDir,
+        additionalSkillPaths: [skillsPath]
+      });
+      await resourceLoader.reload();
+      const tools = createCodingTools(workspaceDir);
+      const { session } = await createAgentSession({
+        cwd: workspaceDir,
+        authStorage,
+        modelRegistry,
+        sessionManager,
+        resourceLoader,
+        model,
+        tools
+      });
+      const channelSession = {
+        session,
+        running: false,
+        pending: Promise.resolve()
+      };
+      this.channels.set(channelId, channelSession);
+      return channelSession;
+    })();
+    this.pendingSessionCreations.set(channelId, createSessionPromise);
+    try {
+      return await createSessionPromise;
+    } finally {
+      this.pendingSessionCreations.delete(channelId);
     }
-    raw = await response.text();
-  } else {
-    const filePath = path6.resolve(source);
-    raw = fs6.readFileSync(filePath, "utf-8");
   }
-  const parsed = JSON.parse(raw);
-  validateConfigShape(parsed, source);
-  return parsed;
-}
-async function initCommand(directory, options) {
-  const workDir = directory ? path6.resolve(directory) : process.cwd();
-  if (directory) {
-    fs6.mkdirSync(workDir, { recursive: true });
+  async handleMessage(channelId, text, onEvent) {
+    const cs = await this.getOrCreateSession(channelId);
+    const run = async () => {
+      cs.running = true;
+      let turnHadVisibleOutput = false;
+      const unsubscribe = cs.session.subscribe((event) => {
+        switch (event.type) {
+          case "agent_start":
+            log("\n=== [AGENT SESSION START] ===");
+            log("System Prompt:\n", cs.session.systemPrompt);
+            log("============================\n");
+            onEvent({ type: "agent_start" });
+            break;
+          case "message_start":
+            log(`
+--- [Message Start: ${event.message?.role}] ---`);
+            if (event.message?.role === "user") {
+              log(JSON.stringify(event.message.content, null, 2));
+            }
+            onEvent({ type: "message_start", role: event.message?.role ?? "" });
+            break;
+          case "message_update":
+            if (event.assistantMessageEvent?.type === "text_delta") {
+              turnHadVisibleOutput = true;
+              write(event.assistantMessageEvent.delta);
+              onEvent({
+                type: "text_delta",
+                delta: event.assistantMessageEvent.delta
+              });
+            } else if (event.assistantMessageEvent?.type === "thinking_delta") {
+              turnHadVisibleOutput = true;
+              onEvent({
+                type: "thinking_delta",
+                delta: event.assistantMessageEvent.delta
+              });
+            }
+            break;
+          case "message_end":
+            log(`
+--- [Message End: ${event.message?.role}] ---`);
+            if (event.message?.role === "assistant") {
+              const diagnostics = getAssistantDiagnostics(event.message);
+              if (diagnostics) {
+                log(
+                  `[Assistant Diagnostics] stopReason=${diagnostics.stopReason} text=${diagnostics.hasText ? "yes" : "no"} toolCalls=${diagnostics.toolCalls}`
+                );
+                if (diagnostics.errorMessage) {
+                  log(`[Assistant Error] ${diagnostics.errorMessage}`);
+                }
+              }
+            }
+            onEvent({ type: "message_end", role: event.message?.role ?? "" });
+            break;
+          case "tool_execution_start":
+            turnHadVisibleOutput = true;
+            log(`
+>>> [Tool Start: ${event.toolName}] >>>`);
+            log("Args:", JSON.stringify(event.args, null, 2));
+            onEvent({
+              type: "tool_start",
+              toolName: event.toolName,
+              toolInput: event.args
+            });
+            break;
+          case "tool_execution_end":
+            turnHadVisibleOutput = true;
+            log(`<<< [Tool End: ${event.toolName}] <<<`);
+            log(`Error: ${event.isError ? "Yes" : "No"}`);
+            onEvent({
+              type: "tool_end",
+              toolName: event.toolName,
+              isError: event.isError,
+              result: event.result
+            });
+            break;
+          case "agent_end":
+            log("\n=== [AGENT SESSION END] ===\n");
+            onEvent({ type: "agent_end" });
+            break;
+        }
+      });
+      try {
+        await cs.session.prompt(text);
+        const lastMessage = cs.session.state.messages.at(-1);
+        const diagnostics = getAssistantDiagnostics(lastMessage);
+        if (diagnostics?.errorMessage) {
+          return {
+            stopReason: diagnostics.stopReason,
+            errorMessage: diagnostics.errorMessage
+          };
+        }
+        if (diagnostics && !diagnostics.hasText && diagnostics.toolCalls === 0 && !turnHadVisibleOutput) {
+          return {
+            stopReason: diagnostics.stopReason,
+            errorMessage: "Assistant returned no visible output. Check the server logs for details."
+          };
+        }
+        return { stopReason: diagnostics?.stopReason ?? "unknown" };
+      } finally {
+        cs.running = false;
+        unsubscribe();
+      }
+    };
+    const resultPromise = cs.pending.catch(() => void 0).then(run);
+    cs.pending = resultPromise.then(() => void 0, () => void 0);
+    return resultPromise;
   }
-  if (configExists(workDir)) {
-    const { overwrite } = await inquirer2.prompt([
-      {
-        type: "confirm",
-        name: "overwrite",
-        message: `A ${PACK_FILE} file already exists in this directory. Overwrite it?`,
-        default: false
+  async handleCommand(command, channelId) {
+    switch (command) {
+      case "new":
+      case "clear": {
+        const cs = this.channels.get(channelId);
+        if (cs) {
+          cs.session.dispose();
+          this.channels.delete(channelId);
+        }
+        const { rootDir } = this.options;
+        const sessionDir = path5.resolve(rootDir, "data", "sessions", channelId);
+        if (fs5.existsSync(sessionDir)) {
+          fs5.rmSync(sessionDir, { recursive: true, force: true });
+          log(`[PackAgent] Cleared session dir: ${sessionDir}`);
+        }
+        return {
+          success: true,
+          message: command === "new" ? "New session started." : "Session cleared."
+        };
       }
-    ]);
-    if (!overwrite) {
-      console.log(chalk4.yellow("Cancelled"));
-      return;
+      case "restart":
+        log("[PackAgent] Restart requested");
+        return this.options.lifecycleHandler.requestRestart(
+          getLifecycleTrigger(channelId)
+        );
+      case "shutdown":
+        log("[PackAgent] Shutdown requested");
+        return this.options.lifecycleHandler.requestShutdown(
+          getLifecycleTrigger(channelId)
+        );
+      default:
+        return { success: false, message: `Unknown command: ${command}` };
     }
   }
-  const config = await readConfigSource(options.config);
-  saveConfig(workDir, config);
-  console.log(chalk4.blue(`
-  Initialize ${config.name} from ${options.config}
-`));
-  installConfiguredSkills(workDir, config);
-  refreshDescriptionsAndSave(workDir, config);
-  copyRuntimeTemplate(getRuntimeDir(), workDir);
-  ensureRuntimeLaunchersExecutable(workDir);
-  if (options.bundle) {
-    await bundle(workDir);
+  abort(channelId) {
+    const cs = this.channels.get(channelId);
+    if (cs?.running) {
+      cs.session.abort?.();
+    }
   }
-  console.log(chalk4.green(`
-  ${PACK_FILE} saved
-`));
-  console.log(chalk4.green("  Runtime template expanded.\n"));
-  console.log(chalk4.green("  Initialization complete.\n"));
-  if (!options.bundle) {
-    console.log(
-      chalk4.dim("  Run npx @cremini/skillpack build to create the zip when needed\n")
-    );
+  isRunning(channelId) {
+    return this.channels.get(channelId)?.running ?? false;
   }
-}
+  dispose(channelId) {
+    const cs = this.channels.get(channelId);
+    if (cs) {
+      cs.session.dispose();
+      this.channels.delete(channelId);
+    }
+  }
+  /** Reserved: list all sessions */
+  listSessions() {
+    return [];
+  }
+  /** Reserved: restore a historical session */
+  async restoreSession(_sessionId) {
+  }
+};
 
-// src/commands/skills-cmd.ts
-import chalk5 from "chalk";
-function registerSkillsCommand(program2) {
-  const skills = program2.command("skills").description("Manage skills in the app");
-  skills.command("add <source>").description("Add a skill from a git repo, URL, or local path").option("-s, --skill <names...>", "Specify skill name(s)").action(async (source, opts) => {
-    if (!opts.skill || opts.skill.length === 0) {
-      console.log(
-        chalk5.red(
-          "Specify at least one skill name with --skill when adding a source"
-        )
-      );
-      process.exitCode = 1;
-      return;
+// src/runtime/adapters/web.ts
+import fs7 from "fs";
+import path7 from "path";
+import { WebSocketServer } from "ws";
+
+// src/runtime/config.ts
+import fs6 from "fs";
+import path6 from "path";
+var ConfigManager = class _ConfigManager {
+  static instance;
+  configData = {};
+  configPath = "";
+  constructor() {
+  }
+  static getInstance() {
+    if (!_ConfigManager.instance) {
+      _ConfigManager.instance = new _ConfigManager();
+    }
+    return _ConfigManager.instance;
+  }
+  load(rootDir) {
+    this.configPath = path6.join(rootDir, "data", "config.json");
+    if (fs6.existsSync(this.configPath)) {
+      try {
+        this.configData = JSON.parse(fs6.readFileSync(this.configPath, "utf-8"));
+        console.log("  Loaded config from data/config.json");
+      } catch (err) {
+        console.warn("  Warning: Failed to parse data/config.json:", err);
+      }
+    }
+    let { apiKey = "", provider = "openai" } = this.configData;
+    if (!apiKey) {
+      if (process.env.OPENAI_API_KEY) {
+        apiKey = process.env.OPENAI_API_KEY;
+        provider = "openai";
+      } else if (process.env.ANTHROPIC_API_KEY) {
+        apiKey = process.env.ANTHROPIC_API_KEY;
+        provider = "anthropic";
+      }
+    }
+    this.configData.apiKey = apiKey;
+    this.configData.provider = provider;
+    return this.configData;
+  }
+  getConfig() {
+    return this.configData;
+  }
+  save(rootDir, updates) {
+    const configDir = path6.join(rootDir, "data");
+    if (!this.configPath) {
+      this.configPath = path6.join(rootDir, "data", "config.json");
+    }
+    if (!fs6.existsSync(configDir)) {
+      fs6.mkdirSync(configDir, { recursive: true });
+    }
+    if (updates.apiKey !== void 0) this.configData.apiKey = updates.apiKey;
+    if (updates.provider !== void 0) this.configData.provider = updates.provider;
+    if (updates.adapters !== void 0) {
+      const merged = { ...this.configData.adapters || {} };
+      for (const [adapterKey, adapterVal] of Object.entries(updates.adapters)) {
+        if (adapterVal === null || adapterVal === void 0) {
+          delete merged[adapterKey];
+        } else {
+          merged[adapterKey] = adapterVal;
+        }
+      }
+      this.configData.adapters = merged;
     }
-    const workDir = process.cwd();
-    const config = loadConfig(workDir);
-    const requestedSkills = opts.skill.map((name) => ({
-      name: name.trim(),
-      source,
-      description: ""
-    }));
-    upsertSkills(config, requestedSkills);
-    saveConfig(workDir, config);
     try {
-      installSkills(workDir, requestedSkills);
-      refreshDescriptionsAndSave(workDir, config);
-    } catch (error) {
-      console.log(
-        chalk5.red(
-          `Skill installation failed: ${error instanceof Error ? error.message : String(error)}`
-        )
+      fs6.writeFileSync(
+        this.configPath,
+        JSON.stringify(this.configData, null, 2),
+        "utf-8"
       );
-      process.exitCode = 1;
-      return;
+    } catch (err) {
+      console.error("Failed to save config:", err);
     }
-    console.log(chalk5.green(`Installed ${requestedSkills.length} skill(s).`));
-  });
-  skills.command("remove <name>").description("Remove a skill").action((name) => {
-    removeSkill(process.cwd(), name);
+  }
+};
+var configManager = ConfigManager.getInstance();
+
+// src/runtime/adapters/web.ts
+function getPackConfig(rootDir) {
+  const raw = fs7.readFileSync(path7.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;
+}
+function getRuntimeConfigSignature(config) {
+  return JSON.stringify({
+    apiKey: config.apiKey || "",
+    provider: config.provider || "openai",
+    telegramToken: config.adapters?.telegram?.token || "",
+    slackBotToken: config.adapters?.slack?.botToken || "",
+    slackAppToken: config.adapters?.slack?.appToken || ""
   });
-  skills.command("list").description("List installed skills").action(() => {
-    const config = loadConfig(process.cwd());
-    if (config.skills.length === 0) {
-      console.log(chalk5.dim("  No skills installed"));
+}
+var WebAdapter = class {
+  name = "web";
+  wss = null;
+  agent = null;
+  async start(ctx) {
+    const { agent, server, app, rootDir, lifecycle } = ctx;
+    this.agent = agent;
+    const currentConf = configManager.getConfig();
+    let apiKey = currentConf.apiKey || "";
+    let currentProvider = currentConf.provider || "openai";
+    app.get("/api/config", (_req, res) => {
+      const config = getPackConfig(rootDir);
+      const conf = configManager.getConfig();
+      res.json({
+        name: config.name,
+        description: config.description,
+        prompts: config.prompts || [],
+        skills: config.skills || [],
+        hasApiKey: !!conf.apiKey,
+        apiKey: conf.apiKey || "",
+        provider: conf.provider || "openai",
+        adapters: conf.adapters || {},
+        runtimeControl: lifecycle.getRuntimeControl()
+      });
+    });
+    app.get("/api/skills", (_req, res) => {
+      const config = getPackConfig(rootDir);
+      res.json(config.skills || []);
+    });
+    app.post("/api/config/update", (req, res) => {
+      const { key, provider, adapters } = req.body;
+      const updates = {};
+      const beforeConfig = JSON.parse(JSON.stringify(configManager.getConfig()));
+      if (key !== void 0) {
+        updates.apiKey = key;
+        apiKey = key;
+      }
+      if (provider !== void 0) {
+        updates.provider = provider;
+        currentProvider = provider;
+      }
+      if (adapters !== void 0) {
+        updates.adapters = adapters;
+      }
+      configManager.save(rootDir, updates);
+      const newConf = configManager.getConfig();
+      const requiresRestart = getRuntimeConfigSignature(beforeConfig) !== getRuntimeConfigSignature(newConf);
+      res.json({
+        success: true,
+        provider: newConf.provider,
+        adapters: newConf.adapters,
+        requiresRestart,
+        runtimeControl: lifecycle.getRuntimeControl()
+      });
+    });
+    app.post("/api/runtime/restart", async (_req, res) => {
+      const runtimeControl = lifecycle.getRuntimeControl();
+      if (!runtimeControl.canManagedRestart) {
+        res.status(409).json({
+          success: false,
+          message: "Managed restart is unavailable for this process.",
+          runtimeControl
+        });
+        return;
+      }
+      const result = await lifecycle.requestRestart("web");
+      res.status(202).json({ ...result, runtimeControl });
+    });
+    app.delete("/api/chat", (_req, res) => {
+      res.json({ success: true });
+    });
+    app.get("/api/sessions", (_req, res) => {
+      const sessions = agent.listSessions();
+      res.json(sessions);
+    });
+    app.get("/api/sessions/:id", (_req, res) => {
+      res.status(501).json({ error: "Not implemented yet" });
+    });
+    this.wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (request, socket, head) => {
+      if (request.url?.startsWith("/api/chat")) {
+        this.wss.handleUpgrade(request, socket, head, (ws) => {
+          this.wss.emit("connection", ws, request);
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+    this.wss.on("connection", (ws, request) => {
+      const url = new URL(
+        request.url ?? "/",
+        `http://${request.headers.host || "127.0.0.1"}`
+      );
+      const _reqProvider = url.searchParams.get("provider") || currentProvider;
+      if (!apiKey) {
+        ws.send(JSON.stringify({ error: "Please set an API key first" }));
+        ws.close();
+        return;
+      }
+      const channelId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      this.handleWsConnection(ws, channelId, agent);
+    });
+    console.log("[WebAdapter] Started");
+  }
+  async stop() {
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        client.close();
+      }
+      this.wss.close();
+      this.wss = null;
+    }
+    console.log("[WebAdapter] Stopped");
+  }
+  // -------------------------------------------------------------------------
+  // WebSocket message handler
+  // -------------------------------------------------------------------------
+  handleWsConnection(ws, channelId, agent) {
+    ws.on("message", async (data) => {
+      try {
+        const payload = JSON.parse(data.toString());
+        if (!payload.text) return;
+        const text = payload.text;
+        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 }));
+          }
+          return;
+        }
+        const onEvent = (event) => {
+          if (ws.readyState !== ws.OPEN) return;
+          ws.send(JSON.stringify(event));
+        };
+        const result = await agent.handleMessage(channelId, text, onEvent);
+        if (result.errorMessage) {
+          ws.send(JSON.stringify({ error: result.errorMessage }));
+          return;
+        }
+        ws.send(JSON.stringify({ done: true }));
+      } catch (err) {
+        ws.send(JSON.stringify({ error: String(err) }));
+      }
+    });
+    ws.on("close", () => {
+      agent.dispose(channelId);
+    });
+  }
+};
+
+// src/runtime/lifecycle.ts
+var SHUTDOWN_EXIT_CODE = 64;
+var RESTART_EXIT_CODE = 75;
+var STOP_TIMEOUT_MS = 3e3;
+function detectProcessManager() {
+  return process.env.PACK_ROOT ? "wrapper" : "none";
+}
+var Lifecycle = class {
+  server;
+  exitFn;
+  processManager;
+  adapters = [];
+  stopReason = null;
+  constructor(server, exitFn = (code) => process.exit(code)) {
+    this.server = server;
+    this.exitFn = exitFn;
+    this.processManager = detectProcessManager();
+  }
+  registerAdapters(adapters) {
+    this.adapters = adapters;
+  }
+  getRuntimeControl() {
+    return {
+      canManagedRestart: this.processManager === "wrapper",
+      processManager: this.processManager
+    };
+  }
+  async requestRestart(trigger) {
+    return this.requestStop("restart", trigger);
+  }
+  async requestShutdown(trigger) {
+    return this.requestStop("shutdown", trigger);
+  }
+  async requestStop(reason, trigger) {
+    if (this.stopReason) {
+      const message = this.stopReason === "restart" ? "Restart already in progress." : "Shutdown already in progress.";
+      return { success: true, message };
+    }
+    this.stopReason = reason;
+    console.log(`[Lifecycle] ${reason} requested via ${trigger}`);
+    setTimeout(() => {
+      void this.gracefulStopAndExit(reason);
+    }, 50);
+    return {
+      success: true,
+      message: reason === "restart" ? "Restarting..." : "Shutting down..."
+    };
+  }
+  async gracefulStopAndExit(reason) {
+    try {
+      await Promise.race([
+        this.gracefulStop(),
+        new Promise((resolve) => {
+          setTimeout(() => {
+            console.warn("[Lifecycle] Graceful stop timed out, forcing exit.");
+            resolve();
+          }, STOP_TIMEOUT_MS);
+        })
+      ]);
+    } catch (err) {
+      console.error("[Lifecycle] Error during graceful stop:", err);
+    }
+    const exitCode = reason === "restart" ? RESTART_EXIT_CODE : SHUTDOWN_EXIT_CODE;
+    this.exitFn(exitCode);
+  }
+  async gracefulStop() {
+    for (const adapter of [...this.adapters].reverse()) {
+      try {
+        await adapter.stop();
+      } catch (err) {
+        console.error(`[Lifecycle] Failed to stop ${adapter.name}:`, err);
+      }
+    }
+    if (!this.server.listening) {
       return;
     }
-    console.log(chalk5.blue(`
-  ${config.name} Skills:
-`));
-    for (const skill of config.skills) {
-      console.log(`  ${chalk5.green("\u25CF")} ${chalk5.bold(skill.name)}`);
-      if (skill.description) {
-        console.log(`    ${chalk5.dim(skill.description)}`);
+    await new Promise((resolve) => {
+      this.server.close(() => resolve());
+    });
+  }
+};
+
+// src/runtime/server.ts
+var __dirname = path8.dirname(fileURLToPath(import.meta.url));
+async function startServer(options) {
+  const {
+    rootDir,
+    host = process.env.HOST || "127.0.0.1",
+    port = Number(process.env.PORT) || 26313,
+    firstRun = true
+  } = options;
+  const dataConfig = configManager.load(rootDir);
+  const apiKey = dataConfig.apiKey || "";
+  const provider = dataConfig.provider || "openai";
+  const modelId = provider === "anthropic" ? "claude-opus-4-6" : "gpt-5.4";
+  const packageRoot = path8.resolve(__dirname, "..");
+  const webDir = fs8.existsSync(path8.join(rootDir, "web")) ? path8.join(rootDir, "web") : path8.join(packageRoot, "web");
+  const app = express();
+  app.use(express.json());
+  app.use(express.static(webDir));
+  const server = createServer(app);
+  const lifecycle = new Lifecycle(server);
+  const agent = new PackAgent({
+    apiKey,
+    rootDir,
+    provider,
+    modelId,
+    lifecycleHandler: lifecycle
+  });
+  const adapters = [];
+  const webAdapter = new WebAdapter();
+  await webAdapter.start({ agent, server, app, rootDir, lifecycle });
+  adapters.push(webAdapter);
+  if (dataConfig.adapters?.telegram?.token) {
+    try {
+      const { TelegramAdapter: TelegramAdapter2 } = await Promise.resolve().then(() => (init_telegram(), telegram_exports));
+      const telegramAdapter = new TelegramAdapter2({
+        token: dataConfig.adapters.telegram.token
+      });
+      await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
+      adapters.push(telegramAdapter);
+    } catch (err) {
+      console.error("[Telegram] Failed to start:", err);
+    }
+  }
+  const slackConfig = dataConfig.adapters?.slack;
+  if (slackConfig?.botToken || slackConfig?.appToken) {
+    if (!slackConfig.botToken || !slackConfig.appToken) {
+      console.warn(
+        "[Slack] Skipped: both adapters.slack.botToken and adapters.slack.appToken are required."
+      );
+    } else {
+      try {
+        const { SlackAdapter: SlackAdapter2 } = await Promise.resolve().then(() => (init_slack(), slack_exports));
+        const slackAdapter = new SlackAdapter2({
+          botToken: slackConfig.botToken,
+          appToken: slackConfig.appToken
+        });
+        await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
+        adapters.push(slackAdapter);
+      } catch (err) {
+        console.error("[Slack] Failed to start:", err);
       }
     }
-    console.log();
+  }
+  lifecycle.registerAdapters(adapters);
+  server.once("listening", () => {
+    const address = server.address();
+    const actualPort = typeof address === "string" ? address : address?.port;
+    const url = `http://${host}:${actualPort}`;
+    console.log(`
+  Skills Pack Server`);
+    console.log(`  Running at ${url}
+`);
+    if (firstRun) {
+      const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
+      exec(cmd, (err) => {
+        if (err) console.warn(`  Could not open browser: ${err.message}`);
+      });
+    }
+  });
+  process.on("SIGINT", () => {
+    void lifecycle.requestShutdown("signal");
+  });
+  process.on("SIGTERM", () => {
+    void lifecycle.requestShutdown("signal");
+  });
+  await new Promise((resolve, reject) => {
+    function tryListen(listenPort) {
+      server.listen(listenPort, host);
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          console.log(`  Port ${listenPort} is in use, trying ${listenPort + 1}...`);
+          server.close();
+          tryListen(listenPort + 1);
+        } else {
+          reject(err);
+        }
+      });
+      server.once("listening", () => resolve());
+    }
+    tryListen(port);
+  });
+  await new Promise(() => {
   });
 }
 
-// src/commands/prompts-cmd.ts
-import chalk7 from "chalk";
-
-// src/core/prompts.ts
-import chalk6 from "chalk";
-function addPrompt(workDir, text) {
-  const config = loadConfig(workDir);
-  config.prompts.push(text);
-  saveConfig(workDir, config);
-  console.log(chalk6.green(`Added Prompt #${config.prompts.length}`));
+// src/commands/run.ts
+function findMissingSkills(workDir, config) {
+  const installed = scanInstalledSkills(workDir);
+  const installedNames = new Set(
+    installed.map((s) => s.name.trim().toLowerCase())
+  );
+  return config.skills.filter((skill) => {
+    if (skill.source.startsWith("./skills")) return false;
+    return !installedNames.has(skill.name.trim().toLowerCase());
+  });
 }
-function removePrompt(workDir, index) {
-  const config = loadConfig(workDir);
-  const idx = index - 1;
-  if (idx < 0 || idx >= config.prompts.length) {
-    console.log(
-      chalk6.yellow(`Invalid index: ${index} (${config.prompts.length} total)`)
-    );
-    return false;
-  }
-  const removed = config.prompts.splice(idx, 1)[0];
-  saveConfig(workDir, config);
-  console.log(
-    chalk6.green(`Removed Prompt #${index}: "${removed.substring(0, 50)}..."`)
+function copyStartTemplates2(workDir) {
+  const templateDir = path9.resolve(
+    new URL("../templates", import.meta.url).pathname
   );
-  return true;
+  for (const file of ["start.sh", "start.bat"]) {
+    const src = path9.join(templateDir, file);
+    const dest = path9.join(workDir, file);
+    if (fs9.existsSync(src)) {
+      fs9.copyFileSync(src, dest);
+      if (file === "start.sh") {
+        fs9.chmodSync(dest, 493);
+      }
+    }
+  }
 }
-function listPrompts(workDir) {
+async function runCommand(directory) {
+  const workDir = directory ? path9.resolve(directory) : process.cwd();
+  fs9.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([
+      {
+        type: "input",
+        name: "name",
+        message: "App name:",
+        validate: (v) => v.trim() ? true : "Name is required"
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Description:",
+        default: "A skill App, powered by SkillPack.sh"
+      }
+    ]);
+    const config2 = createDefaultConfig(name.trim(), description.trim());
+    saveConfig(workDir, config2);
+    copyStartTemplates2(workDir);
+    console.log(chalk4.green(`
+  skillpack.json created
+`));
+  }
   const config = loadConfig(workDir);
-  return config.prompts;
-}
-
-// src/commands/prompts-cmd.ts
-function registerPromptsCommand(program2) {
-  const prompts = program2.command("prompts").description("Manage prompts");
-  prompts.command("add <text>").description("Add a prompt").action((text) => {
-    addPrompt(process.cwd(), text);
-  });
-  prompts.command("remove <index>").description("Remove a prompt by number, starting from 1").action((index) => {
-    const num = parseInt(index, 10);
-    if (isNaN(num)) {
-      console.log(chalk7.red("Enter a valid numeric index"));
-      return;
-    }
-    removePrompt(process.cwd(), num);
-  });
-  prompts.command("list").description("List all prompts").action(() => {
-    const prompts2 = listPrompts(process.cwd());
-    if (prompts2.length === 0) {
-      console.log(chalk7.dim("  No prompts yet"));
-      return;
+  const missing = findMissingSkills(workDir, config);
+  if (missing.length > 0) {
+    console.log(chalk4.blue(`
+  Installing ${missing.length} missing skill(s)...
+`));
+    try {
+      installSkills(workDir, missing);
+    } catch (err) {
+      console.warn(chalk4.yellow(`  Warning: Some skills could not be installed: ${err}`));
     }
-    console.log(chalk7.blue("\n  Prompts:\n"));
-    prompts2.forEach((u, i) => {
-      const marker = i === 0 ? chalk7.green("\u2605") : chalk7.dim("\u25CF");
-      const label = i === 0 ? chalk7.dim(" (default)") : "";
-      const display = u.length > 80 ? u.substring(0, 80) + "..." : u;
-      console.log(`  ${marker} #${i + 1}${label} ${display}`);
-    });
-    console.log();
-  });
+  }
+  await startServer({ rootDir: workDir, firstRun: true });
 }
 
 // src/cli.ts
-import fs7 from "fs";
+import fs10 from "fs";
 var packageJson = JSON.parse(
-  fs7.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs10.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);
-program.command("create [directory]").description("Create a skills pack interactively").action(async (directory) => {
-  await createCommand(directory);
+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);
 });
-program.command("init [directory]").description(
-  "Initialize a skills pack from a local config file or URL and expand runtime files"
-).requiredOption("--config <path-or-url>", "Path or URL to a skillpack.json file").option("--bundle", "Bundle as a zip after initialization").action(
-  async (directory, options) => {
-    await initCommand(directory, options);
-  }
-);
-registerSkillsCommand(program);
-registerPromptsCommand(program);
-program.command("build").description("Package the current pack as a zip file").action(async () => {
+program.command("run [directory]").description("Start the SkillPack runtime server").option("--port <port>", "Port to listen on").option("--host <host>", "Host to bind to").action(async (directory, options) => {
+  if (options?.port) process.env.PORT = options.port;
+  if (options?.host) process.env.HOST = options.host;
+  await runCommand(directory);
+});
+program.command("zip").description("Package the current pack as a zip file (skillpack.json + skills/ + start scripts)").action(async () => {
   try {
-    await bundle(process.cwd());
+    await zipCommand(process.cwd());
   } catch (err) {
-    console.error(chalk8.red(`Packaging failed: ${err}`));
+    console.error(chalk5.red(`Packaging failed: ${err}`));
     process.exit(1);
   }
 });