@cremini/skillpack 1.2.7 → 1.2.8

package/dist/cli.js

@@ -9,212 +9,138 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/runtime/config.ts
-import fs5 from "fs";
-import path5 from "path";
-var SUPPORTED_PROVIDERS, ConfigManager, configManager, ConfigFileAuthBackend;
-var init_config = __esm({
-  "src/runtime/config.ts"() {
-    "use strict";
-    SUPPORTED_PROVIDERS = {
-      openai: {
-        label: "OpenAI",
-        defaultModelId: "gpt-5.4",
-        authType: "api_key",
-        envKey: "OPENAI_API_KEY",
-        placeholder: "sk-proj-...",
-        baseUrlPlaceholder: "https://api.openai.com/v1",
-        supportsBaseUrl: true
-      },
-      anthropic: {
-        label: "Anthropic",
-        defaultModelId: "claude-opus-4-6",
-        authType: "api_key",
-        envKey: "ANTHROPIC_API_KEY",
-        placeholder: "sk-ant-api03-...",
-        baseUrlPlaceholder: "https://api.anthropic.com",
-        supportsBaseUrl: true
-      },
-      google: {
-        label: "Google (Gemini)",
-        defaultModelId: "gemini-2.5-pro",
-        authType: "api_key",
-        envKey: "GOOGLE_API_KEY",
-        placeholder: "AIza...",
-        supportsBaseUrl: false
+// src/job-config.ts
+import fs2 from "fs";
+import path2 from "path";
+function getJobFilePath(workDir) {
+  return path2.join(workDir, JOB_FILE);
+}
+function validateScheduledJobConfig(value, sourceLabel, index) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}]" must be an object`
+    );
+  }
+  const job = value;
+  if (typeof job.name !== "string" || !job.name.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].name" is required`
+    );
+  }
+  if (typeof job.cron !== "string" || !job.cron.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].cron" is required`
+    );
+  }
+  if (typeof job.prompt !== "string" || !job.prompt.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].prompt" is required`
+    );
+  }
+  if (!job.notify || typeof job.notify !== "object") {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].notify" must be an object`
+    );
+  }
+  const notify = job.notify;
+  if (typeof notify.adapter !== "string" || !notify.adapter.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].notify.adapter" is required`
+    );
+  }
+  if (typeof notify.channelId !== "string" || !notify.channelId.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].notify.channelId" is required`
+    );
+  }
+  if (job.enabled !== void 0 && typeof job.enabled !== "boolean") {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].enabled" must be a boolean`
+    );
+  }
+  if (job.timezone !== void 0 && typeof job.timezone !== "string") {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].timezone" must be a string`
+    );
+  }
+}
+function validateJobFileShape(value, sourceLabel) {
+  if (!value || typeof value !== "object") {
+    throw new Error(`Invalid job config from ${sourceLabel}: expected a JSON object`);
+  }
+  const jobFile = value;
+  if (!Array.isArray(jobFile.jobs)) {
+    throw new Error(`Invalid job config from ${sourceLabel}: "jobs" must be an array`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  jobFile.jobs.forEach((job, index) => {
+    validateScheduledJobConfig(job, sourceLabel, index);
+    const normalizedName = job.name.trim().toLowerCase();
+    if (names.has(normalizedName)) {
+      throw new Error(
+        `Invalid job config from ${sourceLabel}: duplicate job name "${job.name}" is not allowed`
+      );
+    }
+    names.add(normalizedName);
+  });
+}
+function normalizeJobFile(jobFile) {
+  return {
+    jobs: jobFile.jobs.map((job) => ({
+      name: job.name.trim(),
+      cron: job.cron.trim(),
+      prompt: job.prompt,
+      notify: {
+        adapter: job.notify.adapter.trim(),
+        channelId: job.notify.channelId.trim()
       },
-      "openai-codex": {
-        label: "OpenAI Codex",
-        defaultModelId: "gpt-5.4",
-        authType: "oauth",
-        oauthProviderId: "openai-codex",
-        supportsBaseUrl: false
-      }
-    };
-    ConfigManager = class _ConfigManager {
-      static instance;
-      configData = {};
-      configPath = "";
-      constructor() {
-      }
-      static getInstance() {
-        if (!_ConfigManager.instance) {
-          _ConfigManager.instance = new _ConfigManager();
-        }
-        return _ConfigManager.instance;
-      }
-      load(rootDir) {
-        this.configPath = path5.join(rootDir, "data", "config.json");
-        if (fs5.existsSync(this.configPath)) {
-          try {
-            this.configData = JSON.parse(fs5.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", baseUrl = "" } = 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";
-          } else if (process.env.GOOGLE_API_KEY) {
-            apiKey = process.env.GOOGLE_API_KEY;
-            provider = "google";
-          }
-        }
-        this.configData.apiKey = apiKey;
-        this.configData.provider = provider;
-        this.configData.baseUrl = baseUrl?.trim() || void 0;
-        return this.configData;
-      }
-      getConfig() {
-        return this.configData;
-      }
-      save(rootDir, updates) {
-        const configDir = path5.join(rootDir, "data");
-        if (!this.configPath) {
-          this.configPath = path5.join(rootDir, "data", "config.json");
-        }
-        if (!fs5.existsSync(configDir)) {
-          fs5.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.baseUrl !== void 0) {
-          this.configData.baseUrl = updates.baseUrl?.trim() || void 0;
-        }
-        if (updates.modelId !== void 0) {
-          this.configData.modelId = updates.modelId?.trim() || void 0;
-        }
-        if (updates.apiProtocol !== void 0) {
-          this.configData.apiProtocol = updates.apiProtocol || void 0;
-        }
-        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 {
-          fs5.writeFileSync(
-            this.configPath,
-            JSON.stringify(this.configData, null, 2),
-            "utf-8"
-          );
-        } catch (err) {
-          console.error("Failed to save config:", err);
-        }
-      }
-    };
-    configManager = ConfigManager.getInstance();
-    ConfigFileAuthBackend = class {
-      constructor(configPath) {
-        this.configPath = configPath;
-      }
-      ensureFile() {
-        const dir = path5.dirname(this.configPath);
-        if (!fs5.existsSync(dir)) {
-          fs5.mkdirSync(dir, { recursive: true });
-        }
-        if (!fs5.existsSync(this.configPath)) {
-          fs5.writeFileSync(this.configPath, "{}", "utf-8");
-        }
-      }
-      readAuthJson() {
-        this.ensureFile();
-        try {
-          const raw = fs5.readFileSync(this.configPath, "utf-8");
-          const config = JSON.parse(raw);
-          if (config._auth && typeof config._auth === "object") {
-            return JSON.stringify(config._auth);
-          }
-          return void 0;
-        } catch {
-          return void 0;
-        }
-      }
-      writeAuthJson(authJson) {
-        this.ensureFile();
-        try {
-          const raw = fs5.readFileSync(this.configPath, "utf-8");
-          const config = JSON.parse(raw);
-          config._auth = JSON.parse(authJson);
-          fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
-        } catch {
-          const config = { _auth: JSON.parse(authJson) };
-          fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
-        }
-      }
-      withLock(fn) {
-        const current = this.readAuthJson();
-        const { result, next } = fn(current);
-        if (next !== void 0) {
-          this.writeAuthJson(next);
-        }
-        return result;
-      }
-      async withLockAsync(fn) {
-        const current = this.readAuthJson();
-        const { result, next } = await fn(current);
-        if (next !== void 0) {
-          this.writeAuthJson(next);
-        }
-        return result;
-      }
-    };
+      ...job.enabled !== void 0 ? { enabled: job.enabled } : {},
+      ...job.timezone !== void 0 ? { timezone: job.timezone.trim() } : {}
+    }))
+  };
+}
+function loadJobFile(workDir) {
+  const filePath = getJobFilePath(workDir);
+  if (!fs2.existsSync(filePath)) {
+    return { jobs: [] };
+  }
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  validateJobFileShape(parsed, filePath);
+  return normalizeJobFile(parsed);
+}
+function saveJobFile(workDir, jobFile) {
+  const filePath = getJobFilePath(workDir);
+  const normalized = normalizeJobFile(jobFile);
+  validateJobFileShape(normalized, filePath);
+  fs2.writeFileSync(filePath, JSON.stringify(normalized, null, 2) + "\n", "utf-8");
+}
+var JOB_FILE;
+var init_job_config = __esm({
+  "src/job-config.ts"() {
+    "use strict";
+    JOB_FILE = "job.json";
   }
 });
 
 // src/runtime/adapters/attachment-utils.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { pipeline } from "stream/promises";
 import { Readable } from "stream";
 function getAttachmentDir(rootDir, channelId) {
-  return path6.resolve(rootDir, "data", "sessions", channelId, ATTACHMENTS_DIR);
+  return path7.resolve(rootDir, "data", "sessions", channelId, ATTACHMENTS_DIR);
 }
 function sanitizeFilename(name) {
   return name.replace(/[/\\:*?"<>|]/g, "_").replace(/\s+/g, "_");
 }
 async function downloadAndSaveAttachment(rootDir, channelId, url, filename, mimeType, headers) {
   const dir = getAttachmentDir(rootDir, channelId);
-  fs6.mkdirSync(dir, { recursive: true });
+  fs7.mkdirSync(dir, { recursive: true });
   const ts = Date.now();
   const safeName = sanitizeFilename(filename);
   const storedName = `${ts}-${safeName}`;
-  const fullPath = path6.join(dir, storedName);
+  const fullPath = path7.join(dir, storedName);
   const response = await fetch(url, { headers });
   if (!response.ok) {
     throw new Error(
@@ -226,9 +152,9 @@ async function downloadAndSaveAttachment(rootDir, channelId, url, filename, mime
     throw new Error(`Empty response body when downloading ${url}`);
   }
   const nodeStream = Readable.fromWeb(body);
-  const writeStream = fs6.createWriteStream(fullPath);
+  const writeStream = fs7.createWriteStream(fullPath);
   await pipeline(nodeStream, writeStream);
-  const stats = fs6.statSync(fullPath);
+  const stats = fs7.statSync(fullPath);
   const detectedMime = mimeType || response.headers.get("content-type")?.split(";")[0] || void 0;
   return {
     filename,
@@ -257,7 +183,7 @@ ${lines.join("\n")}`;
 }
 function attachmentsToImageContent(attachments) {
   return attachments.filter((a) => isImageMime(a.mimeType)).map((a) => {
-    const buffer = fs6.readFileSync(a.localPath);
+    const buffer = fs7.readFileSync(a.localPath);
     return {
       type: "image",
       data: buffer.toString("base64"),
@@ -463,7 +389,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs13 from "fs";
+import fs17 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -781,7 +707,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs13.existsSync(filePath)) {
+          if (!fs17.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -801,8 +727,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs14 from "fs";
-import path13 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
@@ -1437,12 +1363,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs14.existsSync(filePath)) {
+          if (!fs18.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path13.basename(filePath);
-          const fileContent = fs14.readFileSync(filePath);
+          const filename = path17.basename(filePath);
+          const fileContent = fs18.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1480,7 +1406,7 @@ var VALID_JOB_NAME, SchedulerAdapter;
 var init_scheduler = __esm({
   "src/runtime/adapters/scheduler.ts"() {
     "use strict";
-    init_config();
+    init_job_config();
     VALID_JOB_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
     SchedulerAdapter = class {
       name = "scheduler";
@@ -1494,8 +1420,7 @@ var init_scheduler = __esm({
         this.rootDir = ctx.rootDir;
         this.notifyFn = ctx.notify || (async () => {
         });
-        const config = configManager.getConfig();
-        const jobConfigs = config.scheduledJobs || [];
+        const jobConfigs = loadJobFile(this.rootDir).jobs;
         let scheduledCount = 0;
         let disabledCount = 0;
         for (const jc of jobConfigs) {
@@ -1599,11 +1524,13 @@ var init_scheduler = __esm({
           }
         };
         try {
+          await this.clearJobContext(channelId);
           const result = await this.agent.handleMessage(
             "scheduler",
             channelId,
             jobConfig.prompt,
-            onEvent
+            onEvent,
+            void 0
           );
           if (result.errorMessage) {
             fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u6267\u884C\u5931\u8D25\uFF1A${result.errorMessage}`;
@@ -1648,11 +1575,17 @@ var init_scheduler = __esm({
         }
         return { text: fullText, notifyFailed };
       }
+      async clearJobContext(channelId) {
+        const result = await this.agent.handleCommand("clear", channelId);
+        if (!result.success) {
+          throw new Error(result.message || `Failed to clear context for ${channelId}`);
+        }
+      }
       // -------------------------------------------------------------------------
       // Dynamic management API
       // -------------------------------------------------------------------------
       /**
-       * Add a new job, persist to config.json.
+       * Add a new job, persist to job.json.
        */
       addJob(jobConfig) {
         if (this.jobs.has(jobConfig.name)) {
@@ -1673,7 +1606,7 @@ var init_scheduler = __esm({
         };
       }
       /**
-       * Remove a job and persist to config.json.
+       * Remove a job and persist to job.json.
        */
       removeJob(name) {
         if (!this.jobs.has(name)) {
@@ -1683,6 +1616,29 @@ var init_scheduler = __esm({
         this.persistJobs();
         return { success: true, message: `Job "${name}" removed.` };
       }
+      updateJob(name, updates) {
+        const job = this.jobs.get(name);
+        if (!job) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        const nextConfig = {
+          name,
+          cron: updates.cron,
+          prompt: updates.prompt,
+          notify: updates.notify,
+          enabled: updates.enabled,
+          timezone: updates.timezone
+        };
+        const result = this.registerJob(nextConfig);
+        if (!result.registered) {
+          return { success: false, message: result.message };
+        }
+        this.persistJobs();
+        return {
+          success: true,
+          message: `Job "${name}" updated.`
+        };
+      }
       /**
        * Enable or disable a job and persist.
        */
@@ -1774,14 +1730,14 @@ var init_scheduler = __esm({
         }
       }
       /**
-       * Persist all current jobs to data/config.json.
+       * Persist all current jobs to job.json.
        */
       persistJobs() {
         const configs = [];
         for (const [, job] of this.jobs) {
           configs.push(job.config);
         }
-        configManager.save(this.rootDir, { scheduledJobs: configs });
+        saveJobFile(this.rootDir, { jobs: configs });
       }
       // -------------------------------------------------------------------------
       // Lifecycle
@@ -1802,8 +1758,8 @@ import { Command } from "commander";
 import chalk5 from "chalk";
 
 // src/commands/create.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import inquirer from "inquirer";
 import chalk3 from "chalk";
 
@@ -1911,22 +1867,23 @@ function configExists(workDir) {
 }
 
 // src/commands/zip.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import archiver from "archiver";
 import chalk2 from "chalk";
+init_job_config();
 
 // src/skill-manager.ts
 import { spawnSync } from "child_process";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import chalk from "chalk";
 var SKILLS_DIR = "skills";
 function normalizeName(value) {
   return value.trim().toLowerCase();
 }
 function getSkillsDir(workDir) {
-  return path2.join(workDir, SKILLS_DIR);
+  return path3.join(workDir, SKILLS_DIR);
 }
 function groupSkillsBySource(skills) {
   const groups = /* @__PURE__ */ new Map();
@@ -1983,13 +1940,13 @@ function installSkills(workDir, skills) {
 function scanInstalledSkills(workDir) {
   const installed = [];
   const skillsDir = getSkillsDir(workDir);
-  if (!fs2.existsSync(skillsDir)) {
+  if (!fs3.existsSync(skillsDir)) {
     return installed;
   }
   function visit(dir) {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
+      const fullPath = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath);
         continue;
@@ -2008,7 +1965,7 @@ function scanInstalledSkills(workDir) {
 }
 function parseSkillMd(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
     if (!frontmatterMatch) {
       return null;
@@ -2021,7 +1978,7 @@ function parseSkillMd(filePath) {
     return {
       name,
       description: readFrontmatterField(frontmatter, "description") ?? "",
-      dir: path2.dirname(filePath)
+      dir: path3.dirname(filePath)
     };
   } catch {
     return null;
@@ -2185,12 +2142,12 @@ async function zipCommand(workDir) {
   const config = loadConfig(workDir);
   const slug = config.name.toLowerCase().replace(/\s+/g, "-");
   const zipName = `${slug}.zip`;
-  const zipPath = path3.join(workDir, zipName);
+  const zipPath = path4.join(workDir, zipName);
   installConfiguredSkills(workDir, config);
   syncSkillDescriptions(workDir, config);
   saveConfig(workDir, config);
   console.log(chalk2.blue(`Packaging ${config.name}...`));
-  const output = fs3.createWriteStream(zipPath);
+  const output = fs4.createWriteStream(zipPath);
   const archive = archiver("zip", { zlib: { level: 9 } });
   return new Promise((resolve, reject) => {
     output.on("close", () => {
@@ -2207,22 +2164,26 @@ async function zipCommand(workDir) {
     archive.file(getPackPath(workDir), {
       name: `${prefix}/${PACK_FILE}`
     });
+    const jobFilePath = getJobFilePath(workDir);
+    if (fs4.existsSync(jobFilePath)) {
+      archive.file(jobFilePath, { name: `${prefix}/${JOB_FILE}` });
+    }
     for (const file of ["AGENTS.md", "SOUL.md"]) {
-      const filePath = path3.join(workDir, file);
-      if (fs3.existsSync(filePath)) {
+      const filePath = path4.join(workDir, file);
+      if (fs4.existsSync(filePath)) {
         archive.file(filePath, { name: `${prefix}/${file}` });
       }
     }
-    const skillsDir = path3.join(workDir, "skills");
-    if (fs3.existsSync(skillsDir)) {
+    const skillsDir = path4.join(workDir, "skills");
+    if (fs4.existsSync(skillsDir)) {
       archive.directory(skillsDir, `${prefix}/skills`);
     }
-    const startSh = path3.join(workDir, "start.sh");
-    if (fs3.existsSync(startSh)) {
+    const startSh = path4.join(workDir, "start.sh");
+    if (fs4.existsSync(startSh)) {
       archive.file(startSh, { name: `${prefix}/start.sh`, mode: 493 });
     }
-    const startBat = path3.join(workDir, "start.bat");
-    if (fs3.existsSync(startBat)) {
+    const startBat = path4.join(workDir, "start.bat");
+    if (fs4.existsSync(startBat)) {
       archive.file(startBat, { name: `${prefix}/start.bat` });
     }
     archive.finalize();
@@ -2271,24 +2232,24 @@ async function readConfigSource(source) {
     }
     raw = await response.text();
   } else {
-    const filePath = path4.resolve(source);
-    raw = fs4.readFileSync(filePath, "utf-8");
+    const filePath = path5.resolve(source);
+    raw = fs5.readFileSync(filePath, "utf-8");
   }
   const parsed = JSON.parse(raw);
   validateConfigShape(parsed, source);
   return parsed;
 }
 function copyStartTemplates(workDir) {
-  const templateDir = path4.resolve(
+  const templateDir = path5.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);
+    const src = path5.join(templateDir, file);
+    const dest = path5.join(workDir, file);
+    if (fs5.existsSync(src)) {
+      fs5.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs4.chmodSync(dest, 493);
+        fs5.chmodSync(dest, 493);
       }
     } else {
       console.warn(chalk3.yellow(`  [warn] Template not found: ${src}`));
@@ -2296,9 +2257,9 @@ function copyStartTemplates(workDir) {
   }
 }
 async function createCommand(directory, options = {}) {
-  const workDir = directory ? path4.resolve(directory) : process.cwd();
+  const workDir = directory ? path5.resolve(directory) : process.cwd();
   if (directory) {
-    fs4.mkdirSync(workDir, { recursive: true });
+    fs5.mkdirSync(workDir, { recursive: true });
   }
   if (options.config) {
     await initFromConfig(workDir, options.config);
@@ -2469,24 +2430,23 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path15 from "path";
-import fs16 from "fs";
+import path19 from "path";
+import fs20 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path14 from "path";
-import fs15 from "fs";
+import path18 from "path";
+import fs19 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
 
 // src/runtime/agent.ts
-init_config();
-init_attachment_utils();
-import path9 from "path";
-import fs9 from "fs";
+import path13 from "path";
+import fs13 from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -2497,20 +2457,260 @@ import {
   DefaultResourceLoader
 } from "@mariozechner/pi-coding-agent";
 
-// src/runtime/tools/send-file-tool.ts
-import fs7 from "fs";
-import path7 from "path";
-import { Type } from "@sinclair/typebox";
-var SendFileParams = Type.Object({
-  filePath: Type.String({
-    description: "Absolute path to the file to send to the user. The file must exist and be readable."
-  }),
-  caption: Type.Optional(
-    Type.String({
-      description: "Optional caption or description to accompany the file."
-    })
-  )
-});
+// src/runtime/config.ts
+import fs6 from "fs";
+import path6 from "path";
+var SUPPORTED_PROVIDERS = {
+  openai: {
+    label: "OpenAI",
+    defaultModelId: "gpt-5.4",
+    authType: "api_key",
+    envKey: "OPENAI_API_KEY",
+    placeholder: "sk-proj-...",
+    baseUrlPlaceholder: "https://api.openai.com/v1",
+    supportsBaseUrl: true
+  },
+  anthropic: {
+    label: "Anthropic",
+    defaultModelId: "claude-opus-4-6",
+    authType: "api_key",
+    envKey: "ANTHROPIC_API_KEY",
+    placeholder: "sk-ant-api03-...",
+    baseUrlPlaceholder: "https://api.anthropic.com",
+    supportsBaseUrl: true
+  },
+  google: {
+    label: "Google (Gemini)",
+    defaultModelId: "gemini-2.5-pro",
+    authType: "api_key",
+    envKey: "GOOGLE_API_KEY",
+    placeholder: "AIza...",
+    supportsBaseUrl: false
+  },
+  "openai-codex": {
+    label: "OpenAI Codex",
+    defaultModelId: "gpt-5.4",
+    authType: "oauth",
+    oauthProviderId: "openai-codex",
+    supportsBaseUrl: false
+  }
+};
+function normalizeDataConfig(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const raw = value;
+  const normalized = {};
+  if (typeof raw.apiKey === "string") {
+    normalized.apiKey = raw.apiKey;
+  }
+  if (typeof raw.provider === "string") {
+    normalized.provider = raw.provider;
+  }
+  if (typeof raw.baseUrl === "string") {
+    normalized.baseUrl = raw.baseUrl;
+  }
+  if (typeof raw.modelId === "string") {
+    normalized.modelId = raw.modelId;
+  }
+  if (raw.apiProtocol === "openai-responses" || raw.apiProtocol === "openai-completions") {
+    normalized.apiProtocol = raw.apiProtocol;
+  }
+  if (raw.adapters && typeof raw.adapters === "object" && !Array.isArray(raw.adapters)) {
+    normalized.adapters = raw.adapters;
+  }
+  if (raw._auth && typeof raw._auth === "object" && !Array.isArray(raw._auth)) {
+    normalized._auth = raw._auth;
+  }
+  return normalized;
+}
+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");
+    this.configData = {};
+    if (fs6.existsSync(this.configPath)) {
+      try {
+        const parsed = JSON.parse(fs6.readFileSync(this.configPath, "utf-8"));
+        if (parsed && typeof parsed === "object" && "scheduledJobs" in parsed) {
+          console.warn(
+            '  Warning: data/config.json contains deprecated "scheduledJobs". Move them to job.json at the pack root; the old field is ignored.'
+          );
+        }
+        this.configData = normalizeDataConfig(parsed);
+        console.log("  Loaded config from data/config.json");
+      } catch (err) {
+        console.warn("  Warning: Failed to parse data/config.json:", err);
+      }
+    }
+    let { apiKey = "", provider = "openai", baseUrl = "" } = 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";
+      } else if (process.env.GOOGLE_API_KEY) {
+        apiKey = process.env.GOOGLE_API_KEY;
+        provider = "google";
+      }
+    }
+    this.configData.apiKey = apiKey;
+    this.configData.provider = provider;
+    this.configData.baseUrl = baseUrl?.trim() || void 0;
+    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.baseUrl !== void 0) {
+      this.configData.baseUrl = updates.baseUrl?.trim() || void 0;
+    }
+    if (updates.modelId !== void 0) {
+      this.configData.modelId = updates.modelId?.trim() || void 0;
+    }
+    if (updates.apiProtocol !== void 0) {
+      this.configData.apiProtocol = updates.apiProtocol || void 0;
+    }
+    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 {
+      this.configData = normalizeDataConfig(this.configData);
+      fs6.writeFileSync(
+        this.configPath,
+        JSON.stringify(this.configData, null, 2),
+        "utf-8"
+      );
+    } catch (err) {
+      console.error("Failed to save config:", err);
+    }
+  }
+};
+var configManager = ConfigManager.getInstance();
+var ConfigFileAuthBackend = class {
+  constructor(configPath) {
+    this.configPath = configPath;
+  }
+  ensureFile() {
+    const dir = path6.dirname(this.configPath);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs6.existsSync(this.configPath)) {
+      fs6.writeFileSync(this.configPath, "{}", "utf-8");
+    }
+  }
+  readAuthJson() {
+    this.ensureFile();
+    try {
+      const raw = fs6.readFileSync(this.configPath, "utf-8");
+      const config = JSON.parse(raw);
+      if (config._auth && typeof config._auth === "object") {
+        return JSON.stringify(config._auth);
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  writeAuthJson(authJson) {
+    this.ensureFile();
+    try {
+      const raw = fs6.readFileSync(this.configPath, "utf-8");
+      const config = JSON.parse(raw);
+      config._auth = JSON.parse(authJson);
+      fs6.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch {
+      const config = { _auth: JSON.parse(authJson) };
+      fs6.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+  }
+  withLock(fn) {
+    const current = this.readAuthJson();
+    const { result, next } = fn(current);
+    if (next !== void 0) {
+      this.writeAuthJson(next);
+    }
+    return result;
+  }
+  async withLockAsync(fn) {
+    const current = this.readAuthJson();
+    const { result, next } = await fn(current);
+    if (next !== void 0) {
+      this.writeAuthJson(next);
+    }
+    return result;
+  }
+};
+
+// src/runtime/agent.ts
+init_attachment_utils();
+
+// src/runtime/artifacts/query-service.ts
+function clampLimit(limit, fallback, max) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  const normalized = Math.floor(limit);
+  return Math.max(1, Math.min(normalized, max));
+}
+function clampOffset(offset) {
+  if (!Number.isFinite(offset)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(offset));
+}
+var ResultsQueryService = class {
+  constructor(resultStore) {
+    this.resultStore = resultStore;
+  }
+  listRecentArtifacts(options = {}) {
+    return this.resultStore.listRecentArtifacts({
+      channelId: options.channelId,
+      limit: clampLimit(options.limit, 100, 500),
+      offset: clampOffset(options.offset)
+    });
+  }
+};
+
+// src/runtime/artifacts/snapshot-service.ts
+import { randomUUID } from "crypto";
+import fs9 from "fs";
+import path9 from "path";
+
+// src/runtime/files/metadata.ts
+import fs8 from "fs";
+import path8 from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -2532,26 +2732,381 @@ var MIME_BY_EXT = {
   ".ogg": "audio/ogg"
 };
 function detectMimeType(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   return MIME_BY_EXT[ext];
 }
-function createSendFileTool(fileOutputCallbackRef) {
+function isWithinDirectory(parentDir, targetPath) {
+  const relativePath = path8.relative(path8.resolve(parentDir), path8.resolve(targetPath));
+  return relativePath !== ".." && !relativePath.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relativePath);
+}
+function toPackRelativePath(rootDir, filePath) {
+  const resolvedRoot = path8.resolve(rootDir);
+  const resolvedFile = path8.resolve(filePath);
+  if (!isWithinDirectory(resolvedRoot, resolvedFile)) {
+    throw new Error(`Path is outside the pack root: ${resolvedFile}`);
+  }
+  return path8.relative(resolvedRoot, resolvedFile).split(path8.sep).join("/");
+}
+function resolvePackFile(rootDir, filePath) {
+  if (!path8.isAbsolute(filePath)) {
+    throw new Error(`filePath must be absolute: ${filePath}`);
+  }
+  const resolvedPath = path8.resolve(filePath);
+  if (!isWithinDirectory(rootDir, resolvedPath)) {
+    throw new Error(`File is outside the pack root: ${resolvedPath}`);
+  }
+  if (!fs8.existsSync(resolvedPath)) {
+    throw new Error(`File not found: ${resolvedPath}`);
+  }
+  const stats = fs8.statSync(resolvedPath);
+  if (!stats.isFile()) {
+    throw new Error(`Path is not a file: ${resolvedPath}`);
+  }
+  fs8.accessSync(resolvedPath, fs8.constants.R_OK);
   return {
-    name: "send_file",
-    label: "Send File",
-    description: "Send a file to the user via the current chat channel (Telegram, Slack, or Web). IMPORTANT: Do NOT proactively send files. Only use this tool when the user EXPLICITLY asks you to send, share, or deliver a file (e.g. '\u628A\u6587\u4EF6\u53D1\u7ED9\u6211', 'send me the file', 'share the result'). Never send intermediate/temporary files. When the user asks, send only the specific file(s) the user requested, not all generated files.",
-    promptSnippet: "send_file: Send a file to the user ONLY when they explicitly request it. Never send files proactively or automatically.",
-    parameters: SendFileParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const { filePath, caption } = params;
-      if (!fs7.existsSync(filePath)) {
-        return {
-          content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
-          details: void 0
-        };
-      }
-      const stats = fs7.statSync(filePath);
-      if (!stats.isFile()) {
+    resolvedPath,
+    fileName: path8.basename(resolvedPath),
+    mimeType: detectMimeType(resolvedPath),
+    sizeBytes: stats.size
+  };
+}
+
+// src/runtime/artifacts/snapshot-service.ts
+function sanitizeFileName(fileName) {
+  const sanitized = fileName.replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return sanitized || "artifact";
+}
+function formatSnapshotStamp(isoDate) {
+  const normalized = isoDate.replace(/\D+/g, "").slice(0, 14);
+  return normalized || String(Date.now());
+}
+var ArtifactSnapshotService = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  createSnapshots(runId, artifacts, declaredAt) {
+    if (artifacts.length === 0) {
+      return [];
+    }
+    const artifactsRoot = path9.resolve(this.rootDir, "data", "artifacts");
+    const runDir = path9.join(artifactsRoot, runId);
+    const tempDir = path9.join(
+      artifactsRoot,
+      `.tmp-${runId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+    );
+    const snapshots = [];
+    const movedPaths = [];
+    const snapshotNames = artifacts.map((artifact) => [
+      formatSnapshotStamp(declaredAt),
+      randomUUID(),
+      sanitizeFileName(artifact.fileName)
+    ].join("-"));
+    fs9.mkdirSync(artifactsRoot, { recursive: true });
+    fs9.mkdirSync(tempDir, { recursive: true });
+    try {
+      snapshotNames.forEach((snapshotName, index) => {
+        fs9.copyFileSync(
+          artifacts[index].filePath,
+          path9.join(tempDir, snapshotName)
+        );
+      });
+      fs9.mkdirSync(runDir, { recursive: true });
+      snapshotNames.forEach((snapshotName, index) => {
+        const artifact = artifacts[index];
+        const tempSnapshotPath = path9.join(tempDir, snapshotName);
+        const finalSnapshotPath = path9.join(runDir, snapshotName);
+        fs9.renameSync(tempSnapshotPath, finalSnapshotPath);
+        movedPaths.push(finalSnapshotPath);
+        snapshots.push({
+          declaredAt,
+          originalPath: toPackRelativePath(this.rootDir, artifact.filePath),
+          snapshotPath: path9.join("data", "artifacts", runId, snapshotName).split(path9.sep).join("/"),
+          fileName: artifact.fileName,
+          mimeType: artifact.mimeType,
+          sizeBytes: artifact.sizeBytes,
+          title: artifact.title,
+          isPrimary: artifact.isPrimary
+        });
+      });
+      fs9.rmSync(tempDir, { recursive: true, force: true });
+      return snapshots;
+    } catch (error) {
+      fs9.rmSync(tempDir, { recursive: true, force: true });
+      movedPaths.forEach((filePath) => fs9.rmSync(filePath, { force: true }));
+      this.removeEmptyRunDirectory(runDir);
+      throw error;
+    }
+  }
+  removeSnapshots(snapshotPaths) {
+    const visitedRunDirs = /* @__PURE__ */ new Set();
+    for (const snapshotPath of snapshotPaths) {
+      const resolvedPath = path9.resolve(this.rootDir, snapshotPath);
+      fs9.rmSync(resolvedPath, { force: true });
+      visitedRunDirs.add(path9.dirname(resolvedPath));
+    }
+    visitedRunDirs.forEach((runDir) => this.removeEmptyRunDirectory(runDir));
+  }
+  removeEmptyRunDirectory(runDir) {
+    try {
+      if (!fs9.existsSync(runDir)) {
+        return;
+      }
+      if (fs9.readdirSync(runDir).length === 0) {
+        fs9.rmdirSync(runDir);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/runtime/artifacts/persistence-service.ts
+var ArtifactPersistenceService = class {
+  constructor(snapshotService, resultStore) {
+    this.snapshotService = snapshotService;
+    this.resultStore = resultStore;
+  }
+  saveArtifacts(input) {
+    const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshots = this.snapshotService.createSnapshots(
+      input.runId,
+      input.artifacts,
+      declaredAt
+    );
+    try {
+      this.resultStore.insertArtifacts({
+        runId: input.runId,
+        channelId: input.channelId,
+        artifacts: snapshots
+      });
+      return snapshots.length;
+    } catch (error) {
+      this.snapshotService.removeSnapshots(
+        snapshots.map((artifact) => artifact.snapshotPath)
+      );
+      throw error;
+    }
+  }
+};
+
+// src/runtime/artifacts/store.ts
+import fs10 from "fs";
+import path10 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import Database from "better-sqlite3";
+function mapArtifactRow(row) {
+  return {
+    artifactId: row.artifact_id,
+    runId: row.run_id,
+    channelId: row.channel_id,
+    originalPath: row.original_path,
+    snapshotPath: row.snapshot_path,
+    fileName: row.file_name,
+    mimeType: row.mime_type,
+    sizeBytes: row.size_bytes,
+    title: row.title,
+    isPrimary: row.is_primary === 1,
+    declaredAt: row.declared_at
+  };
+}
+var ResultStore = class {
+  db;
+  constructor(rootDir) {
+    const dataDir = path10.resolve(rootDir, "data");
+    fs10.mkdirSync(dataDir, { recursive: true });
+    this.db = new Database(path10.join(dataDir, "result.db"));
+    this.db.pragma("journal_mode = WAL");
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS artifacts (
+        artifact_id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        channel_id TEXT NOT NULL,
+        original_path TEXT NOT NULL,
+        snapshot_path TEXT NOT NULL,
+        file_name TEXT NOT NULL,
+        mime_type TEXT,
+        size_bytes INTEGER NOT NULL,
+        title TEXT,
+        is_primary INTEGER NOT NULL DEFAULT 0,
+        declared_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_artifacts_channel_declared_at
+      ON artifacts(channel_id, declared_at DESC);
+    `);
+  }
+  insertArtifacts(input) {
+    if (input.artifacts.length === 0) {
+      return;
+    }
+    const insertArtifact = this.db.prepare(`
+      INSERT INTO artifacts (
+        artifact_id,
+        run_id,
+        channel_id,
+        original_path,
+        snapshot_path,
+        file_name,
+        mime_type,
+        size_bytes,
+        title,
+        is_primary,
+        declared_at
+      ) VALUES (
+        @artifactId,
+        @runId,
+        @channelId,
+        @originalPath,
+        @snapshotPath,
+        @fileName,
+        @mimeType,
+        @sizeBytes,
+        @title,
+        @isPrimary,
+        @declaredAt
+      )
+    `);
+    const transaction = this.db.transaction((payload) => {
+      for (const artifact of payload.artifacts) {
+        insertArtifact.run({
+          artifactId: randomUUID2(),
+          runId: payload.runId,
+          channelId: payload.channelId,
+          originalPath: artifact.originalPath,
+          snapshotPath: artifact.snapshotPath,
+          fileName: artifact.fileName,
+          mimeType: artifact.mimeType ?? null,
+          sizeBytes: artifact.sizeBytes,
+          title: artifact.title ?? null,
+          isPrimary: artifact.isPrimary ? 1 : 0,
+          declaredAt: artifact.declaredAt
+        });
+      }
+    });
+    transaction(input);
+  }
+  listRecentArtifacts(options = {}) {
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (options.channelId) {
+      conditions.push("channel_id = ?");
+      params.push(options.channelId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = this.db.prepare(`
+      SELECT *
+      FROM artifacts
+      ${whereClause}
+      ORDER BY declared_at DESC, rowid DESC
+      LIMIT ? OFFSET ?
+    `).all(...params, limit, offset);
+    return rows.map(mapArtifactRow);
+  }
+};
+
+// src/runtime/artifacts/save-artifacts-tool.ts
+import { Type } from "@sinclair/typebox";
+var ArtifactItem = Type.Object({
+  filePath: Type.String({
+    description: "Absolute path to the artifact file. The file must exist, be readable, and be inside the current pack root."
+  }),
+  title: Type.Optional(
+    Type.String({
+      description: "Optional short title shown in the dashboard."
+    })
+  ),
+  isPrimary: Type.Optional(
+    Type.Boolean({
+      description: "Mark this artifact as a primary output."
+    })
+  )
+});
+var SaveArtifactsParams = Type.Object({
+  artifacts: Type.Array(ArtifactItem, {
+    minItems: 1,
+    description: "The artifact files to save for this run."
+  })
+});
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
+}
+function normalizeOptionalText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function createSaveArtifactsTool(rootDir, saveCallbackRef) {
+  return {
+    name: "save_artifacts",
+    label: "Save Artifacts",
+    description: [
+      "Save the final output files produced by this run.",
+      "Always use this for user-facing deliverables that are part of the final result.",
+      "Do not use this for intermediate, temporary, draft, or scratch files.",
+      "Each filePath must be an absolute path inside the current pack root."
+    ].join("\n"),
+    promptSnippet: "save_artifacts: Save final result files for this task. Always call this for user-facing final deliverables, and never for intermediate files. Use absolute paths inside the current pack root.",
+    promptGuidelines: [
+      "Whenever you create a final result file for the user, call `save_artifacts` before finishing the response.",
+      "Do not call `save_artifacts` for intermediate, temporary, draft, or scratch files."
+    ],
+    parameters: SaveArtifactsParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const saveArtifacts = saveCallbackRef.current;
+      if (!saveArtifacts) {
+        throw new Error("Artifact saving is not available for this run.");
+      }
+      const artifacts = params.artifacts.map((artifact) => {
+        const metadata = resolvePackFile(rootDir, artifact.filePath);
+        return {
+          filePath: metadata.resolvedPath,
+          fileName: metadata.fileName,
+          mimeType: metadata.mimeType,
+          sizeBytes: metadata.sizeBytes,
+          title: normalizeOptionalText(artifact.title),
+          isPrimary: artifact.isPrimary === true
+        };
+      });
+      const savedCount = await saveArtifacts(artifacts);
+      return textResult(`Saved ${savedCount} artifact(s).`);
+    }
+  };
+}
+
+// src/runtime/tools/send-file-tool.ts
+import fs11 from "fs";
+import path11 from "path";
+import { Type as Type2 } from "@sinclair/typebox";
+var SendFileParams = Type2.Object({
+  filePath: Type2.String({
+    description: "Absolute path to the file to send to the user. The file must exist and be readable."
+  }),
+  caption: Type2.Optional(
+    Type2.String({
+      description: "Optional caption or description to accompany the file."
+    })
+  )
+});
+function createSendFileTool(fileOutputCallbackRef) {
+  return {
+    name: "send_file",
+    label: "Send File",
+    description: "Send a file to the user via the current chat channel (Telegram, Slack, or Web). IMPORTANT: Do NOT proactively send files. Only use this tool when the user EXPLICITLY asks you to send, share, or deliver a file (e.g. '\u628A\u6587\u4EF6\u53D1\u7ED9\u6211', 'send me the file', 'share the result'). Never send intermediate/temporary files. When the user asks, send only the specific file(s) the user requested, not all generated files.",
+    promptSnippet: "send_file: Send a file to the user ONLY when they explicitly request it. Never send files proactively or automatically.",
+    parameters: SendFileParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const { filePath, caption } = params;
+      if (!fs11.existsSync(filePath)) {
+        return {
+          content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
+          details: void 0
+        };
+      }
+      const stats = fs11.statSync(filePath);
+      if (!stats.isFile()) {
         return {
           content: [
             { type: "text", text: `Error: Path is not a file: ${filePath}` }
@@ -2559,7 +3114,7 @@ function createSendFileTool(fileOutputCallbackRef) {
           details: void 0
         };
       }
-      const filename = path7.basename(filePath);
+      const filename = path11.basename(filePath);
       const mimeType = detectMimeType(filePath);
       const callback = fileOutputCallbackRef.current;
       if (callback) {
@@ -2586,43 +3141,65 @@ function createSendFileTool(fileOutputCallbackRef) {
 }
 
 // src/runtime/tools/manage-schedule-tool.ts
-import { Type as Type2 } from "@sinclair/typebox";
-var ManageScheduleParams = Type2.Object({
-  action: Type2.Union(
+import { Type as Type3 } from "@sinclair/typebox";
+var ManageScheduleParams = Type3.Object({
+  action: Type3.Union(
     [
-      Type2.Literal("add"),
-      Type2.Literal("list"),
-      Type2.Literal("remove"),
-      Type2.Literal("trigger"),
-      Type2.Literal("enable"),
-      Type2.Literal("disable")
+      Type3.Literal("add"),
+      Type3.Literal("list"),
+      Type3.Literal("remove"),
+      Type3.Literal("trigger"),
+      Type3.Literal("enable"),
+      Type3.Literal("disable")
     ],
     { description: "The action to perform." }
   ),
-  name: Type2.Optional(
-    Type2.String({
+  name: Type3.Optional(
+    Type3.String({
       description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
     })
   ),
-  cron: Type2.Optional(
-    Type2.String({
+  cron: Type3.Optional(
+    Type3.String({
       description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
     })
   ),
-  prompt: Type2.Optional(
-    Type2.String({
+  prompt: Type3.Optional(
+    Type3.String({
       description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
     })
   ),
-  timezone: Type2.Optional(
-    Type2.String({
+  timezone: Type3.Optional(
+    Type3.String({
       description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
     })
+  ),
+  notifyAdapter: Type3.Optional(
+    Type3.String({
+      description: "Optional target adapter for notifications. If omitted, the current chat is used when supported (Telegram, Slack, or Web)."
+    })
+  ),
+  notifyChannelId: Type3.Optional(
+    Type3.String({
+      description: "Optional target channelId for notifications. Must be provided together with notifyAdapter when overriding the default target."
+    })
   )
 });
-function textResult(text) {
+function textResult2(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
+function getDefaultNotifyTarget(adapter, channelId) {
+  if (adapter === "telegram" && channelId.startsWith("telegram-")) {
+    return { adapter: "telegram", channelId };
+  }
+  if (adapter === "slack" && channelId.startsWith("slack-")) {
+    return { adapter: "slack", channelId };
+  }
+  if (adapter === "web") {
+    return { adapter: "web", channelId };
+  }
+  return null;
+}
 function createManageScheduleTool(schedulerRef, adapter, channelId) {
   return {
     name: "manage_scheduled_task",
@@ -2631,7 +3208,7 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
       "Manage scheduled tasks (cron jobs) that automatically execute prompts and push results to IM channels.",
       "",
       "Actions:",
-      "- add: Create a new scheduled task. Requires: name, cron, prompt. The notification target always uses the current Telegram or Slack chat. The prompt must describe only the work for each run, not the schedule itself.",
+      "- add: Create a new scheduled task. Requires: name, cron, prompt. Notifications default to the current Telegram, Slack, or Web chat. You can override the destination with notifyAdapter + notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
       "- list: List all scheduled tasks with their status.",
       "- remove: Remove a scheduled task by name.",
       "- trigger: Manually trigger a scheduled task by name (runs immediately).",
@@ -2648,7 +3225,7 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const scheduler = schedulerRef.current;
       if (!scheduler) {
-        return textResult(
+        return textResult2(
           "Error: Scheduler is not available. The scheduled task system may not be initialized."
         );
       }
@@ -2656,79 +3233,85 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
         case "list": {
           const jobs = scheduler.listJobs();
           if (jobs.length === 0) {
-            return textResult("No scheduled tasks configured.");
+            return textResult2("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(
+          return textResult2(
             `Scheduled tasks (${jobs.length}):
 ${lines.join("\n")}`
           );
         }
         case "add": {
           if (!params.name || !params.cron || !params.prompt) {
-            return textResult(
+            return textResult2(
               "Error: 'name', 'cron', and 'prompt' are required for adding a task."
             );
           }
-          if (adapter !== "telegram" && adapter !== "slack") {
-            return textResult(
-              "Error: Scheduled tasks can only be created from a Telegram or Slack."
+          if (params.notifyAdapter && !params.notifyChannelId || !params.notifyAdapter && params.notifyChannelId) {
+            return textResult2(
+              "Error: 'notifyAdapter' and 'notifyChannelId' must be provided together when overriding the notification target."
+            );
+          }
+          const notify = params.notifyAdapter && params.notifyChannelId ? {
+            adapter: params.notifyAdapter,
+            channelId: params.notifyChannelId
+          } : getDefaultNotifyTarget(adapter, channelId);
+          if (!notify) {
+            return textResult2(
+              "Error: No default notification target is available for this chat. Provide 'notifyAdapter' and 'notifyChannelId'."
             );
           }
           const jobConfig = {
             name: params.name,
             cron: params.cron,
             prompt: params.prompt,
-            notify: {
-              adapter,
-              channelId
-            },
+            notify,
             enabled: true,
             timezone: params.timezone
           };
           const result = scheduler.addJob(jobConfig);
-          return textResult(result.message);
+          return textResult2(result.message);
         }
         case "remove": {
           if (!params.name) {
-            return textResult(
+            return textResult2(
               "Error: 'name' is required for removing a task."
             );
           }
           const result = scheduler.removeJob(params.name);
-          return textResult(result.message);
+          return textResult2(result.message);
         }
         case "trigger": {
           if (!params.name) {
-            return textResult(
+            return textResult2(
               "Error: 'name' is required for triggering a task."
             );
           }
           const result = await scheduler.triggerJob(params.name);
-          return textResult(result.message);
+          return textResult2(result.message);
         }
         case "enable": {
           if (!params.name) {
-            return textResult(
+            return textResult2(
               "Error: 'name' is required for enabling a task."
             );
           }
           const result = scheduler.setEnabled(params.name, true);
-          return textResult(result.message);
+          return textResult2(result.message);
         }
         case "disable": {
           if (!params.name) {
-            return textResult(
+            return textResult2(
               "Error: 'name' is required for disabling a task."
             );
           }
           const result = scheduler.setEnabled(params.name, false);
-          return textResult(result.message);
+          return textResult2(result.message);
         }
         default:
-          return textResult(
+          return textResult2(
             `Error: Unknown action '${params.action}'. Use: add, list, remove, trigger, enable, disable.`
           );
       }
@@ -2738,8 +3321,8 @@ ${lines.join("\n")}`
 
 // src/runtime/commands/help-command.ts
 init_commands();
-import fs8 from "fs";
-import path8 from "path";
+import fs12 from "fs";
+import path12 from "path";
 function buildHelpMessage(rootDir) {
   const sections = [];
   const commands = getVisibleCommands();
@@ -2749,7 +3332,7 @@ function buildHelpMessage(rootDir) {
   sections.push(`\u{1F4CB} **Available Commands**
 
 ${commandLines.join("\n")}`);
-  const configPath = path8.resolve(rootDir, "skillpack.json");
+  const configPath = path12.resolve(rootDir, "skillpack.json");
   const skills = readInstalledSkills(configPath);
   if (skills.length > 0) {
     const skillLines = skills.map(
@@ -2785,11 +3368,11 @@ function handleHelpCommand(rootDir) {
   };
 }
 function readInstalledSkills(configPath) {
-  if (!fs8.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     return [];
   }
   try {
-    const raw = fs8.readFileSync(configPath, "utf-8");
+    const raw = fs12.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return Array.isArray(config.skills) ? config.skills : [];
   } catch {
@@ -2809,24 +3392,24 @@ var BUILTIN_SKILL_CREATOR_TEMPLATE_DIR = fileURLToPath(
 var PACK_AGENTS_FILE = "AGENTS.md";
 var PACK_SOUL_FILE = "SOUL.md";
 function materializeBuiltinSkillCreator(rootDir, skillsPath) {
-  if (!fs9.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs13.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path9.resolve(rootDir, "skillpack.json");
-  const skillDir = path9.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path9.join(skillDir, "SKILL.md");
+  const packConfigPath = path13.resolve(rootDir, "skillpack.json");
+  const skillDir = path13.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path13.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs9.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs9.readdirSync(srcDir, { withFileTypes: true })) {
+    fs13.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs13.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path9.join(srcDir, entry.name);
-      const destPath = path9.join(destDir, entry.name);
+      const srcPath = path13.join(srcDir, entry.name);
+      const destPath = path13.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -2835,17 +3418,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs9.readFileSync(srcPath, "utf-8");
-        fs9.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs13.readFileSync(srcPath, "utf-8");
+        fs13.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs9.copyFileSync(srcPath, destPath);
+      fs13.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs9.existsSync(skillDir)) {
+  if (!fs13.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs9.existsSync(skillPath)) {
+  if (!fs13.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -2873,11 +3456,11 @@ function overrideBuiltinSkillCreator(base, materializedSkill) {
   };
 }
 function readOptionalPackPromptFile(filePath) {
-  if (!fs9.existsSync(filePath)) {
+  if (!fs13.existsSync(filePath)) {
     return void 0;
   }
   try {
-    const content = fs9.readFileSync(filePath, "utf-8").trim();
+    const content = fs13.readFileSync(filePath, "utf-8").trim();
     return content.length > 0 ? content : void 0;
   } catch (error) {
     console.warn(`[PackAgent] Warning: Could not read ${filePath}:`, error);
@@ -2885,8 +3468,8 @@ function readOptionalPackPromptFile(filePath) {
   }
 }
 function buildPackPromptBlock(rootDir) {
-  const agentsPath = path9.resolve(rootDir, PACK_AGENTS_FILE);
-  const soulPath = path9.resolve(rootDir, PACK_SOUL_FILE);
+  const agentsPath = path13.resolve(rootDir, PACK_AGENTS_FILE);
+  const soulPath = path13.resolve(rootDir, PACK_SOUL_FILE);
   const agentsContent = readOptionalPackPromptFile(agentsPath);
   const soulContent = readOptionalPackPromptFile(soulPath);
   if (!agentsContent && !soulContent) {
@@ -2945,14 +3528,13 @@ var PackAgent = class {
   options;
   channels = /* @__PURE__ */ new Map();
   pendingSessionCreations = /* @__PURE__ */ new Map();
-  fileOutputCallbackRef = {
-    current: null
-  };
   schedulerRef = { current: null };
   authStorage;
+  artifactPersistenceService;
   constructor(options) {
     this.options = options;
-    const configPath = path9.resolve(options.rootDir, "data", "config.json");
+    this.artifactPersistenceService = options.artifactPersistenceService;
+    const configPath = path13.resolve(options.rootDir, "data", "config.json");
     const backend = new ConfigFileAuthBackend(configPath);
     this.authStorage = AuthStorage.fromStorage(backend);
     const providerMeta = SUPPORTED_PROVIDERS[options.provider];
@@ -2979,9 +3561,12 @@ var PackAgent = class {
   setScheduler(scheduler) {
     this.schedulerRef.current = scheduler;
   }
-  createCustomTools(adapter, channelId) {
-    const tools = [createSendFileTool(this.fileOutputCallbackRef)];
-    if (adapter === "telegram" || adapter === "slack") {
+  createCustomTools(adapter, channelId, fileOutputCallbackRef, finalArtifactsSaveCallbackRef) {
+    const tools = [
+      createSendFileTool(fileOutputCallbackRef),
+      createSaveArtifactsTool(this.options.rootDir, finalArtifactsSaveCallbackRef)
+    ];
+    if (adapter !== "scheduler") {
       tools.push(createManageScheduleTool(this.schedulerRef, adapter, channelId));
     }
     return tools;
@@ -3023,24 +3608,24 @@ var PackAgent = class {
       if (resolvedModel && baseUrl) {
         log(`[PackAgent] Resolved ${provider}/${modelId} api=${resolvedModel.api} baseUrl=${baseUrl}`);
       }
-      const sessionDir = path9.resolve(
+      const sessionDir = path13.resolve(
         rootDir,
         "data",
         "sessions",
         channelId
       );
-      fs9.mkdirSync(sessionDir, { recursive: true });
+      fs13.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path9.resolve(
+      const workspaceDir = path13.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs9.mkdirSync(workspaceDir, { recursive: true });
+      fs13.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path9.resolve(rootDir, "skills");
+      const skillsPath = path13.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -3075,7 +3660,18 @@ var PackAgent = class {
       });
       await resourceLoader.reload();
       const tools = createCodingTools(workspaceDir);
-      const customTools = this.createCustomTools(adapter, channelId);
+      const fileOutputCallbackRef = {
+        current: null
+      };
+      const finalArtifactsSaveCallbackRef = {
+        current: null
+      };
+      const customTools = this.createCustomTools(
+        adapter,
+        channelId,
+        fileOutputCallbackRef,
+        finalArtifactsSaveCallbackRef
+      );
       const { session } = await createAgentSession({
         cwd: workspaceDir,
         authStorage,
@@ -3089,7 +3685,9 @@ var PackAgent = class {
       const channelSession = {
         session,
         running: false,
-        pending: Promise.resolve()
+        pending: Promise.resolve(),
+        fileOutputCallbackRef,
+        finalArtifactsSaveCallbackRef
       };
       this.channels.set(channelId, channelSession);
       return channelSession;
@@ -3106,86 +3704,97 @@ var PackAgent = class {
     const run = async () => {
       cs.running = true;
       let turnHadVisibleOutput = false;
-      this.fileOutputCallbackRef.current = (event) => {
-        onEvent(event);
-      };
-      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(`
+      const runId = randomUUID3();
+      let unsubscribe = () => void 0;
+      try {
+        cs.fileOutputCallbackRef.current = (event) => {
+          onEvent(event);
+        };
+        cs.finalArtifactsSaveCallbackRef.current = (artifacts) => {
+          return this.artifactPersistenceService.saveArtifacts({
+            runId,
+            channelId,
+            artifacts
+          });
+        };
+        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") {
+              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 diagnostics2 = getAssistantDiagnostics(event.message);
+                if (diagnostics2) {
+                  log(
+                    `[Assistant Diagnostics] stopReason=${diagnostics2.stopReason} text=${diagnostics2.hasText ? "yes" : "no"} toolCalls=${diagnostics2.toolCalls}`
+                  );
+                  if (diagnostics2.errorMessage) {
+                    log(`[Assistant Error] ${diagnostics2.errorMessage}`);
+                  }
+                }
+              }
+              onEvent({ type: "message_end", role: event.message?.role ?? "" });
+              break;
+            case "tool_execution_start":
               turnHadVisibleOutput = true;
-              write(event.assistantMessageEvent.delta);
+              log(`
+>>> [Tool Start: ${event.toolName}] >>>`);
+              log("Args:", JSON.stringify(event.args, null, 2));
               onEvent({
-                type: "text_delta",
-                delta: event.assistantMessageEvent.delta
+                type: "tool_start",
+                toolCallId: event.toolCallId ?? "",
+                toolName: event.toolName,
+                toolInput: event.args
               });
-            } else if (event.assistantMessageEvent?.type === "thinking_delta") {
+              break;
+            case "tool_execution_end":
               turnHadVisibleOutput = true;
+              log(`<<< [Tool End: ${event.toolName}] <<<`);
+              log(`Error: ${event.isError ? "Yes" : "No"}`);
               onEvent({
-                type: "thinking_delta",
-                delta: event.assistantMessageEvent.delta
+                type: "tool_end",
+                toolCallId: event.toolCallId ?? "",
+                toolName: event.toolName,
+                isError: event.isError,
+                result: event.result
               });
-            }
-            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 {
+              break;
+            case "agent_end":
+              log("\n=== [AGENT SESSION END] ===\n");
+              onEvent({ type: "agent_end" });
+              break;
+          }
+        });
         let promptText = text;
         const promptOptions = {};
         if (attachments && attachments.length > 0) {
@@ -3213,15 +3822,17 @@ ${text}`;
           };
         }
         if (diagnostics && !diagnostics.hasText && diagnostics.toolCalls === 0 && !turnHadVisibleOutput) {
+          const errorMessage = "Assistant returned no visible output. Check the server logs for details.";
           return {
             stopReason: diagnostics.stopReason,
-            errorMessage: "Assistant returned no visible output. Check the server logs for details."
+            errorMessage
           };
         }
         return { stopReason: diagnostics?.stopReason ?? "unknown" };
       } finally {
         cs.running = false;
-        this.fileOutputCallbackRef.current = null;
+        cs.fileOutputCallbackRef.current = null;
+        cs.finalArtifactsSaveCallbackRef.current = null;
         unsubscribe();
       }
     };
@@ -3241,9 +3852,9 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path9.resolve(rootDir, "data", "sessions", channelId);
-        if (fs9.existsSync(sessionDir)) {
-          fs9.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path13.resolve(rootDir, "data", "sessions", channelId);
+        if (fs13.existsSync(sessionDir)) {
+          fs13.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
         return {
@@ -3265,42 +3876,437 @@ ${text}`;
         return { success: false, message: `Unknown command: ${command}` };
     }
   }
-  abort(channelId) {
-    const cs = this.channels.get(channelId);
-    if (cs?.running) {
-      cs.session.abort?.();
+  abort(channelId) {
+    const cs = this.channels.get(channelId);
+    if (cs?.running) {
+      cs.session.abort?.();
+    }
+  }
+  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) {
+  }
+  getActiveChannelIds() {
+    return Array.from(this.channels.keys());
+  }
+};
+
+// src/runtime/adapters/web.ts
+import fs15 from "fs";
+import path15 from "path";
+import { WebSocketServer } from "ws";
+init_commands();
+
+// src/runtime/services/conversation.ts
+import fs14 from "fs";
+import path14 from "path";
+import {
+  parseSessionEntries
+} from "@mariozechner/pi-coding-agent";
+var DEFAULT_WEB_CHANNEL_ID = "web";
+var ConversationService = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Scan data/sessions and return conversation summaries sorted by recency.
+   */
+  listConversations(activeChannels, options = {}) {
+    const {
+      includeDefaultWeb = false,
+      includeLegacyWeb = true,
+      allowedPlatforms
+    } = options;
+    const sessionsDir = path14.resolve(this.rootDir, "data", "sessions");
+    const channelIds = new Set(activeChannels);
+    const allowedPlatformSet = allowedPlatforms ? new Set(allowedPlatforms) : null;
+    if (includeDefaultWeb) {
+      channelIds.add(DEFAULT_WEB_CHANNEL_ID);
+    }
+    if (fs14.existsSync(sessionsDir)) {
+      for (const entry of fs14.readdirSync(sessionsDir)) {
+        const channelDir = path14.join(sessionsDir, entry);
+        try {
+          if (!fs14.statSync(channelDir).isDirectory()) {
+            continue;
+          }
+          const platform = this.detectPlatform(entry);
+          if (allowedPlatformSet && !allowedPlatformSet.has(platform)) {
+            continue;
+          }
+          if (!includeLegacyWeb && this.isLegacyWebConversation(entry)) {
+            continue;
+          }
+          channelIds.add(entry);
+        } catch {
+        }
+      }
+    }
+    const results = [];
+    for (const channelId of channelIds) {
+      const platform = this.detectPlatform(channelId);
+      if (allowedPlatformSet && !allowedPlatformSet.has(platform)) {
+        continue;
+      }
+      if (!includeLegacyWeb && this.isLegacyWebConversation(channelId)) {
+        continue;
+      }
+      const channelDir = path14.join(sessionsDir, channelId);
+      const sessionFile = this.findLatestSessionFile(channelDir);
+      let messageCount = 0;
+      let lastMessageAt = "";
+      let lastMessagePreview = "";
+      if (sessionFile) {
+        const entries = this.loadEntries(sessionFile);
+        const messages = entries.filter(
+          (entry) => entry.type === "message"
+        );
+        messageCount = messages.length;
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage) {
+          lastMessageAt = lastMessage.timestamp;
+          lastMessagePreview = this.extractTextPreview(lastMessage, 100);
+        }
+      }
+      results.push({
+        channelId,
+        platform,
+        sessionFile,
+        messageCount,
+        lastMessageAt,
+        lastMessagePreview
+      });
+    }
+    return results.sort((a, b) => {
+      if (a.channelId === DEFAULT_WEB_CHANNEL_ID && b.channelId !== DEFAULT_WEB_CHANNEL_ID) {
+        return -1;
+      }
+      if (b.channelId === DEFAULT_WEB_CHANNEL_ID && a.channelId !== DEFAULT_WEB_CHANNEL_ID) {
+        return 1;
+      }
+      const recency = (b.lastMessageAt || "").localeCompare(
+        a.lastMessageAt || ""
+      );
+      if (recency !== 0) return recency;
+      return a.channelId.localeCompare(b.channelId);
+    });
+  }
+  /**
+   * Load latest messages for a channel in a simplified format.
+   */
+  getMessages(channelId, limit = 100) {
+    const channelDir = path14.resolve(
+      this.rootDir,
+      "data",
+      "sessions",
+      channelId
+    );
+    const sessionFile = this.findLatestSessionFile(channelDir);
+    if (!sessionFile) return [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 100;
+    if (safeLimit === 0) return [];
+    const entries = this.loadEntries(sessionFile);
+    const toolResultsById = this.collectToolResultStates(entries);
+    const messages = [];
+    let pendingBlocks = [];
+    let pendingToolCalls = [];
+    let pendingMessageId = "";
+    let pendingTimestamp = "";
+    const flushPendingAssistant = () => {
+      if (pendingBlocks.length === 0 && pendingToolCalls.length === 0) {
+        return;
+      }
+      messages.push({
+        id: pendingMessageId || `assistant-${messages.length + 1}`,
+        role: "assistant",
+        text: "",
+        timestamp: pendingTimestamp || (/* @__PURE__ */ new Date(0)).toISOString(),
+        toolCalls: pendingToolCalls.length > 0 ? pendingToolCalls : void 0,
+        blocks: pendingBlocks.length > 0 ? pendingBlocks : void 0
+      });
+      pendingBlocks = [];
+      pendingToolCalls = [];
+      pendingMessageId = "";
+      pendingTimestamp = "";
+    };
+    for (const entry of entries) {
+      if (entry.type !== "message") continue;
+      const role = entry.message?.role;
+      if (role === "user") {
+        flushPendingAssistant();
+        const text2 = this.extractText(entry.message);
+        if (!text2) continue;
+        messages.push({
+          id: entry.id,
+          role,
+          text: text2,
+          timestamp: entry.timestamp
+        });
+        continue;
+      }
+      if (role !== "assistant") continue;
+      const text = this.extractText(entry.message);
+      const toolCalls = this.extractToolCalls(entry.message, toolResultsById);
+      const blocks = this.extractBlocks(
+        entry.id,
+        entry.message,
+        toolResultsById
+      );
+      if (!text) {
+        if (blocks.length > 0) {
+          pendingBlocks = [...pendingBlocks, ...blocks];
+        }
+        if (toolCalls?.length) {
+          pendingToolCalls = this.mergeToolCalls(pendingToolCalls, toolCalls);
+        }
+        if (!pendingMessageId) {
+          pendingMessageId = entry.id;
+          pendingTimestamp = entry.timestamp;
+        }
+        continue;
+      }
+      const mergedBlocks = pendingBlocks.length > 0 ? [...pendingBlocks, ...blocks] : blocks;
+      const mergedToolCalls = this.mergeToolCalls(pendingToolCalls, toolCalls);
+      messages.push({
+        id: entry.id,
+        role,
+        text,
+        timestamp: entry.timestamp,
+        toolCalls: mergedToolCalls.length > 0 ? mergedToolCalls : void 0,
+        blocks: mergedBlocks.length > 0 ? mergedBlocks : void 0
+      });
+      pendingBlocks = [];
+      pendingToolCalls = [];
+      pendingMessageId = "";
+      pendingTimestamp = "";
+    }
+    flushPendingAssistant();
+    return messages.slice(-safeLimit);
+  }
+  findLatestSessionFile(channelDir) {
+    if (!fs14.existsSync(channelDir)) return null;
+    let stats;
+    try {
+      stats = fs14.statSync(channelDir);
+    } catch {
+      return null;
+    }
+    if (!stats.isDirectory()) return null;
+    const files = fs14.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path14.join(channelDir, files[0]) : null;
+  }
+  loadEntries(filePath) {
+    try {
+      const content = fs14.readFileSync(filePath, "utf-8");
+      const fileEntries = parseSessionEntries(content);
+      return fileEntries.filter(
+        (entry) => entry.type !== "session"
+      );
+    } catch (err) {
+      console.warn(`[ConversationService] Failed to load ${filePath}:`, err);
+      return [];
+    }
+  }
+  extractText(message) {
+    if (!message?.content) return "";
+    if (typeof message.content === "string") return message.content.trim();
+    if (!Array.isArray(message.content)) return "";
+    return message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  }
+  extractTextPreview(entry, maxLen) {
+    const text = this.extractText(entry.message);
+    return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+  }
+  collectToolResultStates(entries) {
+    const toolResultsById = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (entry.type !== "message") continue;
+      if (entry.message?.role !== "toolResult") continue;
+      if (typeof entry.message?.toolCallId !== "string" || !entry.message.toolCallId) {
+        continue;
+      }
+      toolResultsById.set(entry.message.toolCallId, {
+        isError: entry.message?.isError === true,
+        result: this.extractToolResultValue(entry.message)
+      });
+    }
+    return toolResultsById;
+  }
+  extractToolCalls(message, toolResultsById) {
+    if (!Array.isArray(message?.content)) return void 0;
+    const toolCalls = message.content.filter((item) => item?.type === "toolCall").map((item) => {
+      const id = typeof item?.id === "string" && item.id ? item.id : "unknown";
+      const name = typeof item?.name === "string" && item.name ? item.name : "unknown";
+      const toolCall = {
+        id,
+        name,
+        isError: toolResultsById.get(id)?.isError === true
+      };
+      if (name === "send_file") {
+        const args = this.extractSendFileArguments(item?.arguments);
+        if (args) {
+          toolCall.arguments = args;
+        }
+      }
+      return toolCall;
+    });
+    return toolCalls.length > 0 ? toolCalls : void 0;
+  }
+  extractBlocks(messageId, message, toolResultsById) {
+    if (!Array.isArray(message?.content)) {
+      return [];
+    }
+    const blocks = [];
+    message.content.forEach((item, index) => {
+      if (item?.type === "thinking") {
+        const thinkingText = this.extractThinkingText(item);
+        if (thinkingText) {
+          blocks.push({
+            id: `${messageId}-thinking-${index}`,
+            type: "thinking",
+            text: thinkingText
+          });
+        }
+        return;
+      }
+      if (item?.type !== "toolCall") {
+        return;
+      }
+      const toolCallId = typeof item?.id === "string" && item.id ? item.id : `${messageId}-tool-${index}`;
+      const toolName = typeof item?.name === "string" && item.name ? item.name : "unknown";
+      const toolResult = toolResultsById.get(toolCallId);
+      const sendFileArgs = toolName === "send_file" ? this.extractSendFileArguments(item?.arguments) : void 0;
+      if (toolName === "send_file" && !toolResult?.isError && sendFileArgs?.filePath) {
+        blocks.push({
+          id: toolCallId,
+          type: "file",
+          filename: this.getFileBaseName(sendFileArgs.filePath),
+          filePath: sendFileArgs.filePath,
+          caption: sendFileArgs.caption
+        });
+        return;
+      }
+      blocks.push({
+        id: toolCallId,
+        type: "tool",
+        toolCallId,
+        toolName,
+        toolInput: item?.arguments,
+        result: toolResult?.result,
+        isError: toolResult?.isError === true,
+        status: toolResult ? "done" : "running"
+      });
+    });
+    return blocks;
+  }
+  extractThinkingText(item) {
+    if (typeof item?.thinking === "string" && item.thinking.trim()) {
+      return item.thinking.trim();
+    }
+    if (typeof item?.thinkingSignature !== "string" || !item.thinkingSignature) {
+      return "";
+    }
+    try {
+      const parsed = JSON.parse(item.thinkingSignature);
+      if (!Array.isArray(parsed?.summary)) {
+        return "";
+      }
+      return parsed.summary.map(
+        (summaryItem) => typeof summaryItem?.text === "string" ? summaryItem.text.trim() : ""
+      ).filter(Boolean).join("\n\n").trim();
+    } catch {
+      return "";
+    }
+  }
+  extractToolResultValue(message) {
+    if (!message?.content) {
+      return void 0;
+    }
+    if (typeof message.content === "string") {
+      return this.parsePossibleJson(message.content);
+    }
+    if (!Array.isArray(message.content)) {
+      return message.content;
+    }
+    const textContent = message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+    if (textContent) {
+      return this.parsePossibleJson(textContent);
+    }
+    return message.content;
+  }
+  parsePossibleJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return "";
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed;
+    }
+  }
+  extractSendFileArguments(rawArguments) {
+    if (!rawArguments || typeof rawArguments !== "object") {
+      return void 0;
     }
+    const maybeArgs = rawArguments;
+    const filePath = typeof maybeArgs.filePath === "string" && maybeArgs.filePath ? maybeArgs.filePath : void 0;
+    const caption = typeof maybeArgs.caption === "string" && maybeArgs.caption ? maybeArgs.caption : void 0;
+    if (!filePath && !caption) {
+      return void 0;
+    }
+    return {
+      filePath,
+      caption
+    };
   }
-  isRunning(channelId) {
-    return this.channels.get(channelId)?.running ?? false;
+  hasVisibleSendFileToolCall(toolCalls) {
+    return Boolean(
+      toolCalls?.some(
+        (toolCall) => toolCall.name === "send_file" && !toolCall.isError && typeof toolCall.arguments?.filePath === "string" && toolCall.arguments.filePath.length > 0
+      )
+    );
   }
-  dispose(channelId) {
-    const cs = this.channels.get(channelId);
-    if (cs) {
-      cs.session.dispose();
-      this.channels.delete(channelId);
+  mergeToolCalls(left, right) {
+    const merged = [...left || [], ...right || []];
+    const byId = /* @__PURE__ */ new Map();
+    for (const toolCall of merged) {
+      byId.set(toolCall.id, toolCall);
     }
+    return [...byId.values()];
   }
-  /** Reserved: list all sessions */
-  listSessions() {
-    return [];
+  getFileBaseName(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const parts = normalized.split("/").filter(Boolean);
+    return parts[parts.length - 1] || filePath;
   }
-  /** Reserved: restore a historical session */
-  async restoreSession(_sessionId) {
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
   }
-  getActiveChannelIds() {
-    return Array.from(this.channels.keys());
+  isLegacyWebConversation(channelId) {
+    return channelId.startsWith("web-");
   }
 };
 
 // src/runtime/adapters/web.ts
-init_config();
-init_commands();
-import fs10 from "fs";
-import path10 from "path";
-import { WebSocketServer } from "ws";
 function getPackConfig(rootDir) {
-  const raw = fs10.readFileSync(path10.join(rootDir, "skillpack.json"), "utf-8");
+  const raw = fs15.readFileSync(path15.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
 function parseCommand(text) {
@@ -3322,15 +4328,30 @@ function getRuntimeConfigSignature(config) {
     slackAppToken: config.adapters?.slack?.appToken || ""
   });
 }
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.floor(parsed);
+}
+function resolveDownloadFilePath(rootDir, filePath) {
+  const resolvedPath = path15.isAbsolute(filePath) ? path15.resolve(filePath) : path15.resolve(rootDir, filePath);
+  return isWithinDirectory(rootDir, resolvedPath) ? resolvedPath : null;
+}
 var WebAdapter = class {
   name = "web";
   wss = null;
   agent = null;
   ipcBroadcaster = null;
+  conversationService = null;
+  socketsByChannel = /* @__PURE__ */ new Map();
   async start(ctx) {
     const { agent, server, app, rootDir, lifecycle } = ctx;
     this.agent = agent;
     this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
+    this.conversationService = new ConversationService(rootDir);
+    const resultsQueryService = ctx.resultsQueryService ?? null;
     const currentConf = configManager.getConfig();
     let apiKey = currentConf.apiKey || "";
     let currentProvider = currentConf.provider || "openai";
@@ -3448,12 +4469,42 @@ var WebAdapter = class {
     app.delete("/api/chat", (_req, res) => {
       res.json({ success: true });
     });
-    app.get("/api/sessions", (_req, res) => {
-      const sessions = agent.listSessions();
-      res.json(sessions);
+    const getWebConversations = () => {
+      const activeChannels = new Set(agent.getActiveChannelIds());
+      return this.conversationService.listConversations(activeChannels, {
+        includeDefaultWeb: true,
+        includeLegacyWeb: false,
+        allowedPlatforms: ["web"]
+      });
+    };
+    app.get("/api/conversations", (_req, res) => {
+      res.json(getWebConversations());
+    });
+    app.post("/api/conversations", (_req, res) => {
+      res.json({ channelId: DEFAULT_WEB_CHANNEL_ID });
+    });
+    app.get("/api/conversations/:channelId/messages", (req, res) => {
+      if (req.params.channelId !== DEFAULT_WEB_CHANNEL_ID) {
+        res.status(404).json({ error: "Conversation not found" });
+        return;
+      }
+      res.json(
+        this.conversationService.getMessages(
+          req.params.channelId,
+          parsePositiveInt(req.query.limit, 100)
+        )
+      );
     });
-    app.get("/api/sessions/:id", (_req, res) => {
-      res.status(501).json({ error: "Not implemented yet" });
+    app.get("/api/results/artifacts", (req, res) => {
+      if (!resultsQueryService) {
+        res.status(503).json({ error: "Results query service is not available" });
+        return;
+      }
+      res.json(resultsQueryService.listRecentArtifacts({
+        channelId: typeof req.query.channelId === "string" ? req.query.channelId : void 0,
+        limit: parsePositiveInt(req.query.limit, 100),
+        offset: parsePositiveInt(req.query.offset, 0)
+      }));
     });
     app.get("/api/files", (req, res) => {
       const filePath = req.query.path;
@@ -3461,23 +4512,22 @@ var WebAdapter = class {
         res.status(400).json({ error: "Missing 'path' query parameter" });
         return;
       }
-      const resolvedPath = path10.resolve(filePath);
-      const dataDir = path10.resolve(rootDir, "data");
-      if (!resolvedPath.startsWith(dataDir)) {
+      const resolvedPath = resolveDownloadFilePath(rootDir, filePath);
+      if (!resolvedPath) {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (!fs10.existsSync(resolvedPath)) {
+      if (!fs15.existsSync(resolvedPath)) {
         res.status(404).json({ error: "File not found" });
         return;
       }
-      const filename = path10.basename(resolvedPath);
+      const filename = path15.basename(resolvedPath);
       res.setHeader("Content-Type", "application/octet-stream");
       res.setHeader(
         "Content-Disposition",
         `attachment; filename="${filename}"`
       );
-      fs10.createReadStream(resolvedPath).pipe(res);
+      fs15.createReadStream(resolvedPath).pipe(res);
     });
     const getScheduler = () => {
       const schedulerAdapter = ctx.adapterMap?.get("scheduler");
@@ -3571,7 +4621,8 @@ var WebAdapter = class {
         ws.close();
         return;
       }
-      const channelId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const requestedChannelId = url.searchParams.get("channelId");
+      const channelId = requestedChannelId && requestedChannelId === DEFAULT_WEB_CHANNEL_ID ? requestedChannelId : DEFAULT_WEB_CHANNEL_ID;
       this.handleWsConnection(ws, channelId, agent);
     });
     console.log("[WebAdapter] Started");
@@ -3584,12 +4635,29 @@ var WebAdapter = class {
       this.wss.close();
       this.wss = null;
     }
+    this.socketsByChannel.clear();
     console.log("[WebAdapter] Stopped");
   }
+  async sendMessage(channelId, text) {
+    const sockets = this.socketsByChannel.get(channelId);
+    const activeSockets = [...sockets || []].filter(
+      (socket) => socket.readyState === socket.OPEN
+    );
+    if (activeSockets.length === 0) {
+      throw new Error(`[Web] No active WebSocket clients for channelId: ${channelId}`);
+    }
+    for (const socket of activeSockets) {
+      sendWsEvent(socket, { type: "message_start", role: "assistant" });
+      sendWsEvent(socket, { type: "text_delta", delta: text });
+      sendWsEvent(socket, { type: "message_end", role: "assistant" });
+      socket.send(JSON.stringify({ done: true }));
+    }
+  }
   // -------------------------------------------------------------------------
   // WebSocket message handler
   // -------------------------------------------------------------------------
   handleWsConnection(ws, channelId, agent) {
+    this.addSocket(channelId, ws);
     ws.on("message", async (data) => {
       try {
         const payload = JSON.parse(data.toString());
@@ -3619,154 +4687,27 @@ var WebAdapter = class {
       }
     });
     ws.on("close", () => {
-      agent.dispose(channelId);
-    });
-  }
-};
-
-// src/runtime/adapters/ipc.ts
-init_config();
-
-// src/runtime/services/conversation.ts
-import fs11 from "fs";
-import path11 from "path";
-import {
-  parseSessionEntries
-} from "@mariozechner/pi-coding-agent";
-var ConversationService = class {
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  /**
-   * Scan data/sessions and return conversation summaries sorted by recency.
-   */
-  listConversations(activeChannels) {
-    const sessionsDir = path11.resolve(this.rootDir, "data", "sessions");
-    const channelIds = new Set(activeChannels);
-    if (fs11.existsSync(sessionsDir)) {
-      for (const entry of fs11.readdirSync(sessionsDir)) {
-        const channelDir = path11.join(sessionsDir, entry);
-        try {
-          if (fs11.statSync(channelDir).isDirectory()) {
-            channelIds.add(entry);
-          }
-        } catch {
-        }
-      }
-    }
-    const results = [];
-    for (const channelId of channelIds) {
-      const channelDir = path11.join(sessionsDir, channelId);
-      const sessionFile = this.findLatestSessionFile(channelDir);
-      let messageCount = 0;
-      let lastMessageAt = "";
-      let lastMessagePreview = "";
-      if (sessionFile) {
-        const entries = this.loadEntries(sessionFile);
-        const messages = entries.filter(
-          (entry) => entry.type === "message"
-        );
-        messageCount = messages.length;
-        const lastMessage = messages[messages.length - 1];
-        if (lastMessage) {
-          lastMessageAt = lastMessage.timestamp;
-          lastMessagePreview = this.extractTextPreview(lastMessage, 100);
-        }
+      this.removeSocket(channelId, ws);
+      if (channelId !== DEFAULT_WEB_CHANNEL_ID) {
+        agent.dispose(channelId);
       }
-      results.push({
-        channelId,
-        platform: this.detectPlatform(channelId),
-        sessionFile,
-        messageCount,
-        lastMessageAt,
-        lastMessagePreview
-      });
-    }
-    return results.sort((a, b) => {
-      const recency = (b.lastMessageAt || "").localeCompare(a.lastMessageAt || "");
-      if (recency !== 0) return recency;
-      return a.channelId.localeCompare(b.channelId);
     });
   }
-  /**
-   * Load latest messages for a channel in a simplified format.
-   */
-  getMessages(channelId, limit = 100) {
-    const channelDir = path11.resolve(
-      this.rootDir,
-      "data",
-      "sessions",
-      channelId
-    );
-    const sessionFile = this.findLatestSessionFile(channelDir);
-    if (!sessionFile) return [];
-    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 100;
-    if (safeLimit === 0) return [];
-    const entries = this.loadEntries(sessionFile);
-    const messages = [];
-    for (const entry of entries) {
-      if (entry.type !== "message") continue;
-      const role = entry.message?.role;
-      if (role !== "user" && role !== "assistant") continue;
-      const text = this.extractText(entry.message);
-      if (!text) continue;
-      const toolCalls = role === "assistant" ? this.extractToolCallSummaries(entry.message) : void 0;
-      messages.push({
-        id: entry.id,
-        role,
-        text,
-        timestamp: entry.timestamp,
-        toolCalls
-      });
-    }
-    return messages.slice(-safeLimit);
+  addSocket(channelId, ws) {
+    const sockets = this.socketsByChannel.get(channelId) ?? /* @__PURE__ */ new Set();
+    sockets.add(ws);
+    this.socketsByChannel.set(channelId, sockets);
   }
-  findLatestSessionFile(channelDir) {
-    if (!fs11.existsSync(channelDir)) return null;
-    let stats;
-    try {
-      stats = fs11.statSync(channelDir);
-    } catch {
-      return null;
+  removeSocket(channelId, ws) {
+    const sockets = this.socketsByChannel.get(channelId);
+    if (!sockets) {
+      return;
     }
-    if (!stats.isDirectory()) return null;
-    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
-    return files[0] ? path11.join(channelDir, files[0]) : null;
-  }
-  loadEntries(filePath) {
-    try {
-      const content = fs11.readFileSync(filePath, "utf-8");
-      const fileEntries = parseSessionEntries(content);
-      return fileEntries.filter((entry) => entry.type !== "session");
-    } catch (err) {
-      console.warn(`[ConversationService] Failed to load ${filePath}:`, err);
-      return [];
+    sockets.delete(ws);
+    if (sockets.size === 0) {
+      this.socketsByChannel.delete(channelId);
     }
   }
-  extractText(message) {
-    if (!message?.content) return "";
-    if (typeof message.content === "string") return message.content.trim();
-    if (!Array.isArray(message.content)) return "";
-    return message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
-  }
-  extractTextPreview(entry, maxLen) {
-    const text = this.extractText(entry.message);
-    return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
-  }
-  extractToolCallSummaries(message) {
-    if (!Array.isArray(message?.content)) return void 0;
-    const toolCalls = message.content.filter((item) => item?.type === "toolCall").map((item) => ({
-      name: typeof item?.name === "string" && item.name ? item.name : "unknown",
-      isError: false
-    }));
-    return toolCalls.length > 0 ? toolCalls : void 0;
-  }
-  detectPlatform(channelId) {
-    if (channelId.startsWith("telegram-")) return "telegram";
-    if (channelId.startsWith("slack-")) return "slack";
-    if (channelId.startsWith("scheduler-")) return "scheduler";
-    return "web";
-  }
 };
 
 // src/runtime/adapters/ipc.ts
@@ -3777,6 +4718,7 @@ var IpcAdapter = class {
   rootDir = "";
   adapterMap = null;
   conversationService = null;
+  resultsQueryService = null;
   createdChannels = /* @__PURE__ */ new Set();
   messageListener;
   started = false;
@@ -3788,6 +4730,7 @@ var IpcAdapter = class {
     this.rootDir = ctx.rootDir;
     this.adapterMap = ctx.adapterMap ?? null;
     this.conversationService = new ConversationService(ctx.rootDir);
+    this.resultsQueryService = ctx.resultsQueryService ?? null;
     this.messageListener = (message) => {
       if (!this.isIpcRequest(message)) return;
       void this.handleRequest(message);
@@ -3846,12 +4789,15 @@ var IpcAdapter = class {
           for (const channelId of this.createdChannels) {
             activeChannels.add(channelId);
           }
-          const conversations = this.conversationService.listConversations(activeChannels);
+          const conversations = this.conversationService.listConversations(activeChannels, {
+            includeDefaultWeb: true,
+            includeLegacyWeb: false
+          });
           this.reply(request.id, conversations);
           return;
         }
         case "create_conversation": {
-          const channelId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          const channelId = DEFAULT_WEB_CHANNEL_ID;
           this.createdChannels.add(channelId);
           this.reply(request.id, { channelId });
           return;
@@ -3868,6 +4814,18 @@ var IpcAdapter = class {
           this.reply(request.id, messages);
           return;
         }
+        case "get_recent_artifacts": {
+          if (!this.resultsQueryService) {
+            this.replyError(request.id, "Results query service is not available");
+            return;
+          }
+          this.reply(request.id, this.resultsQueryService.listRecentArtifacts({
+            channelId: request.channelId,
+            limit: request.limit,
+            offset: request.offset
+          }));
+          return;
+        }
         case "send_message": {
           if (!request.channelId || typeof request.channelId !== "string") {
             this.replyError(request.id, "channelId is required");
@@ -3950,6 +4908,48 @@ var IpcAdapter = class {
           this.reply(request.id, result);
           return;
         }
+        case "update_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.updateJob(request.name, request.updates);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+        case "set_scheduled_job_enabled": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.setEnabled(request.name, request.enabled);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+        case "trigger_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = await scheduler.triggerJob(request.name);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
         case "remove_scheduled_job": {
           const scheduler = this.getSchedulerAdapter();
           if (!scheduler) {
@@ -3996,9 +4996,6 @@ var IpcAdapter = class {
   }
 };
 
-// src/runtime/server.ts
-init_config();
-
 // src/runtime/lifecycle.ts
 var SHUTDOWN_EXIT_CODE = 64;
 var RESTART_EXIT_CODE = 75;
@@ -4072,28 +5069,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs12 from "fs";
+import fs16 from "fs";
 import os from "os";
-import path12 from "path";
-var SKILLPACK_HOME = path12.join(os.homedir(), ".skillpack");
-var LEGACY_REGISTRY_FILE = path12.join(SKILLPACK_HOME, "registry.json");
-var REGISTRY_DIR = path12.join(SKILLPACK_HOME, "registry.d");
+import path16 from "path";
+var SKILLPACK_HOME = path16.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path16.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path16.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs12.existsSync(SKILLPACK_HOME)) {
-    fs12.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs16.existsSync(SKILLPACK_HOME)) {
+    fs16.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs12.existsSync(REGISTRY_DIR)) {
-    fs12.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs16.existsSync(REGISTRY_DIR)) {
+    fs16.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path12.resolve(dir);
+  const resolved = path16.resolve(dir);
   try {
-    return fs12.realpathSync(resolved);
+    return fs16.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -4102,7 +5099,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path12.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path16.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -4110,11 +5107,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs12.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path12.join(REGISTRY_DIR, file));
+  return fs16.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path16.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs12.readFileSync(filePath, "utf-8");
+    const raw = fs16.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
       return null;
@@ -4147,8 +5144,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs12.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs12.renameSync(tmpPath, entryPath);
+  fs16.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs16.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -4156,14 +5153,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs12.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs16.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs12.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs16.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -4176,7 +5173,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs12.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs16.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -4229,13 +5226,13 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path14.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path18.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
     host = process.env.HOST || "127.0.0.1",
     port = Number(process.env.PORT) || 26313,
-    daemonRun = false
+    runtimeMode = process.env.SKILLPACK_RUNTIME_MODE === "embedded" ? "embedded" : "standalone"
   } = options;
   const dataConfig = configManager.load(rootDir);
   const apiKey = dataConfig.apiKey || "";
@@ -4245,8 +5242,8 @@ async function startServer(options) {
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = dataConfig.modelId?.trim() || (SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId);
   const apiProtocol = dataConfig.apiProtocol;
-  const packageRoot = path14.resolve(__dirname, "..");
-  const webDir = fs15.existsSync(path14.join(rootDir, "web")) ? path14.join(rootDir, "web") : path14.join(packageRoot, "web");
+  const packageRoot = path18.resolve(__dirname, "..");
+  const webDir = fs19.existsSync(path18.join(rootDir, "web")) ? path18.join(rootDir, "web") : path18.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -4264,6 +5261,13 @@ async function startServer(options) {
     });
   });
   const lifecycle = new Lifecycle(server);
+  const resultStore = new ResultStore(rootDir);
+  const artifactSnapshotService = new ArtifactSnapshotService(rootDir);
+  const artifactPersistenceService = new ArtifactPersistenceService(
+    artifactSnapshotService,
+    resultStore
+  );
+  const resultsQueryService = new ResultsQueryService(resultStore);
   const agent = new PackAgent({
     apiKey,
     rootDir,
@@ -4271,12 +5275,14 @@ async function startServer(options) {
     modelId,
     baseUrl,
     apiProtocol,
-    lifecycleHandler: lifecycle
+    lifecycleHandler: lifecycle,
+    artifactPersistenceService
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
   const hasIpcChannel = typeof process.send === "function";
   const ipcAdapter = new IpcAdapter();
+  const webEnabled = runtimeMode === "standalone";
   if (hasIpcChannel) {
     await ipcAdapter.start({
       agent,
@@ -4284,24 +5290,28 @@ async function startServer(options) {
       app,
       rootDir,
       lifecycle,
-      adapterMap
+      adapterMap,
+      resultsQueryService
     });
     adapters.push(ipcAdapter);
     adapterMap.set(ipcAdapter.name, ipcAdapter);
   }
   const ipcBroadcaster = hasIpcChannel ? ipcAdapter : void 0;
-  const webAdapter = new WebAdapter();
-  await webAdapter.start({
-    agent,
-    server,
-    app,
-    rootDir,
-    lifecycle,
-    adapterMap,
-    ipcBroadcaster
-  });
-  adapters.push(webAdapter);
-  adapterMap.set(webAdapter.name, webAdapter);
+  if (webEnabled) {
+    const webAdapter = new WebAdapter();
+    await webAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      adapterMap,
+      ipcBroadcaster,
+      resultsQueryService
+    });
+    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));
@@ -4315,7 +5325,8 @@ async function startServer(options) {
         rootDir,
         lifecycle,
         adapterMap,
-        ipcBroadcaster
+        ipcBroadcaster,
+        resultsQueryService
       });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
@@ -4343,7 +5354,8 @@ async function startServer(options) {
           rootDir,
           lifecycle,
           adapterMap,
-          ipcBroadcaster
+          ipcBroadcaster,
+          resultsQueryService
         });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
@@ -4363,7 +5375,6 @@ async function startServer(options) {
     }
     await adapter.sendMessage(channelId, text);
   };
-  const scheduledJobs = dataConfig.scheduledJobs || [];
   let schedulerAdapter = null;
   try {
     const { SchedulerAdapter: SchedulerAdapter2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
@@ -4375,13 +5386,11 @@ async function startServer(options) {
       rootDir,
       lifecycle,
       notify: notifyFn,
-      adapterMap
+      adapterMap,
+      resultsQueryService
     });
     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);
   }
@@ -4389,34 +5398,35 @@ async function startServer(options) {
     agent.setScheduler(schedulerAdapter);
   }
   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(`
+  const announceReady = (actualPort) => {
+    if (webEnabled) {
+      const url = `http://${host}:${actualPort}`;
+      console.log(`
   Skills Pack Server`);
-    console.log(`  Running at ${url}
+      console.log(`  Running at ${url}
 `);
-    try {
-      register({
-        dir: canonicalRootDir,
-        name: packConfig.name,
-        version: packConfig.version,
-        port: typeof actualPort === "number" ? actualPort : port
-      });
-    } catch (err) {
-      console.warn("  [Registry] Could not register pack:", err);
-    }
-    if (hasIpcChannel) {
-      ipcAdapter.notifyReady(typeof actualPort === "number" ? actualPort : port);
-    }
-    if (!daemonRun) {
+      try {
+        register({
+          dir: canonicalRootDir,
+          name: packConfig.name,
+          version: packConfig.version,
+          port: actualPort
+        });
+      } catch (err) {
+        console.warn("  [Registry] Could not register pack:", err);
+      }
       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}`);
       });
+    } else {
+      console.log("\n  Skills Pack Server");
+      console.log("  Running in embedded mode (IPC only)\n");
     }
-  });
+    if (hasIpcChannel) {
+      ipcAdapter.notifyReady(actualPort);
+    }
+  };
   process.on("SIGINT", () => {
     deregister(canonicalRootDir, process.pid);
     void lifecycle.requestShutdown("signal");
@@ -4425,22 +5435,30 @@ async function startServer(options) {
     deregister(canonicalRootDir, process.pid);
     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);
-  });
+  if (webEnabled) {
+    const actualPort = 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", () => {
+          const address = server.address();
+          resolve(typeof address === "string" ? listenPort : address?.port ?? listenPort);
+        });
+      }
+      tryListen(port);
+    });
+    announceReady(actualPort);
+  } else {
+    announceReady(0);
+  }
   await new Promise(() => {
   });
 }
@@ -4457,23 +5475,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path15.resolve(
+  const templateDir = path19.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path15.join(templateDir, file);
-    const dest = path15.join(workDir, file);
-    if (fs16.existsSync(src)) {
-      fs16.copyFileSync(src, dest);
+    const src = path19.join(templateDir, file);
+    const dest = path19.join(workDir, file);
+    if (fs20.existsSync(src)) {
+      fs20.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs16.chmodSync(dest, 493);
+        fs20.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path15.resolve(directory) : process.cwd();
-  fs16.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path19.resolve(directory) : process.cwd();
+  fs20.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([
@@ -4512,20 +5530,19 @@ async function runCommand(directory) {
   syncSkillDescriptions(workDir, config);
   saveConfig(workDir, config);
   await startServer({
-    rootDir: workDir,
-    daemonRun: process.env.DAEMON_RUN === "1"
+    rootDir: workDir
   });
 }
 
 // src/cli.ts
-import fs17 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var packageJson = JSON.parse(
-  fs17.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs21.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
-var cliFilePath = path16.resolve(fileURLToPath3(import.meta.url));
+var cliFilePath = path20.resolve(fileURLToPath3(import.meta.url));
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);
 program.command("create [directory]").description("Create a skills pack interactively").option("--config <path-or-url>", "Initialize from a local or remote skillpack.json").action(async (directory, options) => {
   await createCommand(directory, options);
@@ -4535,7 +5552,7 @@ program.command("run [directory]").description("Start the SkillPack runtime serv
   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 () => {
+program.command("zip").description("Package the current pack as a zip file (skillpack.json + optional job.json + skills/ + start scripts)").action(async () => {
   try {
     await zipCommand(process.cwd());
   } catch (err) {
@@ -4546,7 +5563,7 @@ program.command("zip").description("Package the current pack as a zip file (skil
 function normalizeUserArgs(argv) {
   if (argv.length === 0) return argv;
   const firstArg = argv[0];
-  if (firstArg && path16.resolve(firstArg) === cliFilePath) {
+  if (firstArg && path20.resolve(firstArg) === cliFilePath) {
     return argv.slice(1);
   }
   return argv;