@cremini/skillpack 1.1.7 → 1.1.8

package/README.md

@@ -6,20 +6,23 @@ Skillpack helps teams turn AI skills into trusted local agents that can run in t
 
 [skillpack.sh](https://skillpack.sh) is an open-source way to package AI skills into runnable local agents. If skills and tools are like LEGO pieces, a SkillPack is the finished product that assembles them into a complete solution.
 Instead of juggling prompts, scripts, docs, and one-off automations, Skillpack gives you a simple way to:
+
 - package AI skills into reusable agents
 - run them locally
 - keep sensitive data in your own environment
 - use agents from tools your team already uses, like Slack and Telegram
 
-Skillpack is built for teams that want AI Agents to be deployable, trusted, and easy to use. 
+Skillpack is built for teams that want AI Agents to be deployable, trusted, and easy to use.
 
 ---
 
 ## Quick Start
 
-### 1. Run a skillpack 
+### 1. Run a skillpack
+
 1. Download the example [Company Deep Research](https://github.com/FinpeakInc/downloads/releases/download/v.0.0.1/Company-Deep-Research.zip)
 2. Unzip it and Run ./start.sh on Mac OS, and double click start.bat on Windows (see below), the server starts and opens http://127.0.0.1:26313 in your browser
+
 ```bash
 # macOS / Linux
 ./start.sh
@@ -27,10 +30,10 @@ Skillpack is built for teams that want AI Agents to be deployable, trusted, and
 # Windows
 start.bat
 ```
+
 3. Enter an LLM API key (OpenAI or Claude API Key) in the left menu, use the prompt example to try it!
 4. (Optional) Refer to the instructions **Slack/Telegram Integrations** below to integrate with Slack and Telegram.
 
-
 ### 2. Create a new skillpack
 
 ```bash
@@ -51,7 +54,7 @@ Step by step:
 npx @cremini/skillpack create --config ./skillpack.json
 
 # From a remote URL (no directory = current directory)
-npx @cremini/skillpack create comic-explainer --config https://raw.githubusercontent.com/CreminiAI/skillpack/refs/heads/main/examples/comic_explainer.json
+npx @cremini/skillpack create comic-explainer --config https://raw.githubusercontent.com/CreminiAI/skillpack/refs/heads/main/examples/comic-explainer.json
 ```
 
 Ready to run using "Run a skillpack" part
@@ -105,10 +108,12 @@ The start scripts use `npx @cremini/skillpack run .` so Node.js is the only prer
 **Telegram configuration**: requires `Bot Token`
 
 ### Slack App Setup and how to get `App Token` and `Bot Token`
+
 1. Create a new Slack app at https://api.slack.com/apps
 2. Enable Socket Mode (Settings → Socket Mode → Enable)
 3. Generate an App-Level Token with `connections:write` scope. This is **`App Token`**
 4. Add Bot Token Scopes (OAuth & Permissions):
+
 - `app_mentions:read`
 - `channels:history`
 - `channels:read`
@@ -123,32 +128,35 @@ The start scripts use `npx @cremini/skillpack run .` so Node.js is the only prer
 - `users:read`
 
 5. Subscribe to Bot Events (Event Subscriptions):
+
 - `app_mention`
 - `message.channels`
 - `message.groups`
 - `message.im`
 
 6. Enable Direct Messages (App Home):
-Go to App Home in the left sidebar
-Under Show Tabs, enable the Messages Tab
-Check Allow users to send Slash commands and messages from the messages tab
+   Go to App Home in the left sidebar
+   Under Show Tabs, enable the Messages Tab
+   Check Allow users to send Slash commands and messages from the messages tab
 
 7. Install the app to your workspace. Get the Bot User OAuth Token. This is **`Bot Token`**
 8. Add the app to any channels where you want the agent to operate (it'll only see messages in channels it's added to)
 9. On the SkillPack buit-in UI http://127.0.0.1:26313, Tap "Connect to Chat App" button and Enter the **`Bot Token`** and **`App Token`**, Save
 
 ### Telegram Setup and how to get `Bot Token`
+
 1. **Open Telegram** and search for the official account **`@BotFather`** (it will have a blue verified checkmark).
 2. **Start a chat** by tapping "Start" or sending the `/start` command.
 3. **Send the command** `/newbot` to the BotFather.
 4. **Follow the prompts** to choose a display name and a unique username for your bot. The username must end with the word "bot" (e.g., `MyHelperBot` or `My_Helper_bot`).
-5. **Receive the token**. Once the bot is successfully created, the BotFather will provide you with a message containing your unique API token. 
-The token will look like a long string of numbers and letters, formatted as `123456789:AABBCCddEeff.... `
+5. **Receive the token**. Once the bot is successfully created, the BotFather will provide you with a message containing your unique API token.
+   The token will look like a long string of numbers and letters, formatted as `123456789:AABBCCddEeff.... `
 6. On the SkillPack buit-in UI http://127.0.0.1:26313, Tap "Connect to Chat App" button and Enter the **`Bot Token`**, Save
 
 ### (Optional) Put tokens into data/config.json if you don't use Web UI
+
 Or Once you have telegram or slack tokens, you can also configure them in `data/config.json` (created at runtime, not included in the zip):
-The runtime supports **Slack** and **Telegram** in addition to the built-in web UI. 
+The runtime supports **Slack** and **Telegram** in addition to the built-in web UI.
 
 ```json
 {
@@ -168,7 +176,7 @@ The runtime supports **Slack** and **Telegram** in addition to the built-in web
 
 ## Example Use Cases
 
-The main use case is to **run local agents on your computer and integrate them with Slack or Telegram** so they can work for you and your team — operating entirely on your machine to keep all team data local and private, while continuously improving by learning new skills. Each SkillPack organizes skills around a well-defined job — for example: research a company by gathering information from multiple sources and produce a PowerPoint presentation from the findings. 
+The main use case is to **run local agents on your computer and integrate them with Slack or Telegram** so they can work for you and your team — operating entirely on your machine to keep all team data local and private, while continuously improving by learning new skills. Each SkillPack organizes skills around a well-defined job — for example: research a company by gathering information from multiple sources and produce a PowerPoint presentation from the findings.
 
 Download [Company Deep Research](https://github.com/FinpeakInc/downloads/releases/download/v.0.0.1/Company-Deep-Research.zip) and try it! More examples can be found at [skillpack.sh](https://skillpack.sh)
 

package/dist/cli.js

@@ -85,6 +85,91 @@ var init_attachment_utils = __esm({
   }
 });
 
+// src/runtime/config.ts
+import fs8 from "fs";
+import path8 from "path";
+var ConfigManager, configManager;
+var init_config = __esm({
+  "src/runtime/config.ts"() {
+    "use strict";
+    ConfigManager = class _ConfigManager {
+      static instance;
+      configData = {};
+      configPath = "";
+      constructor() {
+      }
+      static getInstance() {
+        if (!_ConfigManager.instance) {
+          _ConfigManager.instance = new _ConfigManager();
+        }
+        return _ConfigManager.instance;
+      }
+      load(rootDir) {
+        this.configPath = path8.join(rootDir, "data", "config.json");
+        if (fs8.existsSync(this.configPath)) {
+          try {
+            this.configData = JSON.parse(fs8.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 = path8.join(rootDir, "data");
+        if (!this.configPath) {
+          this.configPath = path8.join(rootDir, "data", "config.json");
+        }
+        if (!fs8.existsSync(configDir)) {
+          fs8.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;
+        }
+        if (updates.scheduledJobs !== void 0) {
+          this.configData.scheduledJobs = updates.scheduledJobs;
+        }
+        try {
+          fs8.writeFileSync(
+            this.configPath,
+            JSON.stringify(this.configData, null, 2),
+            "utf-8"
+          );
+        } catch (err) {
+          console.error("Failed to save config:", err);
+        }
+      }
+    };
+    configManager = ConfigManager.getInstance();
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -256,6 +341,21 @@ var init_telegram = __esm({
         console.log("[TelegramAdapter] Stopped");
       }
       // -------------------------------------------------------------------------
+      // MessageSender – proactive message sending
+      // -------------------------------------------------------------------------
+      /**
+       * Public method: send a message to a specific Telegram chat.
+       * channelId format: telegram-<chatId>
+       */
+      async sendMessage(channelId, text) {
+        if (!this.bot) throw new Error("[Telegram] Bot not initialized");
+        const chatId = Number(channelId.replace("telegram-", ""));
+        if (isNaN(chatId)) {
+          throw new Error(`[Telegram] Invalid channelId: ${channelId}`);
+        }
+        await this.sendLongMessage(chatId, text);
+      }
+      // -------------------------------------------------------------------------
       // Message handler
       // -------------------------------------------------------------------------
       async handleTelegramMessage(msg) {
@@ -578,6 +678,20 @@ var init_slack = __esm({
         console.log("[SlackAdapter] Stopped");
       }
       // -------------------------------------------------------------------------
+      // MessageSender – proactive message sending
+      // -------------------------------------------------------------------------
+      /**
+       * Public method: send a message to a specific Slack channel/DM.
+       * channelId formats:
+       *   - slack-dm-<teamId>-<channelId>
+       *   - slack-thread-<teamId>-<channel>-<threadTs>
+       */
+      async sendMessage(channelId, text) {
+        if (!this.app) throw new Error("[Slack] App not initialized");
+        const route = this.parseChannelId(channelId);
+        await this.sendLongMessage(this.app.client, route, text);
+      }
+      // -------------------------------------------------------------------------
       // Listener registration
       // -------------------------------------------------------------------------
       registerListeners(app) {
@@ -916,6 +1030,30 @@ var init_slack = __esm({
       escapeRegExp(value) {
         return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       }
+      /**
+       * Parse a skillpack channelId into a SlackRoute.
+       * Supports:
+       *   slack-dm-<teamId>-<channelId>       → { channel: <channelId> }
+       *   slack-thread-<teamId>-<ch>-<ts>     → { channel: <ch>, threadTs: <ts> }
+       */
+      parseChannelId(channelId) {
+        if (channelId.startsWith("slack-thread-")) {
+          const rest = channelId.replace("slack-thread-", "");
+          const parts = rest.split("-");
+          if (parts.length >= 3) {
+            const threadTs = parts.slice(2).join("-");
+            return { channel: parts[1], threadTs };
+          }
+        }
+        if (channelId.startsWith("slack-dm-")) {
+          const rest = channelId.replace("slack-dm-", "");
+          const parts = rest.split("-");
+          if (parts.length >= 2) {
+            return { channel: parts.slice(1).join("-") };
+          }
+        }
+        return { channel: channelId };
+      }
       // -------------------------------------------------------------------------
       // Attachment extraction & sending
       // -------------------------------------------------------------------------
@@ -981,6 +1119,357 @@ 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, {
+  SchedulerAdapter: () => SchedulerAdapter
+});
+import cron from "node-cron";
+function isValidTimezone(tz) {
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidJobName(name) {
+  return VALID_JOB_NAME.test(name) && name.length <= 64;
+}
+var VALID_JOB_NAME, SchedulerAdapter;
+var init_scheduler = __esm({
+  "src/runtime/adapters/scheduler.ts"() {
+    "use strict";
+    init_config();
+    VALID_JOB_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+    SchedulerAdapter = class {
+      name = "scheduler";
+      agent;
+      rootDir = "";
+      notifyFn = async () => {
+      };
+      jobs = /* @__PURE__ */ new Map();
+      async start(ctx) {
+        this.agent = ctx.agent;
+        this.rootDir = ctx.rootDir;
+        this.notifyFn = ctx.notify || (async () => {
+        });
+        const config = configManager.getConfig();
+        const jobConfigs = config.scheduledJobs || [];
+        let scheduledCount = 0;
+        let disabledCount = 0;
+        for (const jc of jobConfigs) {
+          const result = this.registerJob(jc);
+          if (result.registered) {
+            if (jc.enabled === false) {
+              disabledCount++;
+            } else {
+              scheduledCount++;
+            }
+          }
+        }
+        const parts = [];
+        if (scheduledCount > 0) parts.push(`${scheduledCount} active`);
+        if (disabledCount > 0) parts.push(`${disabledCount} disabled`);
+        if (parts.length > 0) {
+          console.log(`[SchedulerAdapter] Started with ${parts.join(", ")} job(s)`);
+        } else {
+          console.log("[SchedulerAdapter] Started (no jobs configured)");
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Core: register a job into the managed map
+      // -------------------------------------------------------------------------
+      /**
+       * Register a job: validate, create cron task (if enabled), store in map.
+       * Does NOT persist – callers decide when to persist.
+       */
+      registerJob(jobConfig) {
+        if (!isValidJobName(jobConfig.name)) {
+          const msg = `[Scheduler] Invalid job name "${jobConfig.name}": must match ${VALID_JOB_NAME} and be \u226464 chars`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        if (!cron.validate(jobConfig.cron)) {
+          const msg = `[Scheduler] Invalid cron expression for job "${jobConfig.name}": ${jobConfig.cron}`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        if (jobConfig.timezone && !isValidTimezone(jobConfig.timezone)) {
+          const msg = `[Scheduler] Invalid timezone for job "${jobConfig.name}": ${jobConfig.timezone}`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        this.removeFromMap(jobConfig.name);
+        let task = null;
+        if (jobConfig.enabled !== false) {
+          task = cron.schedule(
+            jobConfig.cron,
+            () => {
+              void this.runJob(jobConfig);
+            },
+            {
+              timezone: jobConfig.timezone
+            }
+          );
+          console.log(
+            `[Scheduler] Job "${jobConfig.name}" scheduled: ${jobConfig.cron}${jobConfig.timezone ? ` (${jobConfig.timezone})` : ""}`
+          );
+        } else {
+          console.log(
+            `[Scheduler] Job "${jobConfig.name}" registered (disabled)`
+          );
+        }
+        this.jobs.set(jobConfig.name, {
+          config: jobConfig,
+          task,
+          running: false,
+          notifyFailed: false
+        });
+        return { registered: true, message: "" };
+      }
+      // -------------------------------------------------------------------------
+      // Job execution
+      // -------------------------------------------------------------------------
+      /**
+       * Execute a scheduled job: call agent.handleMessage and push results.
+       * Returns { text, notifyFailed } so callers can produce accurate status.
+       */
+      async runJob(jobConfig) {
+        const channelId = `scheduler-${jobConfig.name}`;
+        const job = this.jobs.get(jobConfig.name);
+        if (job?.running) {
+          console.warn(
+            `[Scheduler] Job "${jobConfig.name}" is already running, skipping this trigger`
+          );
+          return { text: "", notifyFailed: false };
+        }
+        if (job) job.running = true;
+        console.log(`[Scheduler] Running job "${jobConfig.name}"`);
+        let fullText = "";
+        let agentFailed = false;
+        const pendingFiles = [];
+        const onEvent = (event) => {
+          if (event.type === "text_delta") fullText += event.delta;
+          if (event.type === "file_output") {
+            pendingFiles.push({
+              filePath: event.filePath,
+              caption: event.caption
+            });
+          }
+        };
+        try {
+          const result = await this.agent.handleMessage(
+            channelId,
+            jobConfig.prompt,
+            onEvent
+          );
+          if (result.errorMessage) {
+            fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u6267\u884C\u5931\u8D25\uFF1A${result.errorMessage}`;
+            agentFailed = true;
+            if (job) job.lastError = result.errorMessage;
+          } else {
+            if (job) job.lastError = void 0;
+          }
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u5F02\u5E38\uFF1A${errorMsg}`;
+          agentFailed = true;
+          if (job) job.lastError = errorMsg;
+        }
+        if (job) {
+          job.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+          job.lastResult = fullText.slice(0, 200);
+        }
+        let notifyFailed = false;
+        if (fullText.trim()) {
+          try {
+            await this.notifyFn(
+              jobConfig.notify.adapter,
+              jobConfig.notify.channelId,
+              fullText
+            );
+          } catch (err) {
+            notifyFailed = true;
+            const notifyErr = err instanceof Error ? err.message : String(err);
+            console.error(
+              `[Scheduler] Failed to notify for job "${jobConfig.name}":`,
+              err
+            );
+            if (job) {
+              job.lastError = agentFailed ? `${job.lastError}; Notify also failed: ${notifyErr}` : `Notify failed: ${notifyErr}`;
+            }
+          }
+        }
+        if (job) {
+          job.running = false;
+          job.notifyFailed = notifyFailed;
+        }
+        return { text: fullText, notifyFailed };
+      }
+      // -------------------------------------------------------------------------
+      // Dynamic management API
+      // -------------------------------------------------------------------------
+      /**
+       * Add a new job, persist to config.json.
+       */
+      addJob(jobConfig) {
+        if (this.jobs.has(jobConfig.name)) {
+          return {
+            success: false,
+            message: `Job "${jobConfig.name}" already exists. Remove it first.`
+          };
+        }
+        const result = this.registerJob(jobConfig);
+        if (!result.registered) {
+          return { success: false, message: result.message };
+        }
+        this.persistJobs();
+        const enabled = jobConfig.enabled !== false;
+        return {
+          success: true,
+          message: enabled ? `Job "${jobConfig.name}" created and scheduled.` : `Job "${jobConfig.name}" created (disabled).`
+        };
+      }
+      /**
+       * Remove a job and persist to config.json.
+       */
+      removeJob(name) {
+        if (!this.jobs.has(name)) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        this.removeFromMap(name);
+        this.persistJobs();
+        return { success: true, message: `Job "${name}" removed.` };
+      }
+      /**
+       * Enable or disable a job and persist.
+       */
+      setEnabled(name, enabled) {
+        const job = this.jobs.get(name);
+        if (!job) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        job.config.enabled = enabled;
+        if (enabled && !job.task) {
+          job.task = cron.schedule(
+            job.config.cron,
+            () => {
+              void this.runJob(job.config);
+            },
+            {
+              timezone: job.config.timezone
+            }
+          );
+        } else if (enabled && job.task) {
+          job.task.start();
+        } else if (!enabled && job.task) {
+          job.task.stop();
+        }
+        this.persistJobs();
+        return {
+          success: true,
+          message: `Job "${name}" ${enabled ? "enabled" : "disabled"}.`
+        };
+      }
+      /**
+       * Manually trigger a job (runs immediately, ignoring cron schedule).
+       */
+      async triggerJob(name) {
+        const job = this.jobs.get(name);
+        if (!job) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        const { text, notifyFailed } = await this.runJob(job.config);
+        if (!text) {
+          return {
+            success: true,
+            message: `Job "${name}" triggered but produced no output.`
+          };
+        }
+        if (notifyFailed) {
+          return {
+            success: true,
+            message: `Job "${name}" executed, but notification to ${job.config.notify.adapter} failed. Check logs.`
+          };
+        }
+        return {
+          success: true,
+          message: `Job "${name}" triggered. Result sent to ${job.config.notify.adapter}.`
+        };
+      }
+      /**
+       * List all jobs with their current status.
+       */
+      listJobs() {
+        const result = [];
+        for (const [, job] of this.jobs) {
+          result.push({
+            name: job.config.name,
+            cron: job.config.cron,
+            prompt: job.config.prompt,
+            notify: job.config.notify,
+            enabled: job.config.enabled !== false,
+            timezone: job.config.timezone,
+            lastRunAt: job.lastRunAt,
+            lastError: job.lastError,
+            running: job.running,
+            notifyFailed: job.notifyFailed
+          });
+        }
+        return result;
+      }
+      // -------------------------------------------------------------------------
+      // Internal helpers
+      // -------------------------------------------------------------------------
+      /**
+       * Stop the cron task and remove a job from the map (does NOT persist).
+       */
+      removeFromMap(name) {
+        const existing = this.jobs.get(name);
+        if (existing) {
+          existing.task?.stop();
+          this.jobs.delete(name);
+        }
+      }
+      /**
+       * Persist all current jobs to data/config.json.
+       */
+      persistJobs() {
+        const configs = [];
+        for (const [, job] of this.jobs) {
+          configs.push(job.config);
+        }
+        configManager.save(this.rootDir, { scheduledJobs: configs });
+      }
+      // -------------------------------------------------------------------------
+      // Lifecycle
+      // -------------------------------------------------------------------------
+      async stop() {
+        for (const [, job] of this.jobs) {
+          job.task?.stop();
+        }
+        this.jobs.clear();
+        console.log("[SchedulerAdapter] All jobs stopped.");
+      }
+    };
+  }
+});
+
 // src/cli.ts
 import { Command } from "commander";
 import chalk5 from "chalk";
@@ -4268,6 +4757,169 @@ function createSendFileTool(fileOutputCallbackRef) {
   };
 }
 
+// src/runtime/tools/manage-schedule-tool.ts
+var ManageScheduleParams = Type.Object({
+  action: Type.Union(
+    [
+      Type.Literal("add"),
+      Type.Literal("list"),
+      Type.Literal("remove"),
+      Type.Literal("trigger"),
+      Type.Literal("enable"),
+      Type.Literal("disable")
+    ],
+    { description: "The action to perform." }
+  ),
+  name: Type.Optional(
+    Type.String({
+      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
+    })
+  ),
+  cron: Type.Optional(
+    Type.String({
+      description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
+    })
+  ),
+  prompt: Type.Optional(
+    Type.String({
+      description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
+    })
+  ),
+  notifyAdapter: Type.Optional(
+    Type.String({
+      description: "Target adapter name for result notification: 'telegram' or 'slack'. Required for add."
+    })
+  ),
+  notifyChannelId: Type.Optional(
+    Type.String({
+      description: "Target channelId for result notification (e.g. 'telegram-123456'). Required for add."
+    })
+  ),
+  timezone: Type.Optional(
+    Type.String({
+      description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
+    })
+  )
+});
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
+}
+function createManageScheduleTool(schedulerRef, _rootDirRef) {
+  return {
+    name: "manage_scheduled_task",
+    label: "Manage Scheduled Task",
+    description: [
+      "Manage scheduled tasks (cron jobs) that automatically execute prompts and push results to IM channels.",
+      "",
+      "Actions:",
+      "- add: Create a new scheduled task. Requires: name, cron, prompt, notifyAdapter, notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
+      "- list: List all scheduled tasks with their status.",
+      "- remove: Remove a scheduled task by name.",
+      "- trigger: Manually trigger a scheduled task by name (runs immediately).",
+      "- enable: Enable a disabled scheduled task.",
+      "- disable: Disable a scheduled task without removing it.",
+      "",
+      "Cron expression format: '* * * * *' (minute hour day month weekday)",
+      "Examples:",
+      "  '0 9 * * 1-5'  = every weekday at 9:00 AM",
+      "  '0 18 * * 5'   = every Friday at 6:00 PM",
+      "  '*/30 * * * *'  = every 30 minutes",
+      "",
+      "notifyAdapter: 'telegram' or 'slack'",
+      "notifyChannelId: the channel ID where result will be sent (e.g. 'telegram-123456')"
+    ].join("\n"),
+    parameters: ManageScheduleParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const scheduler = schedulerRef.current;
+      if (!scheduler) {
+        return textResult(
+          "Error: Scheduler is not available. The scheduled task system may not be initialized."
+        );
+      }
+      switch (params.action) {
+        case "list": {
+          const jobs = scheduler.listJobs();
+          if (jobs.length === 0) {
+            return textResult("No scheduled tasks configured.");
+          }
+          const lines = jobs.map(
+            (j) => `- **${j.name}**: \`${j.cron}\` \u2192 ${j.notify.adapter}:${j.notify.channelId} [${j.enabled ? "enabled" : "disabled"}]${j.running ? " (running)" : ""}${j.lastRunAt ? ` (last: ${j.lastRunAt})` : ""}`
+          );
+          return textResult(
+            `Scheduled tasks (${jobs.length}):
+${lines.join("\n")}`
+          );
+        }
+        case "add": {
+          if (!params.name || !params.cron || !params.prompt) {
+            return textResult(
+              "Error: 'name', 'cron', and 'prompt' are required for adding a task."
+            );
+          }
+          if (!params.notifyAdapter || !params.notifyChannelId) {
+            return textResult(
+              "Error: 'notifyAdapter' and 'notifyChannelId' are required for adding a task."
+            );
+          }
+          const jobConfig = {
+            name: params.name,
+            cron: params.cron,
+            prompt: params.prompt,
+            notify: {
+              adapter: params.notifyAdapter,
+              channelId: params.notifyChannelId
+            },
+            enabled: true,
+            timezone: params.timezone
+          };
+          const result = scheduler.addJob(jobConfig);
+          return textResult(result.message);
+        }
+        case "remove": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for removing a task."
+            );
+          }
+          const result = scheduler.removeJob(params.name);
+          return textResult(result.message);
+        }
+        case "trigger": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for triggering a task."
+            );
+          }
+          const result = await scheduler.triggerJob(params.name);
+          return textResult(result.message);
+        }
+        case "enable": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for enabling a task."
+            );
+          }
+          const result = scheduler.setEnabled(params.name, true);
+          return textResult(result.message);
+        }
+        case "disable": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for disabling a task."
+            );
+          }
+          const result = scheduler.setEnabled(params.name, false);
+          return textResult(result.message);
+        }
+        default:
+          return textResult(
+            `Error: Unknown action '${params.action}'. Use: add, list, remove, trigger, enable, disable.`
+          );
+      }
+    }
+  };
+}
+
 // src/runtime/agent.ts
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
@@ -4298,8 +4950,22 @@ var PackAgent = class {
     current: null
   };
   sendFileToolDef = createSendFileTool(this.fileOutputCallbackRef);
