@cremini/skillpack 1.2.10 → 1.2.11

package/dist/cli.js

@@ -417,7 +417,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs17 from "fs";
+import fs14 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -735,7 +735,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs17.existsSync(filePath)) {
+          if (!fs14.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -755,8 +755,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs18 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path15 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({
@@ -1391,12 +1391,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs18.existsSync(filePath)) {
+          if (!fs15.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path17.basename(filePath);
-          const fileContent = fs18.readFileSync(filePath);
+          const filename = path15.basename(filePath);
+          const fileContent = fs15.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1444,14 +1444,19 @@ var init_scheduler = __esm({
       name = "scheduler";
       agent;
       rootDir = "";
+      ipcBroadcaster = null;
       notifyFn = async () => {
       };
       jobs = /* @__PURE__ */ new Map();
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.notifyFn = ctx.notify || (async () => {
         });
+        console.log(
+          `[Scheduler] IPC broadcaster ${this.ipcBroadcaster ? "attached" : "not available"} for agent events`
+        );
         const jobConfigs = loadJobFile(this.rootDir).jobs;
         let scheduledCount = 0;
         let disabledCount = 0;
@@ -1549,8 +1554,27 @@ var init_scheduler = __esm({
         console.log(`[Scheduler] Running job "${jobConfig.name}"`);
         let fullText = "";
         let agentFailed = false;
+        let loggedFirstTextDelta = false;
+        let sawAgentStart = false;
+        let sawAgentEnd = false;
         const pendingFiles = [];
         const onEvent = (event) => {
+          if (event.type === "agent_start") {
+            sawAgentStart = true;
+          } else if (event.type === "agent_end") {
+            sawAgentEnd = true;
+          }
+          if (event.type === "agent_start" || event.type === "agent_end") {
+            console.log(
+              `[Scheduler] Forwarding ${event.type} for ${channelId} (ipc=${this.ipcBroadcaster ? "yes" : "no"})`
+            );
+          } else if (event.type === "text_delta" && !loggedFirstTextDelta) {
+            loggedFirstTextDelta = true;
+            console.log(
+              `[Scheduler] Forwarding first text_delta for ${channelId} (${event.delta.length} chars, ipc=${this.ipcBroadcaster ? "yes" : "no"})`
+            );
+          }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
           if (event.type === "text_delta") fullText += event.delta;
           if (event.type === "file_output") {
             pendingFiles.push({
@@ -1568,6 +1592,7 @@ var init_scheduler = __esm({
             onEvent,
             void 0
           );
+          this.ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent);
           if (result.errorMessage) {
             fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u6267\u884C\u5931\u8D25\uFF1A${result.errorMessage}`;
             agentFailed = true;
@@ -1576,6 +1601,7 @@ var init_scheduler = __esm({
             if (job) job.lastError = void 0;
           }
         } catch (err) {
+          this.ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent);
           const errorMsg = err instanceof Error ? err.message : String(err);
           fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u5F02\u5E38\uFF1A${errorMsg}`;
           agentFailed = true;
@@ -1612,10 +1638,19 @@ var init_scheduler = __esm({
         return { text: fullText, notifyFailed };
       }
       async clearJobContext(channelId) {
+        console.log(`[Scheduler] Clearing context for ${channelId}`);
         const result = await this.agent.handleCommand("clear", channelId);
         if (!result.success) {
           throw new Error(result.message || `Failed to clear context for ${channelId}`);
         }
+        console.log(`[Scheduler] Context cleared for ${channelId}`);
+      }
+      ensureTerminalAgentEvent(channelId, sawAgentStart, sawAgentEnd, onEvent) {
+        if (!sawAgentStart || sawAgentEnd) {
+          return;
+        }
+        console.log(`[Scheduler] Synthesizing agent_end for ${channelId}`);
+        onEvent({ type: "agent_end" });
       }
       // -------------------------------------------------------------------------
       // Dynamic management API
@@ -2480,22 +2515,22 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path19 from "path";
-import fs20 from "fs";
+import path17 from "path";
+import fs17 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path18 from "path";
-import fs19 from "fs";
+import path16 from "path";
+import fs16 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
 
 // src/runtime/agent.ts
-import path13 from "path";
-import fs13 from "fs";
+import path11 from "path";
+import fs10 from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import { fileURLToPath } from "url";
 import {
@@ -2726,40 +2761,238 @@ var ConfigFileAuthBackend = class {
 // src/runtime/agent.ts
 init_attachment_utils();
 
-// src/runtime/artifacts/query-service.ts
-function clampLimit(limit, fallback, max) {
-  if (!Number.isFinite(limit)) {
-    return fallback;
+// src/runtime/custom-tools/delegated-custom-tool-client.ts
+import { randomUUID } from "crypto";
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function assertToolDefinitions(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid delegated custom tool definitions response");
+  }
+  for (const definition of value) {
+    if (!isObject(definition) || typeof definition.name !== "string" || typeof definition.label !== "string" || typeof definition.description !== "string" || !isObject(definition.parameters)) {
+      throw new Error("Invalid delegated custom tool definition");
+    }
   }
-  const normalized = Math.floor(limit);
-  return Math.max(1, Math.min(normalized, max));
 }
-function clampOffset(offset) {
-  if (!Number.isFinite(offset)) {
-    return 0;
+function assertToolResult(value) {
+  if (!isObject(value) || !Array.isArray(value.content)) {
+    throw new Error("Invalid delegated custom tool result");
   }
-  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)
+var DelegatedCustomToolClient = class {
+  constructor(transport = process, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
+    this.transport.on("message", this.handleMessage);
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  timeoutMs;
+  disposed = false;
+  isAvailable() {
+    return typeof this.transport.send === "function" && this.transport.connected !== false;
+  }
+  async listDefinitions() {
+    if (!this.isAvailable()) {
+      return [];
+    }
+    const data = await this.sendRequest("get_custom_tool_definitions");
+    assertToolDefinitions(data);
+    return data;
+  }
+  async executeTool(input) {
+    const data = await this.sendRequest("execute_custom_tool", input);
+    assertToolResult(data);
+    return data;
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.transport.off("message", this.handleMessage);
+    this.rejectAllPending(new Error("Delegated custom tool client disposed"));
+  }
+  sendRequest(type, payload) {
+    if (!this.isAvailable()) {
+      throw new Error("Delegated custom tool IPC channel is not available");
+    }
+    const id = randomUUID();
+    const request = {
+      id,
+      type,
+      ...payload || {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Delegated custom tool request timed out: ${type}`));
+      }, this.timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(request);
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
+  handleMessage = (message) => {
+    if (!isObject(message)) {
+      return;
+    }
+    const payload = message;
+    if (typeof payload.id !== "string" || payload.type !== "result" && payload.type !== "error") {
+      return;
+    }
+    const pending = this.pendingRequests.get(payload.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(payload.id);
+    if (payload.type === "error") {
+      pending.reject(new Error(payload.message));
+      return;
+    }
+    pending.resolve(payload.data);
+  };
+  rejectAllPending(error) {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pendingRequests.delete(id);
+    }
+  }
 };
 
-// src/runtime/artifacts/snapshot-service.ts
-import { randomUUID } from "crypto";
-import fs9 from "fs";
+// src/runtime/custom-tools/delegated-custom-tool-factory.ts
+function toAgentToolResult(result) {
+  return {
+    content: result.content,
+    details: result.details
+  };
+}
+function createDelegatedCustomTools(definitions, client, runContextRef) {
+  return definitions.map((definition) => ({
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    promptSnippet: definition.promptSnippet,
+    promptGuidelines: definition.promptGuidelines,
+    parameters: definition.parameters,
+    async execute(toolCallId, params) {
+      const runContext = runContextRef.current;
+      if (!runContext) {
+        throw new Error(
+          `Delegated custom tool ${definition.name} is not available outside an active run.`
+        );
+      }
+      return toAgentToolResult(
+        await client.executeTool({
+          toolName: definition.name,
+          toolCallId,
+          runContext,
+          params
+        })
+      );
+    }
+  }));
+}
+
+// src/runtime/host-ipc/host-ipc-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function isObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+var HostIpcClient = class {
+  constructor(transport = process, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
+    this.transport.on("message", this.handleMessage);
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  timeoutMs;
+  disposed = false;
+  isAvailable() {
+    return typeof this.transport.send === "function" && this.transport.connected !== false;
+  }
+  async notifyChannelSessionCleared(input) {
+    if (!this.isAvailable()) {
+      return;
+    }
+    await this.sendRequest("channel_session_cleared", input);
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.transport.off("message", this.handleMessage);
+    this.rejectAllPending(new Error("Host IPC client disposed"));
+  }
+  sendRequest(type, payload) {
+    if (!this.isAvailable()) {
+      throw new Error("Host IPC channel is not available");
+    }
+    const id = randomUUID2();
+    const request = {
+      id,
+      type,
+      ...payload || {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Host IPC request timed out: ${type}`));
+      }, this.timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      try {
+        this.transport.send(request);
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  handleMessage = (message) => {
+    if (!isObject2(message)) {
+      return;
+    }
+    const payload = message;
+    if (typeof payload.id !== "string" || payload.type !== "result" && payload.type !== "error") {
+      return;
+    }
+    const pending = this.pendingRequests.get(payload.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(payload.id);
+    if (payload.type === "error") {
+      pending.reject(new Error(payload.message));
+      return;
+    }
+    pending.resolve(payload.data);
+  };
+  rejectAllPending(error) {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pendingRequests.delete(id);
+    }
+  }
+};
+
+// src/runtime/tools/send-file-tool.ts
+import fs8 from "fs";
 import path9 from "path";
+import { Type } from "@sinclair/typebox";
 
 // src/runtime/files/metadata.ts
-import fs8 from "fs";
 import path8 from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
@@ -2789,419 +3022,14 @@ 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 {
-    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({
+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: Type2.Optional(
-    Type2.String({
+  caption: Type.Optional(
+    Type.String({
       description: "Optional caption or description to accompany the file."
     })
   )
@@ -3215,13 +3043,13 @@ function createSendFileTool(fileOutputCallbackRef) {
     parameters: SendFileParams,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const { filePath, caption } = params;
-      if (!fs11.existsSync(filePath)) {
+      if (!fs8.existsSync(filePath)) {
         return {
           content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
           details: void 0
         };
       }
-      const stats = fs11.statSync(filePath);
+      const stats = fs8.statSync(filePath);
       if (!stats.isFile()) {
         return {
           content: [
@@ -3230,7 +3058,7 @@ function createSendFileTool(fileOutputCallbackRef) {
           details: void 0
         };
       }
-      const filename = path11.basename(filePath);
+      const filename = path9.basename(filePath);
       const mimeType = detectMimeType(filePath);
       const callback = fileOutputCallbackRef.current;
       if (callback) {
@@ -3257,51 +3085,51 @@ function createSendFileTool(fileOutputCallbackRef) {
 }
 
 // src/runtime/tools/manage-schedule-tool.ts
-import { Type as Type3 } from "@sinclair/typebox";
-var ManageScheduleParams = Type3.Object({
-  action: Type3.Union(
+import { Type as Type2 } from "@sinclair/typebox";
+var ManageScheduleParams = Type2.Object({
+  action: Type2.Union(
     [
-      Type3.Literal("add"),
-      Type3.Literal("list"),
-      Type3.Literal("remove"),
-      Type3.Literal("trigger"),
-      Type3.Literal("enable"),
-      Type3.Literal("disable")
+      Type2.Literal("add"),
+      Type2.Literal("list"),
+      Type2.Literal("remove"),
+      Type2.Literal("trigger"),
+      Type2.Literal("enable"),
+      Type2.Literal("disable")
     ],
     { description: "The action to perform." }
   ),
-  name: Type3.Optional(
-    Type3.String({
+  name: Type2.Optional(
+    Type2.String({
       description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
     })
   ),
-  cron: Type3.Optional(
-    Type3.String({
+  cron: Type2.Optional(
+    Type2.String({
       description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
     })
   ),
-  prompt: Type3.Optional(
-    Type3.String({
+  prompt: Type2.Optional(
+    Type2.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: Type3.Optional(
-    Type3.String({
+  timezone: Type2.Optional(
+    Type2.String({
       description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
     })
   ),
-  notifyAdapter: Type3.Optional(
-    Type3.String({
+  notifyAdapter: Type2.Optional(
+    Type2.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({
+  notifyChannelId: Type2.Optional(
+    Type2.String({
       description: "Optional target channelId for notifications. Must be provided together with notifyAdapter when overriding the default target."
     })
   )
 });
-function textResult2(text) {
+function textResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
 function getDefaultNotifyTarget(adapter, channelId) {
@@ -3341,7 +3169,7 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const scheduler = schedulerRef.current;
       if (!scheduler) {
-        return textResult2(
+        return textResult(
           "Error: Scheduler is not available. The scheduled task system may not be initialized."
         );
       }
@@ -3349,24 +3177,24 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
         case "list": {
           const jobs = scheduler.listJobs();
           if (jobs.length === 0) {
-            return textResult2("No scheduled tasks configured.");
+            return textResult("No scheduled tasks configured.");
           }
           const lines = jobs.map(
             (j) => `- **${j.name}**: \`${j.cron}\` \u2192 ${j.notify.adapter}:${j.notify.channelId} [${j.enabled ? "enabled" : "disabled"}]${j.running ? " (running)" : ""}${j.lastRunAt ? ` (last: ${j.lastRunAt})` : ""}`
           );
-          return textResult2(
+          return textResult(
             `Scheduled tasks (${jobs.length}):
 ${lines.join("\n")}`
           );
         }
         case "add": {
           if (!params.name || !params.cron || !params.prompt) {
-            return textResult2(
+            return textResult(
               "Error: 'name', 'cron', and 'prompt' are required for adding a task."
             );
           }
           if (params.notifyAdapter && !params.notifyChannelId || !params.notifyAdapter && params.notifyChannelId) {
-            return textResult2(
+            return textResult(
               "Error: 'notifyAdapter' and 'notifyChannelId' must be provided together when overriding the notification target."
             );
           }
@@ -3375,7 +3203,7 @@ ${lines.join("\n")}`
             channelId: params.notifyChannelId
           } : getDefaultNotifyTarget(adapter, channelId);
           if (!notify) {
-            return textResult2(
+            return textResult(
               "Error: No default notification target is available for this chat. Provide 'notifyAdapter' and 'notifyChannelId'."
             );
           }
@@ -3388,46 +3216,46 @@ ${lines.join("\n")}`
             timezone: params.timezone
           };
           const result = scheduler.addJob(jobConfig);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         case "remove": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for removing a task."
             );
           }
           const result = scheduler.removeJob(params.name);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         case "trigger": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for triggering a task."
             );
           }
           const result = await scheduler.triggerJob(params.name);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         case "enable": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for enabling a task."
             );
           }
           const result = scheduler.setEnabled(params.name, true);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         case "disable": {
           if (!params.name) {
-            return textResult2(
+            return textResult(
               "Error: 'name' is required for disabling a task."
             );
           }
           const result = scheduler.setEnabled(params.name, false);
-          return textResult2(result.message);
+          return textResult(result.message);
         }
         default:
-          return textResult2(
+          return textResult(
             `Error: Unknown action '${params.action}'. Use: add, list, remove, trigger, enable, disable.`
           );
       }
@@ -3437,8 +3265,8 @@ ${lines.join("\n")}`
 
 // src/runtime/commands/help-command.ts
 init_commands();
-import fs12 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function buildHelpMessage(rootDir) {
   const sections = [];
   const commands = getVisibleCommands();
@@ -3448,7 +3276,7 @@ function buildHelpMessage(rootDir) {
   sections.push(`\u{1F4CB} **Available Commands**
 
 ${commandLines.join("\n")}`);
-  const configPath = path12.resolve(rootDir, "skillpack.json");
+  const configPath = path10.resolve(rootDir, "skillpack.json");
   const skills = readInstalledSkills(configPath);
   if (skills.length > 0) {
     const skillLines = skills.map(
@@ -3484,11 +3312,11 @@ function handleHelpCommand(rootDir) {
   };
 }
 function readInstalledSkills(configPath) {
-  if (!fs12.existsSync(configPath)) {
+  if (!fs9.existsSync(configPath)) {
     return [];
   }
   try {
-    const raw = fs12.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return Array.isArray(config.skills) ? config.skills : [];
   } catch {
@@ -3508,24 +3336,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 (!fs13.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs10.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path13.resolve(rootDir, "skillpack.json");
-  const skillDir = path13.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path13.join(skillDir, "SKILL.md");
+  const packConfigPath = path11.resolve(rootDir, "skillpack.json");
+  const skillDir = path11.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path11.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs13.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs13.readdirSync(srcDir, { withFileTypes: true })) {
+    fs10.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs10.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path13.join(srcDir, entry.name);
-      const destPath = path13.join(destDir, entry.name);
+      const srcPath = path11.join(srcDir, entry.name);
+      const destPath = path11.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -3534,17 +3362,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs13.readFileSync(srcPath, "utf-8");
-        fs13.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs10.readFileSync(srcPath, "utf-8");
+        fs10.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs13.copyFileSync(srcPath, destPath);
+      fs10.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs13.existsSync(skillDir)) {
+  if (!fs10.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs13.existsSync(skillPath)) {
+  if (!fs10.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -3572,11 +3400,11 @@ function overrideBuiltinSkillCreator(base, materializedSkill) {
   };
 }
 function readOptionalPackPromptFile(filePath) {
-  if (!fs13.existsSync(filePath)) {
+  if (!fs10.existsSync(filePath)) {
     return void 0;
   }
   try {
-    const content = fs13.readFileSync(filePath, "utf-8").trim();
+    const content = fs10.readFileSync(filePath, "utf-8").trim();
     return content.length > 0 ? content : void 0;
   } catch (error) {
     console.warn(`[PackAgent] Warning: Could not read ${filePath}:`, error);
@@ -3584,8 +3412,8 @@ function readOptionalPackPromptFile(filePath) {
   }
 }
 function buildPackPromptBlock(rootDir) {
-  const agentsPath = path13.resolve(rootDir, PACK_AGENTS_FILE);
-  const soulPath = path13.resolve(rootDir, PACK_SOUL_FILE);
+  const agentsPath = path11.resolve(rootDir, PACK_AGENTS_FILE);
+  const soulPath = path11.resolve(rootDir, PACK_SOUL_FILE);
   const agentsContent = readOptionalPackPromptFile(agentsPath);
   const soulContent = readOptionalPackPromptFile(soulPath);
   if (!agentsContent && !soulContent) {
@@ -3644,13 +3472,15 @@ var PackAgent = class {
   options;
   channels = /* @__PURE__ */ new Map();
   pendingSessionCreations = /* @__PURE__ */ new Map();
-  schedulerRef = { current: null };
+  schedulerRef = {
+    current: null
+  };
   authStorage;
-  artifactPersistenceService;
+  delegatedCustomToolClient = new DelegatedCustomToolClient();
+  hostIpcClient = new HostIpcClient();
   constructor(options) {
     this.options = options;
-    this.artifactPersistenceService = options.artifactPersistenceService;
-    const configPath = path13.resolve(options.rootDir, "data", "config.json");
+    const configPath = path11.resolve(options.rootDir, "data", "config.json");
     const backend = new ConfigFileAuthBackend(configPath);
     this.authStorage = AuthStorage.fromStorage(backend);
     const providerMeta = SUPPORTED_PROVIDERS[options.provider];
@@ -3677,13 +3507,20 @@ var PackAgent = class {
   setScheduler(scheduler) {
     this.schedulerRef.current = scheduler;
   }
-  createCustomTools(adapter, channelId, fileOutputCallbackRef, finalArtifactsSaveCallbackRef) {
+  async createCustomTools(adapter, channelId, fileOutputCallbackRef, delegatedToolRunContextRef) {
+    const delegatedDefinitions = await this.delegatedCustomToolClient.listDefinitions();
     const tools = [
       createSendFileTool(fileOutputCallbackRef),
-      createSaveArtifactsTool(this.options.rootDir, finalArtifactsSaveCallbackRef)
+      ...createDelegatedCustomTools(
+        delegatedDefinitions,
+        this.delegatedCustomToolClient,
+        delegatedToolRunContextRef
+      )
     ];
     if (adapter !== "scheduler") {
-      tools.push(createManageScheduleTool(this.schedulerRef, adapter, channelId));
+      tools.push(
+        createManageScheduleTool(this.schedulerRef, adapter, channelId)
+      );
     }
     return tools;
   }
@@ -3701,7 +3538,9 @@ var PackAgent = class {
       const modelRegistry = new ModelRegistry(authStorage);
       if (baseUrl && modelId) {
         const apiProtocol = this.options.apiProtocol ?? "openai-completions";
-        log(`[PackAgent] Registering custom model ${provider}/${modelId} api=${apiProtocol} baseUrl=${baseUrl}`);
+        log(
+          `[PackAgent] Registering custom model ${provider}/${modelId} api=${apiProtocol} baseUrl=${baseUrl}`
+        );
         modelRegistry.registerProvider(provider, {
           baseUrl,
           apiKey: this.options.apiKey,
@@ -3722,26 +3561,23 @@ var PackAgent = class {
       const resolvedModel = modelRegistry.find(provider, modelId);
       const model = resolvedModel && baseUrl && !this.options.apiProtocol ? { ...resolvedModel, baseUrl } : resolvedModel;
       if (resolvedModel && baseUrl) {
-        log(`[PackAgent] Resolved ${provider}/${modelId} api=${resolvedModel.api} baseUrl=${baseUrl}`);
+        log(
+          `[PackAgent] Resolved ${provider}/${modelId} api=${resolvedModel.api} baseUrl=${baseUrl}`
+        );
       }
-      const sessionDir = path13.resolve(
-        rootDir,
-        "data",
-        "sessions",
-        channelId
-      );
-      fs13.mkdirSync(sessionDir, { recursive: true });
+      const sessionDir = path11.resolve(rootDir, "data", "sessions", channelId);
+      fs10.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path13.resolve(
+      const workspaceDir = path11.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs13.mkdirSync(workspaceDir, { recursive: true });
+      fs10.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path13.resolve(rootDir, "skills");
+      const skillsPath = path11.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -3754,14 +3590,22 @@ var PackAgent = class {
       }
       const packPromptFiles = buildPackPromptBlock(rootDir);
       if (packPromptFiles.agentsContent) {
-        log(`[PackAgent] Loaded pack policy from: ${packPromptFiles.agentsPath}`);
+        log(
+          `[PackAgent] Loaded pack policy from: ${packPromptFiles.agentsPath}`
+        );
       } else {
-        log(`[PackAgent] No pack policy file found at: ${packPromptFiles.agentsPath}`);
+        log(
+          `[PackAgent] No pack policy file found at: ${packPromptFiles.agentsPath}`
+        );
       }
       if (packPromptFiles.soulContent) {
-        log(`[PackAgent] Loaded pack persona from: ${packPromptFiles.soulPath}`);
+        log(
+          `[PackAgent] Loaded pack persona from: ${packPromptFiles.soulPath}`
+        );
       } else {
-        log(`[PackAgent] No pack persona file found at: ${packPromptFiles.soulPath}`);
+        log(
+          `[PackAgent] No pack persona file found at: ${packPromptFiles.soulPath}`
+        );
       }
       log(
         `[PackAgent] Pack prompt injection: ${packPromptFiles.promptBlock ? "enabled" : "disabled"}`
@@ -3779,14 +3623,14 @@ var PackAgent = class {
       const fileOutputCallbackRef = {
         current: null
       };
-      const finalArtifactsSaveCallbackRef = {
+      const delegatedToolRunContextRef = {
         current: null
       };
-      const customTools = this.createCustomTools(
+      const customTools = await this.createCustomTools(
         adapter,
         channelId,
         fileOutputCallbackRef,
-        finalArtifactsSaveCallbackRef
+        delegatedToolRunContextRef
       );
       const { session } = await createAgentSession({
         cwd: workspaceDir,
@@ -3803,7 +3647,7 @@ var PackAgent = class {
         running: false,
         pending: Promise.resolve(),
         fileOutputCallbackRef,
-        finalArtifactsSaveCallbackRef
+        delegatedToolRunContextRef
       };
       this.channels.set(channelId, channelSession);
       return channelSession;
@@ -3826,12 +3670,10 @@ var PackAgent = class {
         cs.fileOutputCallbackRef.current = (event) => {
           onEvent(event);
         };
-        cs.finalArtifactsSaveCallbackRef.current = (artifacts) => {
-          return this.artifactPersistenceService.saveArtifacts({
-            runId,
-            channelId,
-            artifacts
-          });
+        cs.delegatedToolRunContextRef.current = {
+          runId,
+          channelId,
+          adapter
         };
         unsubscribe = cs.session.subscribe((event) => {
           switch (event.type) {
@@ -3847,7 +3689,10 @@ var PackAgent = class {
               if (event.message?.role === "user") {
                 log(JSON.stringify(event.message.content, null, 2));
               }
-              onEvent({ type: "message_start", role: event.message?.role ?? "" });
+              onEvent({
+                type: "message_start",
+                role: event.message?.role ?? ""
+              });
               break;
             case "message_update":
               if (event.assistantMessageEvent?.type === "text_delta") {
@@ -3914,18 +3759,26 @@ var PackAgent = class {
         let promptText = text;
         const promptOptions = {};
         if (attachments && attachments.length > 0) {
-          const imageAttachments = attachments.filter((a) => isImageMime(a.mimeType));
-          const nonImageAttachments = attachments.filter((a) => !isImageMime(a.mimeType));
+          const imageAttachments = attachments.filter(
+            (a) => isImageMime(a.mimeType)
+          );
+          const nonImageAttachments = attachments.filter(
+            (a) => !isImageMime(a.mimeType)
+          );
           if (imageAttachments.length > 0) {
             promptOptions.images = attachmentsToImageContent(imageAttachments);
-            log(`[PackAgent] Passing ${imageAttachments.length} image(s) to LLM`);
+            log(
+              `[PackAgent] Passing ${imageAttachments.length} image(s) to LLM`
+            );
           }
           if (nonImageAttachments.length > 0) {
             const attachmentPrompt = formatAttachmentsPrompt(nonImageAttachments);
             promptText = `${attachmentPrompt}
 
 ${text}`;
-            log(`[PackAgent] Injecting ${nonImageAttachments.length} non-image attachment(s) into prompt`);
+            log(
+              `[PackAgent] Injecting ${nonImageAttachments.length} non-image attachment(s) into prompt`
+            );
           }
         }
         await cs.session.prompt(promptText, promptOptions);
@@ -3948,12 +3801,15 @@ ${text}`;
       } finally {
         cs.running = false;
         cs.fileOutputCallbackRef.current = null;
-        cs.finalArtifactsSaveCallbackRef.current = null;
+        cs.delegatedToolRunContextRef.current = null;
         unsubscribe();
       }
     };
     const resultPromise = cs.pending.catch(() => void 0).then(run);
-    cs.pending = resultPromise.then(() => void 0, () => void 0);
+    cs.pending = resultPromise.then(
+      () => void 0,
+      () => void 0
+    );
     return resultPromise;
   }
   async handleCommand(command, channelId) {
@@ -3968,11 +3824,12 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path13.resolve(rootDir, "data", "sessions", channelId);
-        if (fs13.existsSync(sessionDir)) {
-          fs13.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path11.resolve(rootDir, "data", "sessions", channelId);
+        if (fs10.existsSync(sessionDir)) {
+          fs10.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
+        await this.hostIpcClient.notifyChannelSessionCleared({ channelId });
         return {
           success: true,
           message: command === "new" ? "New session started." : "Session cleared."
@@ -4021,14 +3878,14 @@ ${text}`;
 };
 
 // src/runtime/adapters/web.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path13 from "path";
 import { WebSocketServer } from "ws";
 init_commands();
 
 // src/runtime/services/conversation.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import {
   parseSessionEntries
 } from "@mariozechner/pi-coding-agent";
@@ -4046,17 +3903,17 @@ var ConversationService = class {
       includeLegacyWeb = true,
       allowedPlatforms
     } = options;
-    const sessionsDir = path14.resolve(this.rootDir, "data", "sessions");
+    const sessionsDir = path12.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);
+    if (fs11.existsSync(sessionsDir)) {
+      for (const entry of fs11.readdirSync(sessionsDir)) {
+        const channelDir = path12.join(sessionsDir, entry);
         try {
-          if (!fs14.statSync(channelDir).isDirectory()) {
+          if (!fs11.statSync(channelDir).isDirectory()) {
             continue;
           }
           const platform = this.detectPlatform(entry);
@@ -4080,7 +3937,7 @@ var ConversationService = class {
       if (!includeLegacyWeb && this.isLegacyWebConversation(channelId)) {
         continue;
       }
-      const channelDir = path14.join(sessionsDir, channelId);
+      const channelDir = path12.join(sessionsDir, channelId);
       const sessionFile = this.findLatestSessionFile(channelDir);
       let messageCount = 0;
       let lastMessageAt = "";
@@ -4124,7 +3981,7 @@ var ConversationService = class {
    * Load latest messages for a channel in a simplified format.
    */
   getMessages(channelId, limit = 100) {
-    const channelDir = path14.resolve(
+    const channelDir = path12.resolve(
       this.rootDir,
       "data",
       "sessions",
@@ -4213,20 +4070,20 @@ var ConversationService = class {
     return messages.slice(-safeLimit);
   }
   findLatestSessionFile(channelDir) {
-    if (!fs14.existsSync(channelDir)) return null;
+    if (!fs11.existsSync(channelDir)) return null;
     let stats;
     try {
-      stats = fs14.statSync(channelDir);
+      stats = fs11.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;
+    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path12.join(channelDir, files[0]) : null;
   }
   loadEntries(filePath) {
     try {
-      const content = fs14.readFileSync(filePath, "utf-8");
+      const content = fs11.readFileSync(filePath, "utf-8");
       const fileEntries = parseSessionEntries(content);
       return fileEntries.filter(
         (entry) => entry.type !== "session"
@@ -4422,7 +4279,7 @@ var ConversationService = class {
 
 // src/runtime/adapters/web.ts
 function getPackConfig(rootDir) {
-  const raw = fs15.readFileSync(path15.join(rootDir, "skillpack.json"), "utf-8");
+  const raw = fs12.readFileSync(path13.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
 function parseCommand(text) {
@@ -4452,7 +4309,7 @@ function parsePositiveInt(value, fallback) {
   return Math.floor(parsed);
 }
 function resolveDownloadFilePath(rootDir, filePath) {
-  const resolvedPath = path15.isAbsolute(filePath) ? path15.resolve(filePath) : path15.resolve(rootDir, filePath);
+  const resolvedPath = path13.isAbsolute(filePath) ? path13.resolve(filePath) : path13.resolve(rootDir, filePath);
   return isWithinDirectory(rootDir, resolvedPath) ? resolvedPath : null;
 }
 var WebAdapter = class {
@@ -4467,7 +4324,6 @@ var WebAdapter = class {
     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";
@@ -4611,17 +4467,6 @@ var WebAdapter = class {
         )
       );
     });
-    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;
       if (!filePath) {
@@ -4633,17 +4478,17 @@ var WebAdapter = class {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs12.existsSync(resolvedPath)) {
         res.status(404).json({ error: "File not found" });
         return;
       }
-      const filename = path15.basename(resolvedPath);
+      const filename = path13.basename(resolvedPath);
       res.setHeader("Content-Type", "application/octet-stream");
       res.setHeader(
         "Content-Disposition",
         `attachment; filename="${filename}"`
       );
-      fs15.createReadStream(resolvedPath).pipe(res);
+      fs12.createReadStream(resolvedPath).pipe(res);
     });
     const getScheduler = () => {
       const schedulerAdapter = ctx.adapterMap?.get("scheduler");
@@ -4828,13 +4673,28 @@ var WebAdapter = class {
 
 // src/runtime/adapters/ipc.ts
 init_types();
+var IPC_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  "get_conversations",
+  "create_conversation",
+  "get_messages",
+  "send_message",
+  "command",
+  "get_config",
+  "update_config",
+  "get_status",
+  "get_scheduled_jobs",
+  "add_scheduled_job",
+  "update_scheduled_job",
+  "set_scheduled_job_enabled",
+  "trigger_scheduled_job",
+  "remove_scheduled_job"
+]);
 var IpcAdapter = class {
   name = "ipc";
   agent = null;
   rootDir = "";
   adapterMap = null;
   conversationService = null;
-  resultsQueryService = null;
   createdChannels = /* @__PURE__ */ new Set();
   messageListener;
   started = false;
@@ -4846,7 +4706,6 @@ 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);
@@ -4891,7 +4750,7 @@ var IpcAdapter = class {
   isIpcRequest(message) {
     if (!message || typeof message !== "object") return false;
     const maybe = message;
-    return typeof maybe.id === "string" && typeof maybe.type === "string";
+    return typeof maybe.id === "string" && typeof maybe.type === "string" && IPC_REQUEST_TYPES.has(maybe.type);
   }
   async handleRequest(request) {
     if (!this.agent || !this.conversationService) {
@@ -4930,18 +4789,6 @@ 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");
@@ -5185,28 +5032,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs16 from "fs";
+import fs13 from "fs";
 import os from "os";
-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");
+import path14 from "path";
+var SKILLPACK_HOME = path14.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path14.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path14.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs16.existsSync(SKILLPACK_HOME)) {
-    fs16.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs13.existsSync(SKILLPACK_HOME)) {
+    fs13.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs16.existsSync(REGISTRY_DIR)) {
-    fs16.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs13.existsSync(REGISTRY_DIR)) {
+    fs13.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path16.resolve(dir);
+  const resolved = path14.resolve(dir);
   try {
-    return fs16.realpathSync(resolved);
+    return fs13.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -5215,7 +5062,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path16.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path14.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -5223,11 +5070,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs16.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path16.join(REGISTRY_DIR, file));
+  return fs13.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path14.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs16.readFileSync(filePath, "utf-8");
+    const raw = fs13.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;
@@ -5260,8 +5107,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs16.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs16.renameSync(tmpPath, entryPath);
+  fs13.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs13.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -5269,14 +5116,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs16.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs13.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs16.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs13.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -5289,7 +5136,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs16.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs13.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -5342,7 +5189,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path18.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path16.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -5358,8 +5205,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 = path18.resolve(__dirname, "..");
-  const webDir = fs19.existsSync(path18.join(rootDir, "web")) ? path18.join(rootDir, "web") : path18.join(packageRoot, "web");
+  const packageRoot = path16.resolve(__dirname, "..");
+  const webDir = fs16.existsSync(path16.join(rootDir, "web")) ? path16.join(rootDir, "web") : path16.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -5377,13 +5224,6 @@ 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,
@@ -5391,14 +5231,16 @@ async function startServer(options) {
     modelId,
     baseUrl,
     apiProtocol,
-    lifecycleHandler: lifecycle,
-    artifactPersistenceService
+    lifecycleHandler: lifecycle
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
   const hasIpcChannel = typeof process.send === "function";
   const ipcAdapter = new IpcAdapter();
   const webEnabled = runtimeMode === "standalone";
+  console.log(
+    `[Runtime] IPC channel ${hasIpcChannel ? "available" : "not available"} (mode=${runtimeMode})`
+  );
   if (hasIpcChannel) {
     await ipcAdapter.start({
       agent,
@@ -5406,8 +5248,7 @@ async function startServer(options) {
       app,
       rootDir,
       lifecycle,
-      adapterMap,
-      resultsQueryService
+      adapterMap
     });
     adapters.push(ipcAdapter);
     adapterMap.set(ipcAdapter.name, ipcAdapter);
@@ -5422,8 +5263,7 @@ async function startServer(options) {
       rootDir,
       lifecycle,
       adapterMap,
-      ipcBroadcaster,
-      resultsQueryService
+      ipcBroadcaster
     });
     adapters.push(webAdapter);
     adapterMap.set(webAdapter.name, webAdapter);
@@ -5441,8 +5281,7 @@ async function startServer(options) {
         rootDir,
         lifecycle,
         adapterMap,
-        ipcBroadcaster,
-        resultsQueryService
+        ipcBroadcaster
       });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
@@ -5470,8 +5309,7 @@ async function startServer(options) {
           rootDir,
           lifecycle,
           adapterMap,
-          ipcBroadcaster,
-          resultsQueryService
+          ipcBroadcaster
         });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
@@ -5503,7 +5341,7 @@ async function startServer(options) {
       lifecycle,
       notify: notifyFn,
       adapterMap,
-      resultsQueryService
+      ipcBroadcaster
     });
     adapters.push(schedulerAdapter);
     adapterMap.set(schedulerAdapter.name, schedulerAdapter);
@@ -5591,23 +5429,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path19.resolve(
+  const templateDir = path17.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path19.join(templateDir, file);
-    const dest = path19.join(workDir, file);
-    if (fs20.existsSync(src)) {
-      fs20.copyFileSync(src, dest);
+    const src = path17.join(templateDir, file);
+    const dest = path17.join(workDir, file);
+    if (fs17.existsSync(src)) {
+      fs17.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs20.chmodSync(dest, 493);
+        fs17.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path19.resolve(directory) : process.cwd();
-  fs20.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path17.resolve(directory) : process.cwd();
+  fs17.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([
@@ -5651,14 +5489,14 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs21 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path18 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var packageJson = JSON.parse(
-  fs21.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs18.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
-var cliFilePath = path20.resolve(fileURLToPath3(import.meta.url));
+var cliFilePath = path18.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);
@@ -5679,7 +5517,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 && path20.resolve(firstArg) === cliFilePath) {
+  if (firstArg && path18.resolve(firstArg) === cliFilePath) {
     return argv.slice(1);
   }
   return argv;