npm - @cremini/skillpack - Versions diffs - 1.2.7 → 1.2.9 - Mend

@cremini/skillpack 1.2.7 → 1.2.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/cli.js CHANGED Viewed

@@ -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;
+  }
+  async 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,447 @@ 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;
+  }
+  async saveArtifacts(input) {
+    const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshots = this.snapshotService.createSnapshots(
+      input.runId,
+      input.artifacts,
+      declaredAt
+    );
+    try {
+      await this.resultStore.insertArtifacts({
+        runId: input.runId,
+        channelId: input.channelId,
+        artifacts: snapshots
+      });
+      return snapshots.length;
+    } catch (error) {
+      this.snapshotService.removeSnapshots(
+        snapshots.map((artifact) => artifact.snapshotPath)
+      );
+      throw error;
+    }
+  }
+};
+// src/runtime/artifacts/store.ts
+import fs10 from "fs";
+import path10 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import sqlite3 from "sqlite3";
+function mapArtifactRow(row) {
+  return {
+    artifactId: row.artifact_id,
+    runId: row.run_id,
+    channelId: row.channel_id,
+    originalPath: row.original_path,
+    snapshotPath: row.snapshot_path,
+    fileName: row.file_name,
+    mimeType: row.mime_type,
+    sizeBytes: row.size_bytes,
+    title: row.title,
+    isPrimary: row.is_primary === 1,
+    declaredAt: row.declared_at
+  };
+}
+var ResultStore = class {
+  db = null;
+  ready;
+  constructor(rootDir) {
+    const dataDir = path10.resolve(rootDir, "data");
+    fs10.mkdirSync(dataDir, { recursive: true });
+    this.ready = this.initialize(path10.join(dataDir, "result-v2.db"));
+  }
+  async initialize(databasePath) {
+    this.db = await openDatabase(databasePath);
+    await this.exec("PRAGMA journal_mode = WAL");
+    await this.exec(`
+      CREATE TABLE IF NOT EXISTS artifacts (
+        artifact_id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        channel_id TEXT NOT NULL,
+        original_path TEXT NOT NULL,
+        snapshot_path TEXT NOT NULL,
+        file_name TEXT NOT NULL,
+        mime_type TEXT,
+        size_bytes INTEGER NOT NULL,
+        title TEXT,
+        is_primary INTEGER NOT NULL DEFAULT 0,
+        declared_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_artifacts_channel_declared_at
+      ON artifacts(channel_id, declared_at DESC);
+    `);
+  }
+  async insertArtifacts(input) {
+    await this.ready;
+    if (input.artifacts.length === 0) {
+      return;
+    }
+    const insertArtifact = `
+      INSERT INTO artifacts (
+        artifact_id,
+        run_id,
+        channel_id,
+        original_path,
+        snapshot_path,
+        file_name,
+        mime_type,
+        size_bytes,
+        title,
+        is_primary,
+        declared_at
+      ) VALUES (
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?
+      )
+    `;
+    await this.exec("BEGIN");
+    try {
+      for (const artifact of input.artifacts) {
+        await this.run(insertArtifact, [
+          randomUUID2(),
+          input.runId,
+          input.channelId,
+          artifact.originalPath,
+          artifact.snapshotPath,
+          artifact.fileName,
+          artifact.mimeType ?? null,
+          artifact.sizeBytes,
+          artifact.title ?? null,
+          artifact.isPrimary ? 1 : 0,
+          artifact.declaredAt
+        ]);
+      }
+      await this.exec("COMMIT");
+    } catch (error) {
+      await this.rollback();
+      throw error;
+    }
+  }
+  async listRecentArtifacts(options = {}) {
+    await this.ready;
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (options.channelId) {
+      conditions.push("channel_id = ?");
+      params.push(options.channelId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = await this.all(`
+      SELECT *
+      FROM artifacts
+      ${whereClause}
+      ORDER BY declared_at DESC, rowid DESC
+      LIMIT ? OFFSET ?
+    `, [...params, limit, offset]);
+    return rows.map(mapArtifactRow);
+  }
+  getDatabase() {
+    if (!this.db) {
+      throw new Error("Result store database is not ready");
+    }
+    return this.db;
+  }
+  exec(sql) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.exec(sql, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  run(sql, params = []) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.run(sql, params, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  all(sql, params = []) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.all(sql, params, (error, rows) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(rows);
+      });
+    });
+  }
+  async rollback() {
+    try {
+      await this.exec("ROLLBACK");
+    } catch {
+    }
+  }
+};
+function openDatabase(databasePath) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(databasePath, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(db);
+    });
+  });
+}
+// src/runtime/artifacts/save-artifacts-tool.ts
+import { Type } from "@sinclair/typebox";
+var ArtifactItem = Type.Object({
+  filePath: Type.String({
+    description: "Absolute path to the artifact file. The file must exist, be readable, and be inside the current pack root."
+  }),
+  title: Type.Optional(
+    Type.String({
+      description: "Optional short title shown in the dashboard."
+    })
+  ),
+  isPrimary: Type.Optional(
+    Type.Boolean({
+      description: "Mark this artifact as a primary output."
+    })
+  )
+});
+var SaveArtifactsParams = Type.Object({
+  artifacts: Type.Array(ArtifactItem, {
+    minItems: 1,
+    description: "The artifact files to save for this run."
+  })
+});
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
+}
+function normalizeOptionalText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function createSaveArtifactsTool(rootDir, saveCallbackRef) {
+  return {
+    name: "save_artifacts",
+    label: "Save Artifacts",
+    description: [
+      "Save the final output files produced by this run.",
+      "Always use this for user-facing deliverables that are part of the final result.",
+      "Do not use this for intermediate, temporary, draft, or scratch files.",
+      "Each filePath must be an absolute path inside the current pack root."
+    ].join("\n"),
+    promptSnippet: "save_artifacts: Save final result files for this task. Always call this for user-facing final deliverables, and never for intermediate files. Use absolute paths inside the current pack root.",
+    promptGuidelines: [
+      "Whenever you create a final result file for the user, call `save_artifacts` before finishing the response.",
+      "Do not call `save_artifacts` for intermediate, temporary, draft, or scratch files."
+    ],
+    parameters: SaveArtifactsParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const saveArtifacts = saveCallbackRef.current;
+      if (!saveArtifacts) {
+        throw new Error("Artifact saving is not available for this run.");
+      }
+      const artifacts = params.artifacts.map((artifact) => {
+        const metadata = resolvePackFile(rootDir, artifact.filePath);
+        return {
+          filePath: metadata.resolvedPath,
+          fileName: metadata.fileName,
+          mimeType: metadata.mimeType,
+          sizeBytes: metadata.sizeBytes,
+          title: normalizeOptionalText(artifact.title),
+          isPrimary: artifact.isPrimary === true
+        };
+      });
+      const savedCount = await saveArtifacts(artifacts);
+      return textResult(`Saved ${savedCount} artifact(s).`);
+    }
+  };
+}
+// src/runtime/tools/send-file-tool.ts
+import fs11 from "fs";
+import path11 from "path";
+import { Type as Type2 } from "@sinclair/typebox";
+var SendFileParams = Type2.Object({
+  filePath: Type2.String({
+    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 +3180,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 +3207,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 +3274,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 +3291,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 +3299,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 +3387,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 +3398,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 +3434,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 +3458,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 +3484,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 +3522,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 +3534,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 +3594,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 +3627,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 +3674,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 +3726,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 +3751,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 +3770,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 +3888,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 +3918,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 +3942,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 +4394,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 +4535,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", async (req, res) => {
+      if (!resultsQueryService) {
+        res.status(503).json({ error: "Results query service is not available" });
+        return;
+      }
+      res.json(await resultsQueryService.listRecentArtifacts({
+        channelId: typeof req.query.channelId === "string" ? req.query.channelId : void 0,
+        limit: parsePositiveInt(req.query.limit, 100),
+        offset: parsePositiveInt(req.query.offset, 0)
+      }));
     });
     app.get("/api/files", (req, res) => {
       const filePath = req.query.path;
@@ -3461,23 +4578,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 +4687,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 +4701,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 +4753,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 +4784,7 @@ var IpcAdapter = class {
   rootDir = "";
   adapterMap = null;
   conversationService = null;
+  resultsQueryService = null;
   createdChannels = /* @__PURE__ */ new Set();
   messageListener;
   started = false;
@@ -3788,6 +4796,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 +4855,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 +4880,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, await this.resultsQueryService.listRecentArtifacts({
+            channelId: request.channelId,
+            limit: request.limit,
+            offset: request.offset
+          }));
+          return;
+        }
         case "send_message": {
           if (!request.channelId || typeof request.channelId !== "string") {
             this.replyError(request.id, "channelId is required");
@@ -3950,6 +4974,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 +5062,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 +5135,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 +5165,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 +5173,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 +5210,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 +5219,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 +5239,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 +5292,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 +5308,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 +5327,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 +5341,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 +5356,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 +5391,8 @@ async function startServer(options) {
         rootDir,
         lifecycle,
         adapterMap,
-        ipcBroadcaster
+        ipcBroadcaster,
+        resultsQueryService
       });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
@@ -4343,7 +5420,8 @@ async function startServer(options) {
           rootDir,
           lifecycle,
           adapterMap,
-          ipcBroadcaster
+          ipcBroadcaster,
+          resultsQueryService
         });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
@@ -4363,7 +5441,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 +5452,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 +5464,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 +5501,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 +5541,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 +5596,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 +5618,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 +5629,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;