+  schedulerRef = { current: null };
+  rootDirRef;
+  scheduleToolDef;
   constructor(options) {
     this.options = options;
+    this.rootDirRef = { current: options.rootDir };
+    this.scheduleToolDef = createManageScheduleTool(
+      this.schedulerRef,
+      this.rootDirRef
+    );
+  }
+  /**
+   * Inject scheduler reference (called by server.ts after adapter init).
+   */
+  setScheduler(scheduler) {
+    this.schedulerRef.current = scheduler;
   }
   /**
    * Lazily create (or return existing) session for a channel.
@@ -4350,7 +5016,7 @@ var PackAgent = class {
         resourceLoader,
         model,
         tools,
-        customTools: [this.sendFileToolDef]
+        customTools: [this.sendFileToolDef, this.scheduleToolDef]
       });
       const channelSession = {
         session,
@@ -4555,87 +5221,10 @@ ${text}`;
 };
 
 // src/runtime/adapters/web.ts
+init_config();
 import fs9 from "fs";
 import path9 from "path";
 import { WebSocketServer } from "ws";
-
-// src/runtime/config.ts
-import fs8 from "fs";
-import path8 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 = path8.join(rootDir, "data", "config.json");
-    if (fs8.existsSync(this.configPath)) {
-      try {
-        this.configData = JSON.parse(fs8.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 = path8.join(rootDir, "data");
-    if (!this.configPath) {
-      this.configPath = path8.join(rootDir, "data", "config.json");
-    }
-    if (!fs8.existsSync(configDir)) {
-      fs8.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;
-    }
-    try {
-      fs8.writeFileSync(
-        this.configPath,
-        JSON.stringify(this.configData, null, 2),
-        "utf-8"
-      );
-    } catch (err) {
-      console.error("Failed to save config:", err);
-    }
-  }
-};
-var configManager = ConfigManager.getInstance();
-
-// src/runtime/adapters/web.ts
 function getPackConfig(rootDir) {
   const raw = fs9.readFileSync(path9.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
@@ -4761,6 +5350,75 @@ var WebAdapter = class {
       );
       fs9.createReadStream(resolvedPath).pipe(res);
     });
+    const getScheduler = () => {
+      const schedulerAdapter = ctx.adapterMap?.get("scheduler");
+      if (!schedulerAdapter) return null;
+      return schedulerAdapter;
+    };
+    app.get("/api/scheduler/jobs", (_req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.json([]);
+        return;
+      }
+      res.json(scheduler.listJobs());
+    });
+    app.post("/api/scheduler/jobs", (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const { name, cron: cronExpr, prompt, notify, enabled, timezone } = req.body;
+      if (!name || !cronExpr || !prompt || !notify?.adapter || !notify?.channelId) {
+        res.status(400).json({
+          success: false,
+          message: "Required fields: name, cron, prompt, notify.adapter, notify.channelId"
+        });
+        return;
+      }
+      const result = scheduler.addJob({
+        name,
+        cron: cronExpr,
+        prompt,
+        notify,
+        enabled: enabled !== false,
+        timezone
+      });
+      res.json(result);
+    });
+    app.delete("/api/scheduler/jobs/:name", (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const result = scheduler.removeJob(req.params.name);
+      res.json(result);
+    });
+    app.post("/api/scheduler/jobs/:name/trigger", async (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const result = await scheduler.triggerJob(req.params.name);
+      res.json(result);
+    });
+    app.patch("/api/scheduler/jobs/:name", (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const { enabled } = req.body;
+      if (typeof enabled !== "boolean") {
+        res.status(400).json({ success: false, message: "Field 'enabled' (boolean) is required" });
+        return;
+      }
+      const result = scheduler.setEnabled(req.params.name, enabled);
+      res.json(result);
+    });
     this.wss = new WebSocketServer({ noServer: true });
     server.on("upgrade", (request, socket, head) => {
       if (request.url?.startsWith("/api/chat")) {
@@ -4841,6 +5499,9 @@ var WebAdapter = class {
   }
 };
 
+// src/runtime/server.ts
+init_config();
+
 // src/runtime/lifecycle.ts
 var SHUTDOWN_EXIT_CODE = 64;
 var RESTART_EXIT_CODE = 75;
@@ -4951,9 +5612,11 @@ async function startServer(options) {
     lifecycleHandler: lifecycle
   });
   const adapters = [];
+  const adapterMap = /* @__PURE__ */ new Map();
   const webAdapter = new WebAdapter();
-  await webAdapter.start({ agent, server, app, rootDir, lifecycle });
+  await webAdapter.start({ agent, server, app, rootDir, lifecycle, adapterMap });
   adapters.push(webAdapter);
+  adapterMap.set(webAdapter.name, webAdapter);
   if (dataConfig.adapters?.telegram?.token) {
     try {
       const { TelegramAdapter: TelegramAdapter2 } = await Promise.resolve().then(() => (init_telegram(), telegram_exports));
@@ -4962,6 +5625,7 @@ async function startServer(options) {
       });
       await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
       adapters.push(telegramAdapter);
+      adapterMap.set(telegramAdapter.name, telegramAdapter);
     } catch (err) {
       console.error("[Telegram] Failed to start:", err);
     }
@@ -4981,11 +5645,48 @@ async function startServer(options) {
         });
         await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
         adapters.push(slackAdapter);
+        adapterMap.set(slackAdapter.name, slackAdapter);
       } catch (err) {
         console.error("[Slack] Failed to start:", err);
       }
     }
   }
+  const { isMessageSender: isMessageSender2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  const notifyFn = async (adapterName, channelId, text) => {
+    const adapter = adapterMap.get(adapterName);
+    if (!adapter || !isMessageSender2(adapter)) {
+      console.warn(
+        `[Scheduler] Target adapter "${adapterName}" not found or doesn't support sendMessage`
+      );
+      return;
+    }
+    await adapter.sendMessage(channelId, text);
+  };
+  const scheduledJobs = dataConfig.scheduledJobs || [];
+  let schedulerAdapter = null;
+  try {
+    const { SchedulerAdapter: SchedulerAdapter2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+    schedulerAdapter = new SchedulerAdapter2();
+    await schedulerAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      notify: notifyFn,
+      adapterMap
+    });
+    adapters.push(schedulerAdapter);
+    adapterMap.set(schedulerAdapter.name, schedulerAdapter);
+    if (scheduledJobs.length > 0) {
+      console.log(`[Server] Scheduler started with ${scheduledJobs.length} job(s)`);
+    }
+  } catch (err) {
+    console.error("[Scheduler] Failed to start:", err);
+  }
+  if (schedulerAdapter) {
+    agent.setScheduler(schedulerAdapter);
+  }
   lifecycle.registerAdapters(adapters);
   server.once("listening", () => {
     const address = server.address();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {
@@ -49,6 +49,7 @@
     "commander": "^14.0.3",
     "express": "^5.1.0",
     "inquirer": "^13.3.0",
+    "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.66.0",
     "ws": "^8.19.0"
   },
@@ -57,6 +58,7 @@
     "@types/express": "^5.0.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.5.0",
+    "@types/node-cron": "^3.0.11",
     "@types/node-telegram-bot-api": "^0.64.0",
     "@types/ws": "^8.18.0",
     "prettier": "^3.8.1",