@hasna/assistants 1.1.4 → 1.1.6

package/dist/lib.js

@@ -240,7 +240,21 @@ var init_runtime = __esm(async () => {
 // ../shared/src/utils.ts
 import { randomUUID } from "crypto";
 function generateId() {
-  return randomUUID();
+  const base = randomUUID();
+  if (base !== lastUuidBase) {
+    lastUuidBase = base;
+    uuidCounter = 0;
+    return base;
+  }
+  uuidCounter = uuidCounter + 1 & 281474976710655;
+  const parts = base.split("-");
+  if (parts.length !== 5) {
+    return base;
+  }
+  const baseValue = BigInt(`0x${parts[4]}`);
+  const nextValue = baseValue + BigInt(uuidCounter) & 0xffffffffffffn;
+  const nextLast = nextValue.toString(16).padStart(12, "0");
+  return `${parts[0]}-${parts[1]}-${parts[2]}-${parts[3]}-${nextLast}`;
 }
 function now() {
   return Date.now();
@@ -302,6 +316,7 @@ function substituteVariables(template, args, env = {}) {
   });
   return result;
 }
+var lastUuidBase = "", uuidCounter = 0;
 var init_utils = () => {};
 
 // ../shared/src/models.ts
@@ -6887,6 +6902,22 @@ function mergeConfig(base, override) {
         ...override.messages?.storage || {}
       }
     },
+    webhooks: {
+      ...base.webhooks || {},
+      ...override.webhooks || {},
+      injection: {
+        ...base.webhooks?.injection || {},
+        ...override.webhooks?.injection || {}
+      },
+      storage: {
+        ...base.webhooks?.storage || {},
+        ...override.webhooks?.storage || {}
+      },
+      security: {
+        ...base.webhooks?.security || {},
+        ...override.webhooks?.security || {}
+      }
+    },
     memory: {
       ...base.memory || {},
       ...override.memory || {},
@@ -7027,7 +7058,8 @@ async function ensureConfigDir(sessionId) {
     mkdir2(join(configDir, "state"), { recursive: true }),
     mkdir2(join(configDir, "energy"), { recursive: true }),
     mkdir2(join(configDir, "jobs"), { recursive: true }),
-    mkdir2(join(configDir, "inbox"), { recursive: true })
+    mkdir2(join(configDir, "inbox"), { recursive: true }),
+    mkdir2(join(configDir, "webhooks"), { recursive: true })
   ];
   if (sessionId) {
     dirs.push(mkdir2(join(configDir, "temp", sessionId), { recursive: true }));
@@ -7227,6 +7259,21 @@ var init_config = __esm(async () => {
         maxAgeDays: 90
       }
     },
+    webhooks: {
+      enabled: false,
+      injection: {
+        enabled: true,
+        maxPerTurn: 5
+      },
+      storage: {
+        maxEvents: 1000,
+        maxAgeDays: 30
+      },
+      security: {
+        maxTimestampAgeMs: 300000,
+        rateLimitPerMinute: 60
+      }
+    },
     memory: {
       enabled: true,
       injection: {
@@ -13120,8 +13167,8 @@ var init_evaluator = __esm(() => {
 });
 
 // ../core/src/guardrails/store.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
-import { join as join21, dirname as dirname9 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { join as join22, dirname as dirname10 } from "path";
 import { createHash as createHash3 } from "crypto";
 function generatePolicyId(name, scope) {
   const hash = createHash3("sha256").update(`${name}-${scope}-${Date.now()}`).digest("hex").slice(0, 8);
@@ -13143,16 +13190,16 @@ class GuardrailsStore {
   getFilePath(location) {
     switch (location) {
       case "user":
-        return join21(getConfigDir(), "guardrails.json");
+        return join22(getConfigDir(), "guardrails.json");
       case "project":
-        return join21(this.cwd, ".assistants", "guardrails.json");
+        return join22(this.cwd, ".assistants", "guardrails.json");
       case "local":
-        return join21(this.cwd, ".assistants", "guardrails.local.json");
+        return join22(this.cwd, ".assistants", "guardrails.local.json");
     }
   }
   loadFrom(location) {
     const filePath = this.getFilePath(location);
-    if (!existsSync13(filePath)) {
+    if (!existsSync14(filePath)) {
       return null;
     }
     try {
@@ -13167,9 +13214,9 @@ class GuardrailsStore {
   }
   save(location, config) {
     const filePath = this.getFilePath(location);
-    const dir = dirname9(filePath);
-    if (!existsSync13(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    const dir = dirname10(filePath);
+    if (!existsSync14(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
     ensurePolicyIds(config);
     writeFileSync8(filePath, JSON.stringify({ guardrails: config }, null, 2), "utf-8");
@@ -42572,8 +42619,8 @@ var require_core3 = __commonJS((exports) => {
   function many1(p) {
     return ab(p, many(p), (head, tail) => [head, ...tail]);
   }
-  function ab(pa, pb, join22) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join22(ma.value, vb, data, i, j)));
+  function ab(pa, pb, join23) {
+    return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join23(ma.value, vb, data, i, j)));
   }
   function left(pa, pb) {
     return ab(pa, pb, (va) => va);
@@ -42581,8 +42628,8 @@ var require_core3 = __commonJS((exports) => {
   function right(pa, pb) {
     return ab(pa, pb, (va, vb) => vb);
   }
-  function abc(pa, pb, pc, join22) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join22(ma.value, mb.value, vc, data, i, j))));
+  function abc(pa, pb, pc, join23) {
+    return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join23(ma.value, mb.value, vc, data, i, j))));
   }
   function middle(pa, pb, pc) {
     return abc(pa, pb, pc, (ra, rb) => rb);
@@ -51296,14 +51343,14 @@ var init_email_parser = __esm(() => {
 });
 
 // ../core/src/workspace/shared.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { homedir as homedir11 } from "os";
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync8,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync9,
   writeFileSync as writeFileSync9,
   readFileSync as readFileSync8,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   rmSync,
   renameSync
 } from "fs";
@@ -51312,33 +51359,33 @@ class SharedWorkspaceManager {
   basePath;
   constructor(basePath) {
     const envHome = process.env.HOME || process.env.USERPROFILE || homedir11();
-    this.basePath = basePath || join22(envHome, ".assistants", "workspaces");
+    this.basePath = basePath || join23(envHome, ".assistants", "workspaces");
     this.ensureDir();
     this.migrateAgentsToAssistants();
   }
   ensureDir() {
-    if (!existsSync14(this.basePath)) {
-      mkdirSync8(this.basePath, { recursive: true });
+    if (!existsSync15(this.basePath)) {
+      mkdirSync9(this.basePath, { recursive: true });
     }
   }
   migrateAgentsToAssistants() {
     try {
-      const dirs = readdirSync5(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = readdirSync6(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const dir of dirs) {
-        const wsPath = join22(this.basePath, dir);
-        const oldAgentsDir = join22(wsPath, "agents");
-        const newAssistantsDir = join22(wsPath, "assistants");
-        if (existsSync14(oldAgentsDir) && !existsSync14(newAssistantsDir)) {
+        const wsPath = join23(this.basePath, dir);
+        const oldAgentsDir = join23(wsPath, "agents");
+        const newAssistantsDir = join23(wsPath, "assistants");
+        if (existsSync15(oldAgentsDir) && !existsSync15(newAssistantsDir)) {
           renameSync(oldAgentsDir, newAssistantsDir);
         }
       }
     } catch {}
   }
   getWorkspacePath(id) {
-    return join22(this.basePath, id);
+    return join23(this.basePath, id);
   }
   getMetadataPath(id) {
-    return join22(this.getWorkspacePath(id), "workspace.json");
+    return join23(this.getWorkspacePath(id), "workspace.json");
   }
   create(name, createdBy, participants, description) {
     const id = `ws_${generateId().slice(0, 8)}`;
@@ -51353,9 +51400,9 @@ class SharedWorkspaceManager {
       status: "active"
     };
     const wsPath = this.getWorkspacePath(id);
-    mkdirSync8(join22(wsPath, "shared"), { recursive: true });
+    mkdirSync9(join23(wsPath, "shared"), { recursive: true });
     for (const assistantId of workspace.participants) {
-      mkdirSync8(join22(wsPath, "assistants", assistantId), { recursive: true });
+      mkdirSync9(join23(wsPath, "assistants", assistantId), { recursive: true });
     }
     writeFileSync9(this.getMetadataPath(id), JSON.stringify(workspace, null, 2));
     return workspace;
@@ -51370,15 +51417,15 @@ class SharedWorkspaceManager {
       workspace.updatedAt = Date.now();
       writeFileSync9(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
     }
-    const assistantDir = join22(this.getWorkspacePath(workspaceId), "assistants", assistantId);
-    if (!existsSync14(assistantDir)) {
-      mkdirSync8(assistantDir, { recursive: true });
+    const assistantDir = join23(this.getWorkspacePath(workspaceId), "assistants", assistantId);
+    if (!existsSync15(assistantDir)) {
+      mkdirSync9(assistantDir, { recursive: true });
     }
   }
   get(workspaceId) {
     try {
       const metadataPath = this.getMetadataPath(workspaceId);
-      if (!existsSync14(metadataPath))
+      if (!existsSync15(metadataPath))
         return null;
       return JSON.parse(readFileSync8(metadataPath, "utf-8"));
     } catch {
@@ -51389,15 +51436,15 @@ class SharedWorkspaceManager {
     return this.getWorkspacePath(workspaceId);
   }
   getSharedPath(workspaceId) {
-    return join22(this.getWorkspacePath(workspaceId), "shared");
+    return join23(this.getWorkspacePath(workspaceId), "shared");
   }
   getAssistantPath(workspaceId, assistantId) {
-    return join22(this.getWorkspacePath(workspaceId), "assistants", assistantId);
+    return join23(this.getWorkspacePath(workspaceId), "assistants", assistantId);
   }
   list(includeArchived = false) {
     try {
       this.ensureDir();
-      const dirs = readdirSync5(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = readdirSync6(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const workspaces = [];
       for (const dir of dirs) {
         const workspace = this.get(dir);
@@ -51425,7 +51472,7 @@ class SharedWorkspaceManager {
   }
   delete(workspaceId) {
     const wsPath = this.getWorkspacePath(workspaceId);
-    if (existsSync14(wsPath)) {
+    if (existsSync15(wsPath)) {
       rmSync(wsPath, { recursive: true, force: true });
     }
   }
@@ -51485,9 +51532,9 @@ var init_defaults2 = __esm(() => {
 });
 
 // ../core/src/budget/tracker.ts
-import { join as join23, dirname as dirname10 } from "path";
+import { join as join24, dirname as dirname11 } from "path";
 import { homedir as homedir12 } from "os";
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, readFileSync as readFileSync9 } from "fs";
 function createEmptyUsage() {
   const now2 = new Date().toISOString();
   return {
@@ -51521,16 +51568,16 @@ class BudgetTracker {
   }
   getStatePath() {
     const envHome = process.env.HOME || process.env.USERPROFILE || homedir12();
-    return join23(envHome, ".assistants", "budget", `${this.sessionId}.json`);
+    return join24(envHome, ".assistants", "budget", `${this.sessionId}.json`);
   }
   getProjectStatePath(projectId) {
     const envHome = process.env.HOME || process.env.USERPROFILE || homedir12();
-    return join23(envHome, ".assistants", "budget", `project-${projectId}.json`);
+    return join24(envHome, ".assistants", "budget", `project-${projectId}.json`);
   }
   loadState() {
     try {
       const statePath = this.getStatePath();
-      if (!existsSync15(statePath))
+      if (!existsSync16(statePath))
         return;
       const data = JSON.parse(readFileSync9(statePath, "utf-8"));
       if (data.version !== PERSISTENCE_VERSION && data.version !== 1)
@@ -51551,7 +51598,7 @@ class BudgetTracker {
   loadProjectState(projectId) {
     try {
       const statePath = this.getProjectStatePath(projectId);
-      if (!existsSync15(statePath))
+      if (!existsSync16(statePath))
         return createEmptyUsage();
       const data = JSON.parse(readFileSync9(statePath, "utf-8"));
       return data;
@@ -51564,9 +51611,9 @@ class BudgetTracker {
       return;
     try {
       const statePath = this.getProjectStatePath(projectId);
-      const stateDir = dirname10(statePath);
-      if (!existsSync15(stateDir)) {
-        mkdirSync9(stateDir, { recursive: true });
+      const stateDir = dirname11(statePath);
+      if (!existsSync16(stateDir)) {
+        mkdirSync10(stateDir, { recursive: true });
       }
       writeFileSync10(statePath, JSON.stringify(usage, null, 2));
     } catch {}
@@ -51576,9 +51623,9 @@ class BudgetTracker {
       return;
     try {
       const statePath = this.getStatePath();
-      const stateDir = dirname10(statePath);
-      if (!existsSync15(stateDir)) {
-        mkdirSync9(stateDir, { recursive: true });
+      const stateDir = dirname11(statePath);
+      if (!existsSync16(stateDir)) {
+        mkdirSync10(stateDir, { recursive: true });
       }
       const state = {
         version: PERSISTENCE_VERSION,
@@ -52151,8 +52198,8 @@ var init_types2 = __esm(() => {
 });
 
 // ../core/src/registry/store.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync11 } from "fs";
-import { join as join24, dirname as dirname11 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync11 } from "fs";
+import { join as join25, dirname as dirname12 } from "path";
 import { homedir as homedir13 } from "os";
 function generateAssistantId() {
   return `assistant_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -52290,12 +52337,12 @@ class RegistryStore {
       return this.config.storagePath;
     }
     const home = process.env.HOME || process.env.USERPROFILE || homedir13();
-    return join24(home, ".assistants", "registry", "assistants.json");
+    return join25(home, ".assistants", "registry", "assistants.json");
   }
   loadFromFile() {
     try {
       const path = this.getStoragePath();
-      if (!existsSync16(path))
+      if (!existsSync17(path))
         return;
       const data = JSON.parse(readFileSync10(path, "utf-8"));
       if (Array.isArray(data.assistants)) {
@@ -52310,9 +52357,9 @@ class RegistryStore {
       return;
     try {
       const path = this.getStoragePath();
-      const dir = dirname11(path);
-      if (!existsSync16(dir)) {
-        mkdirSync10(dir, { recursive: true });
+      const dir = dirname12(path);
+      if (!existsSync17(dir)) {
+        mkdirSync11(dir, { recursive: true });
       }
       const data = {
         version: 1,
@@ -61274,14 +61321,14 @@ var exports_anthropic = {};
 __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
-import { readFileSync as readFileSync11, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync19 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function loadApiKeyFromSecrets() {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir15();
-  const secretsPath = join26(homeDir, ".secrets");
-  if (existsSync18(secretsPath)) {
+  const secretsPath = join27(homeDir, ".secrets");
+  if (existsSync19(secretsPath)) {
     try {
       const content = readFileSync11(secretsPath, "utf-8");
       const match = content.match(/export\s+ANTHROPIC_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
@@ -67297,14 +67344,14 @@ var exports_openai = {};
 __export(exports_openai, {
   OpenAIClient: () => OpenAIClient
 });
-import { readFileSync as readFileSync12, existsSync as existsSync19 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync20 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function loadApiKeyFromSecrets2() {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir16();
-  const secretsPath = join27(homeDir, ".secrets");
-  if (existsSync19(secretsPath)) {
+  const secretsPath = join28(homeDir, ".secrets");
+  if (existsSync20(secretsPath)) {
     try {
       const content = readFileSync12(secretsPath, "utf-8");
       const match = content.match(/export\s+OPENAI_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
@@ -80501,7 +80548,7 @@ var require_readFile = __commonJS((exports) => {
   var promises_1 = __require("fs/promises");
   exports.filePromises = {};
   exports.fileIntercept = {};
-  var readFile13 = (path2, options) => {
+  var readFile14 = (path2, options) => {
     if (exports.fileIntercept[path2] !== undefined) {
       return exports.fileIntercept[path2];
     }
@@ -80510,7 +80557,7 @@ var require_readFile = __commonJS((exports) => {
     }
     return exports.filePromises[path2];
   };
-  exports.readFile = readFile13;
+  exports.readFile = readFile14;
 });
 
 // ../../node_modules/.bun/@smithy+shared-ini-file-loader@4.4.3/node_modules/@smithy/shared-ini-file-loader/dist-cjs/index.js
@@ -80520,7 +80567,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   var getSSOTokenFromFile = require_getSSOTokenFromFile();
   var path2 = __require("path");
   var types11 = require_dist_cjs();
-  var readFile13 = require_readFile();
+  var readFile14 = require_readFile();
   var ENV_PROFILE = "AWS_PROFILE";
   var DEFAULT_PROFILE2 = "default";
   var getProfileName = (init2) => init2.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE2;
@@ -80604,10 +80651,10 @@ var require_dist_cjs35 = __commonJS((exports) => {
       resolvedConfigFilepath = path2.join(homeDir, configFilepath.slice(2));
     }
     const parsedFiles = await Promise.all([
-      readFile13.readFile(resolvedConfigFilepath, {
+      readFile14.readFile(resolvedConfigFilepath, {
         ignoreCache: init2.ignoreCache
       }).then(parseIni).then(getConfigData).catch(swallowError$1),
-      readFile13.readFile(resolvedFilepath, {
+      readFile14.readFile(resolvedFilepath, {
         ignoreCache: init2.ignoreCache
       }).then(parseIni).catch(swallowError$1)
     ]);
@@ -80618,7 +80665,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   };
   var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(types11.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
   var swallowError = () => ({});
-  var loadSsoSessionData = async (init2 = {}) => readFile13.readFile(init2.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
+  var loadSsoSessionData = async (init2 = {}) => readFile14.readFile(init2.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
   var mergeConfigFiles = (...files) => {
     const merged = {};
     for (const file of files) {
@@ -80638,10 +80685,10 @@ var require_dist_cjs35 = __commonJS((exports) => {
   };
   var externalDataInterceptor = {
     getFileRecord() {
-      return readFile13.fileIntercept;
+      return readFile14.fileIntercept;
     },
     interceptFile(path3, contents) {
-      readFile13.fileIntercept[path3] = Promise.resolve(contents);
+      readFile14.fileIntercept[path3] = Promise.resolve(contents);
     },
     getTokenRecord() {
       return getSSOTokenFromFile.tokenIntercept;
@@ -80659,7 +80706,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   Object.defineProperty(exports, "readFile", {
     enumerable: true,
     get: function() {
-      return readFile13.readFile;
+      return readFile14.readFile;
     }
   });
   exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
@@ -87996,7 +88043,7 @@ var require_signin = __commonJS((exports) => {
 import { createHash as createHash4, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
 import { homedir as homedir18 } from "os";
-import { dirname as dirname15, join as join35 } from "path";
+import { dirname as dirname16, join as join36 } from "path";
 var import_property_provider18, import_protocol_http10, import_shared_ini_file_loader6, LoginCredentialsFetcher;
 var init_LoginCredentialsFetcher = __esm(() => {
   import_property_provider18 = __toESM(require_dist_cjs17(), 1);
@@ -88149,17 +88196,17 @@ var init_LoginCredentialsFetcher = __esm(() => {
     }
     async saveToken(token) {
       const tokenFilePath = this.getTokenFilePath();
-      const directory = dirname15(tokenFilePath);
+      const directory = dirname16(tokenFilePath);
       try {
         await fs2.mkdir(directory, { recursive: true });
       } catch (error2) {}
       await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
     }
     getTokenFilePath() {
-      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join35(homedir18(), ".aws", "login", "cache");
+      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join36(homedir18(), ".aws", "login", "cache");
       const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
       const loginSessionSha256 = createHash4("sha256").update(loginSessionBytes).digest("hex");
-      return join35(directory, `${loginSessionSha256}.json`);
+      return join36(directory, `${loginSessionSha256}.json`);
     }
     derToRawSignature(derSignature) {
       let offset = 2;
@@ -89198,8 +89245,8 @@ function many(p4) {
 function many1(p4) {
   return ab2(p4, many(p4), (head, tail) => [head, ...tail]);
 }
-function ab2(pa, pb, join37) {
-  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapInner(pb(data, ma.position), (vb, j4) => join37(ma.value, vb, data, i4, j4)));
+function ab2(pa, pb, join38) {
+  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapInner(pb(data, ma.position), (vb, j4) => join38(ma.value, vb, data, i4, j4)));
 }
 function left(pa, pb) {
   return ab2(pa, pb, (va) => va);
@@ -89207,8 +89254,8 @@ function left(pa, pb) {
 function right(pa, pb) {
   return ab2(pa, pb, (va, vb) => vb);
 }
-function abc(pa, pb, pc, join37) {
-  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j4) => join37(ma.value, mb.value, vc, data, i4, j4))));
+function abc(pa, pb, pc, join38) {
+  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j4) => join38(ma.value, mb.value, vc, data, i4, j4))));
 }
 function middle(pa, pb, pc) {
   return abc(pa, pb, pc, (ra, rb) => rb);
@@ -110706,12 +110753,70 @@ var init_node2 = __esm(() => {
   decoder = new TextDecoder("utf-8");
 });
 
+// ../core/src/webhooks/crypto.ts
+var exports_crypto = {};
+__export(exports_crypto, {
+  verifySignature: () => verifySignature,
+  signPayload: () => signPayload,
+  isTimestampValid: () => isTimestampValid,
+  generateWebhookSecret: () => generateWebhookSecret,
+  generateWebhookId: () => generateWebhookId,
+  generateEventId: () => generateEventId,
+  generateDeliveryId: () => generateDeliveryId
+});
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+function generateWebhookSecret() {
+  const bytes = randomBytes(32);
+  return `whsec_${bytes.toString("hex")}`;
+}
+function signPayload(payload, secret) {
+  const key = secret.startsWith("whsec_") ? secret.slice(6) : secret;
+  return createHmac("sha256", key).update(payload).digest("hex");
+}
+function verifySignature(payload, signature, secret) {
+  try {
+    const expected = signPayload(payload, secret);
+    const sigBuffer = Buffer.from(signature, "hex");
+    const expectedBuffer = Buffer.from(expected, "hex");
+    if (sigBuffer.length !== expectedBuffer.length) {
+      return false;
+    }
+    return timingSafeEqual(sigBuffer, expectedBuffer);
+  } catch {
+    return false;
+  }
+}
+function isTimestampValid(timestamp, maxAgeMs = 300000) {
+  try {
+    const eventTime = new Date(timestamp).getTime();
+    if (isNaN(eventTime))
+      return false;
+    const now2 = Date.now();
+    const age = Math.abs(now2 - eventTime);
+    return age <= maxAgeMs;
+  } catch {
+    return false;
+  }
+}
+function generateWebhookId() {
+  return `whk_${generateId().slice(0, 12)}`;
+}
+function generateEventId() {
+  return `evt_${generateId().slice(0, 12)}`;
+}
+function generateDeliveryId() {
+  return `dlv_${generateId().slice(0, 12)}`;
+}
+var init_crypto = __esm(() => {
+  init_src2();
+});
+
 // ../core/src/index.ts
 await init_runtime();
 
 // ../core/src/agent/loop.ts
 init_src2();
-import { join as join43 } from "path";
+import { join as join46 } from "path";
 
 // ../core/src/agent/context.ts
 init_src2();
@@ -115766,16 +115871,191 @@ function registerEnergyTools(registry, context) {
   }
 }
 
+// ../core/src/heartbeat/history.ts
+await init_config();
+import { dirname as dirname4, join as join6 } from "path";
+import { mkdirSync as mkdirSync2, existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { appendFile as appendFile2, readFile as readFile2 } from "fs/promises";
+function applySessionPlaceholder(path, sessionId) {
+  if (path.includes("{sessionId}")) {
+    return path.replace("{sessionId}", sessionId);
+  }
+  return path;
+}
+function resolveHeartbeatPersistPath(sessionId, persistPath) {
+  if (persistPath) {
+    return applySessionPlaceholder(persistPath, sessionId);
+  }
+  return join6(getConfigDir(), "heartbeats", `${sessionId}.json`);
+}
+function resolveHeartbeatHistoryPath(sessionId, historyPath) {
+  if (historyPath) {
+    return applySessionPlaceholder(historyPath, sessionId);
+  }
+  return join6(getConfigDir(), "heartbeats", "runs", `${sessionId}.jsonl`);
+}
+function listHeartbeatHistorySessions(baseDir) {
+  const dir = baseDir ?? join6(getConfigDir(), "heartbeats", "runs");
+  if (!existsSync4(dir))
+    return [];
+  return readdirSync2(dir).filter((file) => file.endsWith(".jsonl")).map((file) => file.replace(/\.jsonl$/, ""));
+}
+async function appendHeartbeatHistory(historyPath, heartbeat) {
+  try {
+    mkdirSync2(dirname4(historyPath), { recursive: true });
+    await appendFile2(historyPath, `${JSON.stringify(heartbeat)}
+`, "utf-8");
+  } catch {}
+}
+async function readHeartbeatHistory(historyPath, options = {}) {
+  try {
+    const content = await readFile2(historyPath, "utf-8");
+    const lines = content.split(`
+`).filter(Boolean);
+    const parsed = [];
+    for (const line of lines) {
+      try {
+        parsed.push(JSON.parse(line));
+      } catch {}
+    }
+    const order = options.order ?? "desc";
+    const ordered = order === "desc" ? parsed.reverse() : parsed;
+    if (options.limit && options.limit > 0) {
+      return ordered.slice(0, options.limit);
+    }
+    return ordered;
+  } catch {
+    return [];
+  }
+}
+async function readLatestHeartbeat(persistPath, historyPath) {
+  if (historyPath) {
+    const history = await readHeartbeatHistory(historyPath, { limit: 1, order: "desc" });
+    if (history.length > 0)
+      return history[0];
+  }
+  try {
+    const content = await readFile2(persistPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// ../core/src/tools/heartbeat.ts
+var heartbeatStatusTool = {
+  name: "heartbeat_status",
+  description: "Get heartbeat status, last heartbeat record, and optional recent runs for a session.",
+  parameters: {
+    type: "object",
+    properties: {
+      sessionId: {
+        type: "string",
+        description: "Optional session id (defaults to current session)"
+      },
+      includeRuns: {
+        type: "boolean",
+        description: "Include recent heartbeat runs in the response"
+      },
+      limit: {
+        type: "number",
+        description: "Max number of runs to include (default: 20)"
+      }
+    },
+    required: []
+  }
+};
+var heartbeatRunsTool = {
+  name: "heartbeat_runs",
+  description: "List heartbeat runs for a session with optional limits and ordering.",
+  parameters: {
+    type: "object",
+    properties: {
+      sessionId: {
+        type: "string",
+        description: "Optional session id (defaults to current session)"
+      },
+      limit: {
+        type: "number",
+        description: "Max number of runs to return (default: 50)"
+      },
+      order: {
+        type: "string",
+        description: 'Sort order: "asc" or "desc" (default: desc)',
+        enum: ["asc", "desc"]
+      }
+    },
+    required: []
+  }
+};
+var heartbeatTools = [heartbeatStatusTool, heartbeatRunsTool];
+function parseLimit(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}
+function createHeartbeatToolExecutors(context) {
+  return {
+    heartbeat_status: async (input) => {
+      const sessionId = typeof input.sessionId === "string" && input.sessionId.trim().length > 0 ? input.sessionId.trim() : context.sessionId;
+      const config = context.getHeartbeatConfig?.() ?? null;
+      const persistPath = resolveHeartbeatPersistPath(sessionId, config?.persistPath);
+      const historyPath = resolveHeartbeatHistoryPath(sessionId, config?.historyPath);
+      const lastHeartbeat = await readLatestHeartbeat(persistPath, historyPath);
+      const state = context.getHeartbeatState?.() ?? null;
+      const staleThreshold = config?.staleThresholdMs ?? 120000;
+      const lastTimestamp = lastHeartbeat ? new Date(lastHeartbeat.timestamp).getTime() : null;
+      const computedStale = lastTimestamp ? Date.now() - lastTimestamp > staleThreshold : true;
+      const includeRuns = Boolean(input.includeRuns);
+      const limit = parseLimit(input.limit, 20);
+      const runs = includeRuns ? await readHeartbeatHistory(historyPath, { limit, order: "desc" }) : undefined;
+      const enabled = state?.enabled ?? (config ? true : false);
+      return JSON.stringify({
+        success: true,
+        sessionId,
+        enabled,
+        state: state?.state ?? lastHeartbeat?.state ?? null,
+        isStale: state?.isStale ?? computedStale,
+        lastActivity: state?.lastActivity ?? lastHeartbeat?.lastActivity ?? null,
+        uptimeSeconds: state?.uptimeSeconds ?? lastHeartbeat?.stats?.uptimeSeconds ?? null,
+        lastHeartbeat,
+        runs
+      });
+    },
+    heartbeat_runs: async (input) => {
+      const sessionId = typeof input.sessionId === "string" && input.sessionId.trim().length > 0 ? input.sessionId.trim() : context.sessionId;
+      const config = context.getHeartbeatConfig?.() ?? null;
+      const historyPath = resolveHeartbeatHistoryPath(sessionId, config?.historyPath);
+      const order = input.order === "asc" ? "asc" : "desc";
+      const limit = parseLimit(input.limit, 50);
+      const runs = await readHeartbeatHistory(historyPath, { limit, order });
+      return JSON.stringify({
+        success: true,
+        sessionId,
+        count: runs.length,
+        runs
+      });
+    }
+  };
+}
+function registerHeartbeatTools(registry, context) {
+  const executors = createHeartbeatToolExecutors(context);
+  for (const tool of heartbeatTools) {
+    registry.register(tool, executors[tool.name]);
+  }
+}
+
 // ../core/src/tools/context-entries.ts
 init_src2();
 
 // ../core/src/projects/store.ts
 init_src2();
-import { join as join6 } from "path";
-import { mkdir as mkdir4, readdir, readFile as readFile2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { join as join7 } from "path";
+import { mkdir as mkdir4, readdir, readFile as readFile3, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 var SAFE_ID_PATTERN2 = /^[a-zA-Z0-9_-]+$/;
 function projectsDir(cwd) {
-  return join6(cwd, ".assistants", "projects");
+  return join7(cwd, ".assistants", "projects");
 }
 function isSafeId2(id) {
   return SAFE_ID_PATTERN2.test(id);
@@ -115783,7 +116063,7 @@ function isSafeId2(id) {
 function projectPath(cwd, id) {
   if (!isSafeId2(id))
     return null;
-  return join6(projectsDir(cwd), `${id}.json`);
+  return join7(projectsDir(cwd), `${id}.json`);
 }
 async function ensureProjectsDir(cwd) {
   await mkdir4(projectsDir(cwd), { recursive: true });
@@ -115800,7 +116080,7 @@ async function listProjects(cwd) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const raw = await readFile2(join6(dir, file), "utf-8");
+        const raw = await readFile3(join7(dir, file), "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.id && parsed?.name) {
           projects.push(parsed);
@@ -115817,7 +116097,7 @@ async function readProject(cwd, id) {
     const path = projectPath(cwd, id);
     if (!path)
       return null;
-    const raw = await readFile2(path, "utf-8");
+    const raw = await readFile3(path, "utf-8");
     const project = JSON.parse(raw);
     if (!project?.id || !project?.name)
       return null;
@@ -115884,9 +116164,9 @@ function hasProjectNameConflict(projects, name) {
 }
 
 // ../core/src/projects/context.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { resolve as resolve2, join as join7 } from "path";
+import { resolve as resolve2, join as join8 } from "path";
 
 // ../core/src/validation/paths.ts
 import { resolve, normalize, relative, isAbsolute } from "path";
@@ -115967,7 +116247,7 @@ function normalizeEntryLabel(entry) {
 }
 async function renderFileEntry(entry, options) {
   const rawPath = entry.value.trim();
-  const expandedPath = rawPath === "~" ? homedir5() : rawPath.startsWith("~/") ? join7(homedir5(), rawPath.slice(2)) : rawPath;
+  const expandedPath = rawPath === "~" ? homedir5() : rawPath.startsWith("~/") ? join8(homedir5(), rawPath.slice(2)) : rawPath;
   const resolved = resolve2(options.cwd, expandedPath);
   const validation = await validatePath(resolved, { allowedPaths: [options.cwd] });
   if (!validation.valid) {
@@ -115975,7 +116255,7 @@ async function renderFileEntry(entry, options) {
   }
   let content = "";
   try {
-    const data = await readFile3(validation.resolved, "utf-8");
+    const data = await readFile4(validation.resolved, "utf-8");
     const limit = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
     if (data.length > limit) {
       content = `${data.slice(0, limit)}
@@ -116480,8 +116760,8 @@ function registerSecurityTools(registry, context) {
 
 // ../core/src/logger.ts
 await init_config();
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, appendFileSync, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, appendFileSync, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join9 } from "path";
 var SAFE_ID_PATTERN3 = /^[a-zA-Z0-9_-]+$/;
 function isValidId(id) {
   return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN3.test(id);
@@ -116493,14 +116773,14 @@ class Logger {
   sessionId;
   constructor(sessionId, basePath) {
     this.sessionId = sessionId;
-    this.logDir = join8(basePath || getConfigDir(), "logs");
+    this.logDir = join9(basePath || getConfigDir(), "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join8(this.logDir, `${date}.log`);
+    this.logFile = join9(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync4(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
   }
   write(level, message, data) {
@@ -116532,12 +116812,12 @@ class Logger {
     this.write("error", message, data);
   }
   static readEntries(options) {
-    const logDir = join8(options?.basePath || getConfigDir(), "logs");
-    if (!existsSync4(logDir))
+    const logDir = join9(options?.basePath || getConfigDir(), "logs");
+    if (!existsSync5(logDir))
       return [];
     const levelOrder = { debug: 0, info: 1, warn: 2, error: 3 };
     const minLevel = options?.level ? levelOrder[options.level] : 0;
-    const files = readdirSync2(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).sort((a, b) => b.localeCompare(a));
+    const files = readdirSync3(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).sort((a, b) => b.localeCompare(a));
     const entries = [];
     for (const file of files) {
       if (options?.since) {
@@ -116547,7 +116827,7 @@ class Logger {
           break;
       }
       try {
-        const content = readFileSync3(join8(logDir, file), "utf-8");
+        const content = readFileSync3(join9(logDir, file), "utf-8");
         const lines = content.trim().split(`
 `).filter(Boolean);
         for (const line of lines) {
@@ -116570,10 +116850,10 @@ class Logger {
     return entries.slice(offset, offset + limit);
   }
   static listLogDates(basePath) {
-    const logDir = join8(basePath || getConfigDir(), "logs");
-    if (!existsSync4(logDir))
+    const logDir = join9(basePath || getConfigDir(), "logs");
+    if (!existsSync5(logDir))
       return [];
-    return readdirSync2(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).map((f) => f.replace(".log", "")).sort((a, b) => b.localeCompare(a));
+    return readdirSync3(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).map((f) => f.replace(".log", "")).sort((a, b) => b.localeCompare(a));
   }
 }
 
@@ -116588,13 +116868,13 @@ class SessionStorage {
     this.sessionId = sessionId;
     const root = basePath || getConfigDir();
     const safeAssistantId = isValidId(assistantId) ? assistantId : null;
-    this.sessionsDir = safeAssistantId ? join8(root, "assistants", safeAssistantId, "sessions") : join8(root, "sessions");
+    this.sessionsDir = safeAssistantId ? join9(root, "assistants", safeAssistantId, "sessions") : join9(root, "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join8(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join9(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync4(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
   }
   save(data) {
@@ -116607,7 +116887,7 @@ class SessionStorage {
   }
   load() {
     try {
-      if (!existsSync4(this.sessionFile))
+      if (!existsSync5(this.sessionFile))
         return null;
       return JSON.parse(readFileSync3(this.sessionFile, "utf-8"));
     } catch {
@@ -116616,8 +116896,8 @@ class SessionStorage {
   }
   static getActiveAssistantId() {
     try {
-      const activePath = join8(getConfigDir(), "active.json");
-      if (!existsSync4(activePath))
+      const activePath = join9(getConfigDir(), "active.json");
+      if (!existsSync5(activePath))
         return null;
       const raw = readFileSync3(activePath, "utf-8");
       const data = JSON.parse(raw);
@@ -116631,38 +116911,65 @@ class SessionStorage {
     }
   }
   static resolveSessionsDir(assistantId) {
+    return SessionStorage.resolveSessionsDirWithAssistant(assistantId).dir;
+  }
+  static resolveSessionsDirWithAssistant(assistantId) {
     const root = getConfigDir();
     const safeAssistantId = isValidId(assistantId) ? assistantId : null;
     const resolvedId = safeAssistantId ?? SessionStorage.getActiveAssistantId();
     if (resolvedId && isValidId(resolvedId)) {
-      const assistantDir = join8(root, "assistants", resolvedId, "sessions");
-      if (existsSync4(assistantDir)) {
-        return assistantDir;
+      const assistantDir = join9(root, "assistants", resolvedId, "sessions");
+      if (existsSync5(assistantDir)) {
+        return { dir: assistantDir, assistantId: resolvedId };
       }
     }
-    return join8(root, "sessions");
+    return { dir: join9(root, "sessions"), assistantId: null };
   }
-  static listSessions(assistantId) {
-    const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    if (!existsSync4(sessionsDir))
+  static readSessionsFromDir(sessionsDir, assistantId) {
+    if (!existsSync5(sessionsDir))
       return [];
     const sessions = [];
-    const files = readdirSync2(sessionsDir);
+    const files = readdirSync3(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const filePath = join8(sessionsDir, file);
+        const filePath = join9(sessionsDir, file);
         const content = JSON.parse(readFileSync3(filePath, "utf-8"));
         sessions.push({
           id: file.replace(".json", ""),
           cwd: content.cwd,
           startedAt: content.startedAt,
           updatedAt: content.updatedAt,
-          messageCount: content.messages?.length || 0
+          messageCount: content.messages?.length || 0,
+          assistantId
         });
       } catch {}
     }
+    return sessions;
+  }
+  static listSessions(assistantId) {
+    const { dir, assistantId: resolvedAssistantId } = SessionStorage.resolveSessionsDirWithAssistant(assistantId);
+    const sessions = SessionStorage.readSessionsFromDir(dir, resolvedAssistantId);
+    return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+  }
+  static listAllSessions() {
+    const root = getConfigDir();
+    const sessions = [];
+    const rootSessionsDir = join9(root, "sessions");
+    sessions.push(...SessionStorage.readSessionsFromDir(rootSessionsDir, null));
+    const assistantsDir = join9(root, "assistants");
+    if (existsSync5(assistantsDir)) {
+      const entries = readdirSync3(assistantsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        if (!isValidId(entry.name))
+          continue;
+        const assistantSessionsDir = join9(assistantsDir, entry.name, "sessions");
+        sessions.push(...SessionStorage.readSessionsFromDir(assistantSessionsDir, entry.name));
+      }
+    }
     return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
   }
   static getLatestSession(assistantId) {
@@ -116674,9 +116981,9 @@ class SessionStorage {
       return null;
     }
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    const sessionFile = join8(sessionsDir, `${sessionId}.json`);
+    const sessionFile = join9(sessionsDir, `${sessionId}.json`);
     try {
-      if (!existsSync4(sessionFile))
+      if (!existsSync5(sessionFile))
         return null;
       return JSON.parse(readFileSync3(sessionFile, "utf-8"));
     } catch {
@@ -116688,40 +116995,40 @@ function initAssistantsDir() {
   const baseDir = getConfigDir();
   const dirs = [
     baseDir,
-    join8(baseDir, "logs"),
-    join8(baseDir, "assistants"),
-    join8(baseDir, "shared", "skills"),
-    join8(baseDir, "commands"),
-    join8(baseDir, "temp"),
-    join8(baseDir, "heartbeats"),
-    join8(baseDir, "state"),
-    join8(baseDir, "energy"),
-    join8(baseDir, "migration")
+    join9(baseDir, "logs"),
+    join9(baseDir, "assistants"),
+    join9(baseDir, "shared", "skills"),
+    join9(baseDir, "commands"),
+    join9(baseDir, "temp"),
+    join9(baseDir, "heartbeats"),
+    join9(baseDir, "state"),
+    join9(baseDir, "energy"),
+    join9(baseDir, "migration")
   ];
   for (const dir of dirs) {
-    if (!existsSync4(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
   }
 }
 
 // ../core/src/hooks/logger.ts
 await init_config();
-import { join as join9 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, appendFileSync as appendFileSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, appendFileSync as appendFileSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 var MAX_ENTRIES = 1000;
 function getLogPath() {
-  return join9(getConfigDir(), "logs", "hooks.jsonl");
+  return join10(getConfigDir(), "logs", "hooks.jsonl");
 }
 function ensureLogsDir() {
-  const logsDir = join9(getConfigDir(), "logs");
-  if (!existsSync5(logsDir)) {
-    mkdirSync3(logsDir, { recursive: true });
+  const logsDir = join10(getConfigDir(), "logs");
+  if (!existsSync6(logsDir)) {
+    mkdirSync4(logsDir, { recursive: true });
   }
 }
 function rotateIfNeeded() {
   const logPath = getLogPath();
-  if (!existsSync5(logPath))
+  if (!existsSync6(logPath))
     return;
   try {
     const content = readFileSync4(logPath, "utf-8");
@@ -116779,7 +117086,7 @@ class HookLogger {
   }
   static getHistory(limit = 50, hookId) {
     const logPath = getLogPath();
-    if (!existsSync5(logPath))
+    if (!existsSync6(logPath))
       return [];
     try {
       const content = readFileSync4(logPath, "utf-8");
@@ -116801,7 +117108,7 @@ class HookLogger {
   }
   static clearHistory() {
     const logPath = getLogPath();
-    if (existsSync5(logPath)) {
+    if (existsSync6(logPath)) {
       writeFileSync3(logPath, "", "utf-8");
     }
   }
@@ -117172,22 +117479,22 @@ function registerLogsTools(registry, context) {
 
 // ../core/src/sessions/verification.ts
 init_src2();
-import { join as join10 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync3, unlinkSync } from "fs";
+import { join as join11 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync4, unlinkSync } from "fs";
 
 class VerificationSessionStore {
   basePath;
   maxSessions;
   lastTimestamp;
   constructor(basePath, maxSessions = 100) {
-    this.basePath = join10(basePath, "verifications");
+    this.basePath = join11(basePath, "verifications");
     this.maxSessions = maxSessions;
     this.lastTimestamp = 0;
     this.ensureDirectory();
   }
   ensureDirectory() {
-    if (!existsSync6(this.basePath)) {
-      mkdirSync4(this.basePath, { recursive: true });
+    if (!existsSync7(this.basePath)) {
+      mkdirSync5(this.basePath, { recursive: true });
     }
   }
   create(parentSessionId, goals, verificationResult) {
@@ -117212,12 +117519,12 @@ class VerificationSessionStore {
     return session;
   }
   save(session) {
-    const filePath = join10(this.basePath, `${session.id}.json`);
+    const filePath = join11(this.basePath, `${session.id}.json`);
     writeFileSync4(filePath, JSON.stringify(session, null, 2));
   }
   get(id) {
-    const filePath = join10(this.basePath, `${id}.json`);
-    if (!existsSync6(filePath)) {
+    const filePath = join11(this.basePath, `${id}.json`);
+    if (!existsSync7(filePath)) {
       return null;
     }
     try {
@@ -117232,7 +117539,7 @@ class VerificationSessionStore {
     const files = this.listFiles();
     for (const file of files) {
       try {
-        const content = readFileSync5(join10(this.basePath, file), "utf-8");
+        const content = readFileSync5(join11(this.basePath, file), "utf-8");
         const session = JSON.parse(content);
         if (session.parentSessionId === parentSessionId) {
           sessions.push(session);
@@ -117248,7 +117555,7 @@ class VerificationSessionStore {
     const files = this.listFiles();
     for (const file of files) {
       try {
-        const content = readFileSync5(join10(this.basePath, file), "utf-8");
+        const content = readFileSync5(join11(this.basePath, file), "utf-8");
         const session = JSON.parse(content);
         sessions.push(session);
       } catch {
@@ -117265,10 +117572,10 @@ class VerificationSessionStore {
     this.save(session);
   }
   listFiles() {
-    if (!existsSync6(this.basePath)) {
+    if (!existsSync7(this.basePath)) {
       return [];
     }
-    return readdirSync3(this.basePath).filter((f) => f.endsWith(".json"));
+    return readdirSync4(this.basePath).filter((f) => f.endsWith(".json"));
   }
   pruneOldSessions() {
     const files = this.listFiles();
@@ -117278,7 +117585,7 @@ class VerificationSessionStore {
     const sessions = [];
     for (const file of files) {
       try {
-        const content = readFileSync5(join10(this.basePath, file), "utf-8");
+        const content = readFileSync5(join11(this.basePath, file), "utf-8");
         const session = JSON.parse(content);
         sessions.push({
           file,
@@ -117292,7 +117599,7 @@ class VerificationSessionStore {
     const toRemove = sessions.slice(0, sessions.length - this.maxSessions);
     for (const item of toRemove) {
       try {
-        unlinkSync(join10(this.basePath, item.file));
+        unlinkSync(join11(this.basePath, item.file));
       } catch {
         continue;
       }
@@ -117302,7 +117609,7 @@ class VerificationSessionStore {
     const files = this.listFiles();
     for (const file of files) {
       try {
-        unlinkSync(join10(this.basePath, file));
+        unlinkSync(join11(this.basePath, file));
       } catch {
         continue;
       }
@@ -117364,7 +117671,7 @@ class HookLoader {
 // ../core/src/hooks/executor.ts
 init_src2();
 await init_runtime();
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 // ../core/src/hooks/background.ts
 class BackgroundProcessManager {
@@ -117578,7 +117885,7 @@ class HookExecutor {
     }
     try {
       const runtime = getRuntime();
-      const cwd = input.cwd && existsSync7(input.cwd) ? input.cwd : process.cwd();
+      const cwd = input.cwd && existsSync8(input.cwd) ? input.cwd : process.cwd();
       const isWindows = process.platform === "win32";
       const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
       const shellArgs = isWindows ? ["/c", hook.command] : ["-lc", hook.command];
@@ -117631,7 +117938,7 @@ class HookExecutor {
       return null;
     try {
       const runtime = getRuntime();
-      const cwd = input.cwd && existsSync7(input.cwd) ? input.cwd : process.cwd();
+      const cwd = input.cwd && existsSync8(input.cwd) ? input.cwd : process.cwd();
       const isWindows = process.platform === "win32";
       const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
       const shellArgs = isWindows ? ["/c", hook.command] : ["-lc", hook.command];
@@ -118200,8 +118507,8 @@ function createScopeVerificationHook() {
 }
 // ../core/src/hooks/store.ts
 await init_config();
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
-import { join as join11, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
 function generateHookId2(event, hook) {
   const content = hook.command || hook.prompt || "";
@@ -118228,16 +118535,16 @@ class HookStore {
   getFilePath(location) {
     switch (location) {
       case "user":
-        return join11(getConfigDir(), "hooks.json");
+        return join12(getConfigDir(), "hooks.json");
       case "project":
-        return join11(this.cwd, ".assistants", "hooks.json");
+        return join12(this.cwd, ".assistants", "hooks.json");
       case "local":
-        return join11(this.cwd, ".assistants", "hooks.local.json");
+        return join12(this.cwd, ".assistants", "hooks.local.json");
     }
   }
   loadFrom(location) {
     const filePath = this.getFilePath(location);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       return {};
     }
     try {
@@ -118252,9 +118559,9 @@ class HookStore {
   }
   save(location, config) {
     const filePath = this.getFilePath(location);
-    const dir = dirname4(filePath);
-    if (!existsSync8(dir)) {
-      mkdirSync5(dir, { recursive: true });
+    const dir = dirname5(filePath);
+    if (!existsSync9(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
     ensureHookIds(config);
     writeFileSync5(filePath, JSON.stringify({ hooks: config }, null, 2), "utf-8");
@@ -118394,7 +118701,7 @@ class HookStore {
 // ../core/src/hooks/tester.ts
 init_src2();
 await init_runtime();
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 var sampleInputs = {
   SessionStart: {
     source: "test"
@@ -118518,7 +118825,7 @@ class HookTester {
   }
   async executeCommand(command, input, timeout) {
     const runtime = getRuntime();
-    const cwd = input.cwd && existsSync9(input.cwd) ? input.cwd : process.cwd();
+    const cwd = input.cwd && existsSync10(input.cwd) ? input.cwd : process.cwd();
     const isWindows = process.platform === "win32";
     const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
     const shellArgs = isWindows ? ["/c", command] : ["-lc", command];
@@ -119625,7 +119932,7 @@ await __promiseAll([
   init_config(),
   init_runtime()
 ]);
-import { join as join12, resolve as resolve4, dirname as dirname5, sep } from "path";
+import { join as join13, resolve as resolve4, dirname as dirname6, sep } from "path";
 import { homedir as homedir7 } from "os";
 import { mkdir as mkdir5 } from "fs/promises";
 
@@ -119791,7 +120098,7 @@ function isWithinPath2(target, base) {
 var currentSessionId = "default";
 function getScriptsFolder(cwd, sessionId) {
   const resolvedSessionId = sessionId || currentSessionId;
-  return join12(getProjectConfigDir(cwd), "scripts", resolvedSessionId);
+  return join13(getProjectConfigDir(cwd), "scripts", resolvedSessionId);
 }
 function isInScriptsFolder(path, cwd, sessionId) {
   const scriptsFolder = resolve4(getScriptsFolder(cwd, sessionId));
@@ -120000,7 +120307,7 @@ class FilesystemTools {
       });
     }
     const sanitizedFilename = filename.replace(/\.\.[/\\]/g, "").replace(/\.\./g, "").replace(/^[/\\]+/, "");
-    const path = join12(scriptsFolder, sanitizedFilename);
+    const path = join13(scriptsFolder, sanitizedFilename);
     if (!isInScriptsFolder(path, baseCwd, input.sessionId)) {
       throw new ToolExecutionError(`Cannot write outside scripts folder. Files are saved to ${scriptsFolder}`, {
         toolName: "write",
@@ -120043,7 +120350,7 @@ class FilesystemTools {
           retryable: false
         });
       }
-      const dir = dirname5(validated.resolved);
+      const dir = dirname6(validated.resolved);
       await mkdir5(dir, { recursive: true });
       const runtime = getRuntime();
       await runtime.write(validated.resolved, content);
@@ -120251,7 +120558,7 @@ class FilesystemTools {
           if (file.includes(".Trash") || file.includes(".Spotlight-V100") || file.includes(".fseventsd")) {
             continue;
           }
-          const filePath = join12(validated.resolved, file);
+          const filePath = join13(validated.resolved, file);
           try {
             const content = await runtime.file(filePath).text();
             const lines = content.split(`
@@ -121094,8 +121401,8 @@ function isPrivateIPv42(octets) {
 // ../core/src/tools/feedback.ts
 init_src2();
 await init_config();
-import { join as join13 } from "path";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
 function normalizeTags(value) {
   if (Array.isArray(value)) {
     const tags = value.map((t) => String(t).trim()).filter(Boolean);
@@ -121109,16 +121416,16 @@ function normalizeTags(value) {
 }
 function resolveFeedbackDir(cwd) {
   const baseCwd = cwd && cwd.trim().length > 0 ? cwd : process.cwd();
-  const projectConfigDir = join13(baseCwd, ".assistants");
-  if (existsSync10(projectConfigDir)) {
-    return join13(projectConfigDir, "feedback");
+  const projectConfigDir = join14(baseCwd, ".assistants");
+  if (existsSync11(projectConfigDir)) {
+    return join14(projectConfigDir, "feedback");
   }
-  return join13(getConfigDir(), "feedback");
+  return join14(getConfigDir(), "feedback");
 }
 function saveFeedbackEntry(entry, cwd) {
   const feedbackDir = resolveFeedbackDir(cwd);
-  mkdirSync6(feedbackDir, { recursive: true });
-  const path = join13(feedbackDir, `${entry.id}.json`);
+  mkdirSync7(feedbackDir, { recursive: true });
+  const path = join14(feedbackDir, `${entry.id}.json`);
   writeFileSync6(path, JSON.stringify(entry, null, 2));
   return { path };
 }
@@ -121218,15 +121525,15 @@ init_src2();
 
 // ../core/src/scheduler/store.ts
 await init_config();
-import { join as join14 } from "path";
-import { mkdir as mkdir6, readdir as readdir2, readFile as readFile4, unlink as unlink3, writeFile as writeFile3, open as open2 } from "fs/promises";
+import { join as join15 } from "path";
+import { mkdir as mkdir6, readdir as readdir2, readFile as readFile5, unlink as unlink3, writeFile as writeFile3, open as open2 } from "fs/promises";
 var DEFAULT_LOCK_TTL_MS = 10 * 60 * 1000;
 var SAFE_ID_PATTERN4 = /^[a-zA-Z0-9_-]+$/;
 function schedulesDir(cwd) {
-  return join14(getProjectConfigDir(cwd), "schedules");
+  return join15(getProjectConfigDir(cwd), "schedules");
 }
 function locksDir(cwd) {
-  return join14(schedulesDir(cwd), "locks");
+  return join15(schedulesDir(cwd), "locks");
 }
 function isSafeId3(id) {
   return SAFE_ID_PATTERN4.test(id);
@@ -121234,10 +121541,10 @@ function isSafeId3(id) {
 function schedulePath(cwd, id) {
   if (!isSafeId3(id))
     return null;
-  return join14(schedulesDir(cwd), `${id}.json`);
+  return join15(schedulesDir(cwd), `${id}.json`);
 }
 function lockPath(cwd, id) {
-  return join14(locksDir(cwd), `${id}.lock.json`);
+  return join15(locksDir(cwd), `${id}.lock.json`);
 }
 async function ensureDirs(cwd) {
   await mkdir6(schedulesDir(cwd), { recursive: true });
@@ -121252,7 +121559,7 @@ async function listSchedules(cwd, options) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const raw = await readFile4(join14(dir, file), "utf-8");
+        const raw = await readFile5(join15(dir, file), "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.id)
           schedules.push(parsed);
@@ -121279,7 +121586,7 @@ async function getSchedule(cwd, id) {
     const path = schedulePath(cwd, id);
     if (!path)
       return null;
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -121360,7 +121667,7 @@ async function updateSchedule(cwd, id, updater) {
     const path = schedulePath(cwd, id);
     if (!path)
       return null;
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     const schedule = JSON.parse(raw);
     const updated = updater(schedule);
     await saveSchedule(cwd, updated);
@@ -121382,7 +121689,7 @@ async function acquireScheduleLock(cwd, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS
     return true;
   } catch {
     try {
-      const raw = await readFile4(path, "utf-8");
+      const raw = await readFile5(path, "utf-8");
       const lock = JSON.parse(raw);
       const updatedAt = lock?.updatedAt || lock?.createdAt || 0;
       const ttl = lock?.ttlMs ?? ttlMs;
@@ -121408,7 +121715,7 @@ async function releaseScheduleLock(cwd, id, ownerId) {
     return;
   const path = lockPath(cwd, id);
   try {
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     const lock = JSON.parse(raw);
     if (lock?.ownerId === ownerId) {
       await unlink3(path);
@@ -121420,7 +121727,7 @@ async function refreshScheduleLock(cwd, id, ownerId) {
     return;
   const path = lockPath(cwd, id);
   try {
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     const lock = JSON.parse(raw);
     if (lock?.ownerId === ownerId) {
       const updated = { ...lock, updatedAt: Date.now() };
@@ -121433,7 +121740,7 @@ async function readSchedule(cwd, id) {
     const path = schedulePath(cwd, id);
     if (!path)
       return null;
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     const schedule = JSON.parse(raw);
     if (!schedule?.id)
       return null;
@@ -121772,9 +122079,9 @@ class SchedulerTool {
 // ../core/src/tools/image.ts
 init_src2();
 await init_runtime();
-import { existsSync as existsSync11, writeFileSync as writeFileSync7, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { homedir as homedir8 } from "os";
 var FETCH_TIMEOUT_MS = 30000;
 var MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
@@ -121793,7 +122100,7 @@ async function getViuPath() {
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir8();
   const locations = [
     "viu",
-    join15(homeDir, ".cargo", "bin", "viu"),
+    join16(homeDir, ".cargo", "bin", "viu"),
     "/usr/local/bin/viu",
     "/opt/homebrew/bin/viu"
   ];
@@ -121898,7 +122205,7 @@ class ImageDisplayTool {
           offset += chunk.length;
         }
         const ext = contentType.split("/")[1]?.split(";")[0] || "png";
-        tempFile = join15(tmpdir(), `assistants-image-${generateId()}.${ext}`);
+        tempFile = join16(tmpdir(), `assistants-image-${generateId()}.${ext}`);
         writeFileSync7(tempFile, buffer);
         localPath = tempFile;
       } catch (error) {
@@ -121908,7 +122215,7 @@ class ImageDisplayTool {
         return `Error: Failed to fetch image: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
-    if (!existsSync11(localPath)) {
+    if (!existsSync12(localPath)) {
       return `Error: Image file not found: ${localPath}`;
     }
     try {
@@ -121936,7 +122243,7 @@ class ImageDisplayTool {
     } catch (error) {
       return `Error: ${error instanceof Error ? error.message : String(error)}`;
     } finally {
-      if (tempFile && existsSync11(tempFile)) {
+      if (tempFile && existsSync12(tempFile)) {
         try {
           unlinkSync2(tempFile);
         } catch {}
@@ -121956,7 +122263,7 @@ init_errors();
 
 // ../core/src/skills/create.ts
 await init_config();
-import { join as join16, dirname as dirname6 } from "path";
+import { join as join17, dirname as dirname7 } from "path";
 import { mkdir as mkdir7, stat, writeFile as writeFile4, rm } from "fs/promises";
 function slugify(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9\s_-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -122013,9 +122320,9 @@ function buildDefaultContent() {
 }
 function resolveSkillRoot(scope, cwd) {
   if (scope === "global") {
-    return join16(getConfigDir(), "shared", "skills");
+    return join17(getConfigDir(), "shared", "skills");
   }
-  return join16(cwd, ".assistants", "skills");
+  return join17(cwd, ".assistants", "skills");
 }
 async function pathExists(path) {
   try {
@@ -122029,8 +122336,8 @@ async function createSkill(options) {
   const scope = options.scope ?? "project";
   const { skillName, dirName } = normalizeName2(options.name);
   const root = resolveSkillRoot(scope, options.cwd);
-  const directory = join16(root, dirName);
-  const filePath = join16(directory, "SKILL.md");
+  const directory = join17(root, dirName);
+  const filePath = join17(directory, "SKILL.md");
   if (!options.overwrite && await pathExists(filePath)) {
     throw new Error(`Skill already exists at ${filePath}`);
   }
@@ -122053,7 +122360,7 @@ ${content}
 // ../core/src/skills/executor.ts
 init_src2();
 await init_runtime();
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 
 class SkillExecutor {
   constructor() {}
@@ -122074,7 +122381,7 @@ ARGUMENTS: ${args.join(" ")}`;
     if (matches.length === 0) {
       return content;
     }
-    const skillDir = dirname7(skillFilePath);
+    const skillDir = dirname8(skillFilePath);
     let result = content;
     const runtime = getRuntime();
     for (const match of matches) {
@@ -122697,9 +123004,9 @@ Respond with ALLOW or DENY on the first line, followed by a short reason.`,
 // ../core/src/skills/loader.ts
 init_src2();
 var import_fast_glob = __toESM(require_out4(), 1);
-import { join as join17, basename as basename3, dirname as dirname8 } from "path";
+import { join as join18, basename as basename3, dirname as dirname9 } from "path";
 import { homedir as homedir9 } from "os";
-import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
 
 class SkillLoader {
   skills = new Map;
@@ -122707,9 +123014,9 @@ class SkillLoader {
     const includeContent = options.includeContent ?? true;
     const envHome = process.env.HOME || process.env.USERPROFILE;
     const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir9();
-    const userSkillsDir = join17(userHome, ".assistants", "shared", "skills");
+    const userSkillsDir = join18(userHome, ".assistants", "shared", "skills");
     await this.loadFromDirectory(userSkillsDir, { includeContent });
-    const projectSkillsDir = join17(projectDir, ".assistants", "skills");
+    const projectSkillsDir = join18(projectDir, ".assistants", "skills");
     await this.loadFromDirectory(projectSkillsDir, { includeContent });
     const nestedFiles = await import_fast_glob.default("**/.assistants/skills/*/SKILL.md", {
       cwd: projectDir,
@@ -122717,7 +123024,7 @@ class SkillLoader {
       ignore: ["**/node_modules/**"]
     });
     for (const file of nestedFiles) {
-      await this.loadSkillFile(join17(projectDir, file), { includeContent });
+      await this.loadSkillFile(join18(projectDir, file), { includeContent });
     }
   }
   async loadFromDirectory(dir, options = {}) {
@@ -122733,13 +123040,13 @@ class SkillLoader {
       const filesToLoad = [];
       const skillPrefixFiles = await import_fast_glob.default("skill-*/SKILL.md", { cwd: dir });
       for (const file of skillPrefixFiles) {
-        filesToLoad.push(join17(dir, file));
+        filesToLoad.push(join18(dir, file));
       }
       const regularFiles = await import_fast_glob.default("*/SKILL.md", { cwd: dir });
       for (const file of regularFiles) {
         const dirName = file.split(/[\\/]/)[0];
         if (!dirName.startsWith("skill-")) {
-          filesToLoad.push(join17(dir, file));
+          filesToLoad.push(join18(dir, file));
         }
       }
       const loadTasks = [];
@@ -122751,10 +123058,10 @@ class SkillLoader {
   }
   async loadSkillFile(filePath, options = {}) {
     try {
-      const content = await readFile5(filePath, "utf-8");
+      const content = await readFile6(filePath, "utf-8");
       const { frontmatter, content: markdownContent } = parseFrontmatter(content);
       const includeContent = options.includeContent ?? true;
-      const dirName = basename3(dirname8(filePath));
+      const dirName = basename3(dirname9(filePath));
       const name = frontmatter.name || dirName;
       let description = frontmatter.description || "";
       if (!description && markdownContent) {
@@ -122852,8 +123159,8 @@ class SkillLoader {
 }
 // ../core/src/commands/loader.ts
 await init_runtime();
-import { existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join18, basename as basename4, extname as extname2 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join19, basename as basename4, extname as extname2 } from "path";
 import { homedir as homedir10 } from "os";
 
 class CommandLoader {
@@ -122866,17 +123173,17 @@ class CommandLoader {
     this.commands.clear();
     const envHome = process.env.HOME || process.env.USERPROFILE;
     const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir10();
-    const globalDir = join18(homeDir, ".assistants", "commands");
+    const globalDir = join19(homeDir, ".assistants", "commands");
     await this.loadFromDirectory(globalDir, "global");
-    const projectDir = join18(this.cwd, ".assistants", "commands");
+    const projectDir = join19(this.cwd, ".assistants", "commands");
     await this.loadFromDirectory(projectDir, "project");
   }
   async loadFromDirectory(dir, source, prefix = "") {
-    if (!existsSync12(dir))
+    if (!existsSync13(dir))
       return;
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join18(dir, entry);
+      const fullPath = join19(dir, entry);
       const stat3 = statSync2(fullPath);
       if (stat3.isDirectory()) {
         const newPrefix = prefix ? `${prefix}:${entry}` : entry;
@@ -123150,11 +123457,11 @@ ${truncatedStderr}`;
 }
 // ../core/src/commands/builtin.ts
 await init_runtime();
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 import { homedir as homedir14, platform as platform2, release, arch as arch2 } from "os";
-init_src2();
 await init_config();
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
+init_src2();
 
 // ../core/src/scheduler/format.ts
 function formatRelativeTime(timestamp, now2 = Date.now()) {
@@ -123184,11 +123491,11 @@ init_src2();
 
 // ../core/src/jobs/job-store.ts
 await init_config();
-import { join as join19 } from "path";
-import { mkdir as mkdir8, readdir as readdir3, readFile as readFile6, unlink as unlink4, writeFile as writeFile5 } from "fs/promises";
+import { join as join20 } from "path";
+import { mkdir as mkdir8, readdir as readdir3, readFile as readFile7, unlink as unlink4, writeFile as writeFile5 } from "fs/promises";
 var SAFE_ID_PATTERN5 = /^[a-zA-Z0-9_-]+$/;
 function jobsDir() {
-  return join19(getConfigDir(), "jobs");
+  return join20(getConfigDir(), "jobs");
 }
 function isSafeId4(id) {
   return SAFE_ID_PATTERN5.test(id);
@@ -123196,7 +123503,7 @@ function isSafeId4(id) {
 function jobPath(id) {
   if (!isSafeId4(id))
     return null;
-  return join19(jobsDir(), `${id}.json`);
+  return join20(jobsDir(), `${id}.json`);
 }
 async function ensureDir() {
   await mkdir8(jobsDir(), { recursive: true });
@@ -123214,7 +123521,7 @@ async function readJob(id) {
     const path = jobPath(id);
     if (!path)
       return null;
-    const raw = await readFile6(path, "utf-8");
+    const raw = await readFile7(path, "utf-8");
     const job = JSON.parse(raw);
     if (!job?.id)
       return null;
@@ -123243,7 +123550,7 @@ async function listJobs() {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const raw = await readFile6(join19(dir, file), "utf-8");
+        const raw = await readFile7(join20(dir, file), "utf-8");
         const job = JSON.parse(raw);
         if (job?.id)
           jobs.push(job);
@@ -123830,15 +124137,15 @@ var PRIORITY_ORDER = {
 };
 // ../core/src/tasks/store.ts
 init_src2();
-import { join as join20 } from "path";
-import { mkdir as mkdir9, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join21 } from "path";
+import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
 var TASKS_DIR = ".assistants/tasks";
 var TASKS_FILE = "tasks.json";
 function tasksDir(cwd) {
-  return join20(cwd, TASKS_DIR);
+  return join21(cwd, TASKS_DIR);
 }
 function tasksPath(cwd) {
-  return join20(tasksDir(cwd), TASKS_FILE);
+  return join21(tasksDir(cwd), TASKS_FILE);
 }
 async function ensureTasksDir(cwd) {
   await mkdir9(tasksDir(cwd), { recursive: true });
@@ -123852,7 +124159,7 @@ function defaultStoreData() {
 }
 async function loadTaskStore(cwd) {
   try {
-    const raw = await readFile7(tasksPath(cwd), "utf-8");
+    const raw = await readFile8(tasksPath(cwd), "utf-8");
     const data = JSON.parse(raw);
     if (!Array.isArray(data.tasks)) {
       return defaultStoreData();
@@ -124139,6 +124446,7 @@ class BuiltinCommands {
     loader.register(this.clearCommand());
     loader.register(this.newCommand());
     loader.register(this.sessionCommand());
+    loader.register(this.resumeCommand());
     loader.register(this.statusCommand());
     loader.register(this.tokensCommand());
     loader.register(this.contextCommand());
@@ -124166,6 +124474,7 @@ class BuiltinCommands {
     loader.register(this.hooksCommand());
     loader.register(this.feedbackCommand());
     loader.register(this.schedulesCommand());
+    loader.register(this.heartbeatCommand());
     loader.register(this.connectorsCommand());
     loader.register(this.securityLogCommand());
     loader.register(this.guardrailsCommand());
@@ -124174,6 +124483,7 @@ class BuiltinCommands {
     loader.register(this.secretsCommand());
     loader.register(this.jobsCommand());
     loader.register(this.messagesCommand());
+    loader.register(this.webhooksCommand());
     loader.register(this.tasksCommand());
     loader.register(this.exitCommand());
   }
@@ -124908,6 +125218,10 @@ Usage: /identity create --template <name>
             context.emit("done");
             return { handled: true };
           }
+          if (action === "edit") {
+            context.emit("done");
+            return { handled: true, showPanel: "identity", panelInitialValue: `edit:${match.id}` };
+          }
           context.emit("text", `
 ## Identity Details
 
@@ -124987,6 +125301,8 @@ To update fields, use the web UI or edit the identity file directly.
           context.emit("text", `/identity switch <name|id>       Switch to identity
 `);
           context.emit("text", `/identity show <name|id>         Show identity details
+`);
+          context.emit("text", `/identity edit <name|id>         Edit identity in panel
 `);
           context.emit("text", `/identity set-default <name|id>  Set as default
 `);
@@ -126978,6 +127294,197 @@ To enable:
         context.emit("text", `Unknown messages command: ${subcommand}
 `);
         context.emit("text", `Use /messages help for available commands.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  webhooksCommand() {
+    return {
+      name: "webhooks",
+      description: "Manage webhooks for receiving push events from external sources",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const trimmed = args.trim();
+        const [subcommand, ...rest] = trimmed.split(/\s+/);
+        const subArgs = rest.join(" ");
+        if (!subcommand || subcommand === "ui") {
+          context.emit("done");
+          return { handled: true, showPanel: "webhooks" };
+        }
+        const manager = context.getWebhooksManager?.();
+        if (!manager) {
+          context.emit("text", `Webhooks are not enabled. Set webhooks.enabled: true in config.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "list") {
+          try {
+            const webhooks = await manager.list();
+            if (webhooks.length === 0) {
+              context.emit("text", `No webhooks registered. Use /webhooks create <name> <source> to create one.
+`);
+            } else {
+              context.emit("text", `Webhooks (${webhooks.length}):
+
+`);
+              for (const wh of webhooks) {
+                const statusIcon = wh.status === "active" ? "\u25CF" : wh.status === "paused" ? "\u25D0" : "\u2717";
+                const lastDelivery = wh.lastDeliveryAt ? new Date(wh.lastDeliveryAt).toLocaleDateString() : "never";
+                context.emit("text", `  ${statusIcon} ${wh.name} (${wh.id})
+`);
+                context.emit("text", `    Source: ${wh.source} | Events: ${wh.deliveryCount} | Last: ${lastDelivery}
+`);
+              }
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "create") {
+          const parts = subArgs.split(/\s+/);
+          const name = parts[0];
+          const source = parts[1] || "custom";
+          if (!name) {
+            context.emit("text", `Usage: /webhooks create <name> [source]
+`);
+            context.emit("text", `Example: /webhooks create gmail-hook gmail
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const result = await manager.create({ name, source });
+            if (result.success) {
+              context.emit("text", `Webhook created!
+
+`);
+              context.emit("text", `  ID:     ${result.webhookId}
+`);
+              context.emit("text", `  URL:    ${result.url}
+`);
+              context.emit("text", `  Secret: ${result.secret}
+`);
+              context.emit("text", `
+Configure the external source with the URL and secret above.
+`);
+            } else {
+              context.emit("text", `Error: ${result.message}
+`);
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "delete") {
+          const id = subArgs.trim();
+          if (!id) {
+            context.emit("text", `Usage: /webhooks delete <webhook-id>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const result = await manager.delete(id);
+            context.emit("text", `${result.message}
+`);
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "events") {
+          const webhookId = subArgs.trim();
+          if (!webhookId) {
+            context.emit("text", `Usage: /webhooks events <webhook-id>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const events = await manager.listEvents(webhookId, { limit: 20 });
+            if (events.length === 0) {
+              context.emit("text", `No events received for this webhook.
+`);
+            } else {
+              context.emit("text", `Recent events (${events.length}):
+
+`);
+              for (const evt of events) {
+                const statusIcon = evt.status === "pending" ? "\u23F3" : evt.status === "injected" ? "\uD83D\uDCE8" : "\u2713";
+                context.emit("text", `  ${statusIcon} ${evt.eventType} (${evt.id})
+`);
+                context.emit("text", `    ${new Date(evt.timestamp).toLocaleString()} | ${evt.preview}
+`);
+              }
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "test") {
+          const id = subArgs.trim();
+          if (!id) {
+            context.emit("text", `Usage: /webhooks test <webhook-id>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const result = await manager.sendTestEvent(id);
+            if (result.success) {
+              context.emit("text", `Test event sent! Event ID: ${result.eventId}
+`);
+            } else {
+              context.emit("text", `Error: ${result.message}
+`);
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "help") {
+          context.emit("text", `Webhook Commands:
+
+`);
+          context.emit("text", `/webhooks                Open webhooks panel
+`);
+          context.emit("text", `/webhooks list           List all webhooks
+`);
+          context.emit("text", `/webhooks create <name> <source>  Create a webhook
+`);
+          context.emit("text", `/webhooks delete <id>    Delete a webhook
+`);
+          context.emit("text", `/webhooks events <id>    List events for a webhook
+`);
+          context.emit("text", `/webhooks test <id>      Send a test event
+`);
+          context.emit("text", `/webhooks help           Show this help
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `Unknown command: ${subcommand}
+`);
+        context.emit("text", `Use /webhooks help for available commands.
 `);
         context.emit("done");
         return { handled: true };
@@ -127576,6 +128083,91 @@ Usage: /session assign <agent-name>
       }
     };
   }
+  resumeCommand() {
+    return {
+      name: "resume",
+      description: "Resume saved sessions from disk",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const trimmed = args.trim().toLowerCase();
+        const showAll = trimmed.includes("--all");
+        const cleanedArgs = trimmed.replace("--all", "").trim();
+        if (!cleanedArgs || cleanedArgs === "ui") {
+          context.emit("done");
+          return {
+            handled: true,
+            showPanel: "resume",
+            panelInitialValue: showAll ? "all" : "cwd"
+          };
+        }
+        if (cleanedArgs === "list" || cleanedArgs === "--list") {
+          const allSessions = SessionStorage.listAllSessions();
+          const normalizeCwd = (value) => value.replace(/\/+$/, "");
+          const targetCwd = normalizeCwd(context.cwd);
+          const sessions = showAll ? allSessions : allSessions.filter((session) => normalizeCwd(session.cwd) === targetCwd);
+          if (sessions.length === 0) {
+            context.emit("text", showAll ? `No saved sessions found.
+` : `No saved sessions found for this directory.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const assistantManager = context.getAssistantManager?.();
+          const assistantNames = assistantManager ? new Map(assistantManager.listAssistants().map((a) => [a.id, a.name])) : null;
+          const truncate = (value, maxLen) => value.length > maxLen ? `${value.slice(0, maxLen - 3)}...` : value;
+          const escapeCell = (value) => value.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
+          let output = `
+`;
+          if (showAll) {
+            output += `| ID | Assistant | Updated | Messages | CWD |
+`;
+            output += `|----|-----------|---------|----------|-----|
+`;
+          } else {
+            output += `| ID | Updated | Messages | CWD |
+`;
+            output += `|----|---------|----------|-----|
+`;
+          }
+          for (const session of sessions) {
+            const updated = formatRelativeTime(new Date(session.updatedAt).getTime());
+            const messageCount = session.messageCount ?? 0;
+            const cwd = escapeCell(truncate(singleLine2(session.cwd || ""), 48));
+            const id = escapeCell(session.id.slice(0, 8));
+            if (showAll) {
+              const assistantLabel = session.assistantId ? assistantNames?.get(session.assistantId) || session.assistantId : "default";
+              output += `| ${id} | ${escapeCell(truncate(assistantLabel, 16))} | ${updated} | ${messageCount} | ${cwd} |
+`;
+            } else {
+              output += `| ${id} | ${updated} | ${messageCount} | ${cwd} |
+`;
+            }
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `
+**Resume** - Load saved sessions from disk
+
+`);
+        context.emit("text", `Usage:
+`);
+        context.emit("text", `  /resume             Open interactive panel (current folder)
+`);
+        context.emit("text", `  /resume --all       Open interactive panel (all sessions)
+`);
+        context.emit("text", `  /resume list        Show text table (current folder)
+`);
+        context.emit("text", `  /resume list --all  Show text table (all sessions)
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
   tokensCommand() {
     return {
       name: "tokens",
@@ -128869,9 +129461,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         }
         if (action === "show" || action === "paths") {
           const configPaths = [
-            join25(context.cwd, ".assistants", "config.json"),
-            join25(context.cwd, ".assistants", "config.local.json"),
-            join25(getConfigDir(), "config.json")
+            join26(context.cwd, ".assistants", "config.json"),
+            join26(context.cwd, ".assistants", "config.local.json"),
+            join26(getConfigDir(), "config.json")
           ];
           let message = `
 **Configuration**
@@ -128880,7 +129472,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
           message += `**Config File Locations:**
 `;
           for (const path of configPaths) {
-            const exists = existsSync17(path);
+            const exists = existsSync18(path);
             message += `  ${exists ? "\u2713" : "\u25CB"} ${path}
 `;
           }
@@ -128889,9 +129481,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
           message += `
 **Commands Directories:**
 `;
-          message += `  - Project: ${join25(context.cwd, ".assistants", "commands")}
+          message += `  - Project: ${join26(context.cwd, ".assistants", "commands")}
 `;
-          message += `  - Global: ${join25(homeDir, ".assistants", "commands")}
+          message += `  - Global: ${join26(homeDir, ".assistants", "commands")}
 `;
           context.emit("text", message);
           context.emit("done");
@@ -129724,8 +130316,8 @@ ${error instanceof Error ? error.message : String(error)}
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const commandsDir = join25(context.cwd, ".assistants", "commands");
-        mkdirSync11(commandsDir, { recursive: true });
+        const commandsDir = join26(context.cwd, ".assistants", "commands");
+        mkdirSync12(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: reflect
 description: Reflect on the conversation and suggest next steps
@@ -129740,8 +130332,8 @@ Please summarize the last interaction and suggest 2-3 next steps.
 - Focus on clarity
 - Ask a follow-up question if needed
 `;
-        const examplePath = join25(commandsDir, "reflect.md");
-        if (!existsSync17(examplePath)) {
+        const examplePath = join26(commandsDir, "reflect.md");
+        if (!existsSync18(examplePath)) {
           writeFileSync12(examplePath, exampleCommand);
         }
         let message = `
@@ -130412,7 +131004,7 @@ Memory Statistics
           return { handled: true };
         }
         if (action === "export") {
-          const filePath = rest[0] || join25(getConfigDir(), "memories-export.json");
+          const filePath = rest[0] || join26(getConfigDir(), "memories-export.json");
           const memories = await manager.export();
           try {
             const content = JSON.stringify(memories, null, 2);
@@ -130609,6 +131201,136 @@ Importing ${validMemories.length} valid entries (skipping ${errors.length} inval
         context.emit("text", `  /schedules list        Show text table (this session)
 `);
         context.emit("text", `  /schedules list --all  Show all schedules
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  heartbeatCommand() {
+    return {
+      name: "heartbeat",
+      description: "View heartbeat status and recent heartbeat runs",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const trimmed = args.trim().toLowerCase();
+        const showAll = trimmed.includes("--all");
+        const cleanedArgs = trimmed.replace("--all", "").trim();
+        const heartbeatState = context.getHeartbeatState?.() ?? null;
+        const heartbeatConfig = context.getHeartbeatConfig?.() ?? null;
+        const historyPathTemplate = heartbeatConfig?.historyPath;
+        if (!cleanedArgs || cleanedArgs === "ui") {
+          context.emit("done");
+          return { handled: true, showPanel: "heartbeat" };
+        }
+        if (cleanedArgs === "list" || cleanedArgs === "--list") {
+          const canEnumerate = !historyPathTemplate || historyPathTemplate.includes("{sessionId}");
+          const sessionIds = showAll && canEnumerate ? listHeartbeatHistorySessions() : [context.sessionId];
+          const rows = [];
+          for (const sessionId of sessionIds) {
+            const historyPath = resolveHeartbeatHistoryPath(sessionId, historyPathTemplate);
+            const runs = await readHeartbeatHistory(historyPath, { order: "desc" });
+            for (const run of runs) {
+              rows.push({ sessionId, run });
+            }
+          }
+          if (rows.length === 0) {
+            context.emit("text", showAll ? `No heartbeat runs found.
+` : `No heartbeat runs found for this session.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          rows.sort((a, b) => {
+            const aTime = new Date(a.run.timestamp).getTime();
+            const bTime = new Date(b.run.timestamp).getTime();
+            return bTime - aTime;
+          });
+          const rel = (iso) => formatRelativeTime(iso ? new Date(iso).getTime() : undefined);
+          if (heartbeatState) {
+            const stateLine = `State: ${heartbeatState.state} | Stale: ${heartbeatState.isStale ? "yes" : "no"} | Last Activity: ${rel(heartbeatState.lastActivity)}`;
+            context.emit("text", `
+**Heartbeat Status**
+${stateLine}
+
+`);
+          }
+          const escapeCell = (value) => value.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
+          let output = `
+`;
+          if (showAll) {
+            output += `| Session | Time | State | Last Activity | Msgs | Tools | Errors |
+`;
+            output += `|--------|------|-------|---------------|------|-------|--------|
+`;
+          } else {
+            output += `| Time | State | Last Activity | Msgs | Tools | Errors |
+`;
+            output += `|------|-------|---------------|------|-------|--------|
+`;
+          }
+          for (const { sessionId, run } of rows) {
+            const time = rel(run.timestamp);
+            const activity = rel(run.lastActivity);
+            const stats = run.stats || { messagesProcessed: 0, toolCallsExecuted: 0, errorsEncountered: 0 };
+            if (showAll) {
+              output += `| ${escapeCell(sessionId.slice(0, 8))} | ${time} | ${run.state} | ${activity} | ${stats.messagesProcessed} | ${stats.toolCallsExecuted} | ${stats.errorsEncountered} |
+`;
+            } else {
+              output += `| ${time} | ${run.state} | ${activity} | ${stats.messagesProcessed} | ${stats.toolCallsExecuted} | ${stats.errorsEncountered} |
+`;
+            }
+          }
+          context.emit("text", output);
+          if (showAll && historyPathTemplate && !historyPathTemplate.includes("{sessionId}")) {
+            context.emit("text", `
+Note: custom heartbeat historyPath does not include {sessionId}; showing current session only.
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (cleanedArgs === "status") {
+          if (!heartbeatState) {
+            context.emit("text", `Heartbeat status unavailable.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const rel = (iso) => formatRelativeTime(iso ? new Date(iso).getTime() : undefined);
+          context.emit("text", `
+**Heartbeat Status**
+`);
+          context.emit("text", `State: ${heartbeatState.state}
+`);
+          context.emit("text", `Enabled: ${heartbeatState.enabled ? "yes" : "no"}
+`);
+          context.emit("text", `Stale: ${heartbeatState.isStale ? "yes" : "no"}
+`);
+          context.emit("text", `Last Activity: ${rel(heartbeatState.lastActivity)}
+`);
+          context.emit("text", `Uptime: ${heartbeatState.uptimeSeconds}s
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `
+**Heartbeat** - View heartbeat status and run history
+
+`);
+        context.emit("text", `Usage:
+`);
+        context.emit("text", `  /heartbeat             Open interactive panel
+`);
+        context.emit("text", `  /heartbeat ui          Open interactive panel
+`);
+        context.emit("text", `  /heartbeat list        Show text table (this session)
+`);
+        context.emit("text", `  /heartbeat list --all  Show text table for all sessions
+`);
+        context.emit("text", `  /heartbeat status      Show current heartbeat status
 `);
         context.emit("done");
         return { handled: true };
@@ -131094,10 +131816,9 @@ async function createLLMClient(config) {
 await init_config();
 
 // ../core/src/heartbeat/manager.ts
-import { dirname as dirname12 } from "path";
-import { mkdirSync as mkdirSync12 } from "fs";
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-
+import { dirname as dirname13 } from "path";
+import { mkdirSync as mkdirSync13 } from "fs";
+import { readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
 class HeartbeatManager {
   config;
   state = "idle";
@@ -131106,6 +131827,7 @@ class HeartbeatManager {
   stats;
   intervalId;
   listeners = new Set;
+  lastHeartbeatAt = null;
   constructor(config) {
     this.config = config;
     this.startTime = Date.now();
@@ -131116,8 +131838,8 @@ class HeartbeatManager {
       errorsEncountered: 0,
       uptimeSeconds: 0
     };
-    const dir = dirname12(config.persistPath);
-    mkdirSync12(dir, { recursive: true });
+    const dir = dirname13(config.persistPath);
+    mkdirSync13(dir, { recursive: true });
   }
   start(sessionId) {
     if (this.intervalId)
@@ -131159,6 +131881,10 @@ class HeartbeatManager {
   getStartTime() {
     return this.startTime;
   }
+  getNextHeartbeatAt() {
+    const base = this.lastHeartbeatAt ?? Date.now();
+    return base + this.config.intervalMs;
+  }
   getStats() {
     return {
       ...this.stats,
@@ -131173,14 +131899,17 @@ class HeartbeatManager {
     this.lastActivity = Date.now();
   }
   async emit(sessionId) {
+    const now2 = Date.now();
+    this.lastHeartbeatAt = now2;
+    const uptimeSeconds = Math.floor((now2 - this.startTime) / 1000);
     const heartbeat = {
       sessionId,
-      timestamp: new Date().toISOString(),
+      timestamp: new Date(now2).toISOString(),
       state: this.state,
       lastActivity: new Date(this.lastActivity).toISOString(),
       stats: {
         ...this.stats,
-        uptimeSeconds: Math.floor((Date.now() - this.startTime) / 1000)
+        uptimeSeconds
       }
     };
     for (const listener of this.listeners) {
@@ -131191,11 +131920,14 @@ class HeartbeatManager {
   async persist(heartbeat) {
     try {
       await writeFile7(this.config.persistPath, JSON.stringify(heartbeat, null, 2));
+      if (this.config.historyPath) {
+        await appendHeartbeatHistory(this.config.historyPath, heartbeat);
+      }
     } catch {}
   }
   static async checkStale(path2, thresholdMs) {
     try {
-      const content = await readFile8(path2, "utf-8");
+      const content = await readFile9(path2, "utf-8");
       const heartbeat = JSON.parse(content);
       const age = Date.now() - new Date(heartbeat.timestamp).getTime();
       return { isStale: age > thresholdMs, lastHeartbeat: heartbeat };
@@ -131205,15 +131937,15 @@ class HeartbeatManager {
   }
 }
 // ../core/src/heartbeat/persistence.ts
-import { dirname as dirname13 } from "path";
-import { mkdirSync as mkdirSync13 } from "fs";
-import { readFile as readFile9, writeFile as writeFile8, unlink as unlink5 } from "fs/promises";
+import { dirname as dirname14 } from "path";
+import { mkdirSync as mkdirSync14 } from "fs";
+import { readFile as readFile10, writeFile as writeFile8, unlink as unlink5 } from "fs/promises";
 
 class StatePersistence {
   path;
   constructor(path2) {
     this.path = path2;
-    mkdirSync13(dirname13(path2), { recursive: true });
+    mkdirSync14(dirname14(path2), { recursive: true });
   }
   async save(state) {
     try {
@@ -131222,7 +131954,7 @@ class StatePersistence {
   }
   async load() {
     try {
-      const content = await readFile9(this.path, "utf-8");
+      const content = await readFile10(this.path, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -131354,7 +132086,7 @@ async function ensureWatchdogSchedule(cwd, sessionId, intervalMs = DEFAULT_WATCH
 }
 // ../core/src/heartbeat/install-skills.ts
 await init_config();
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var MAIN_LOOP_SKILL = `---
 name: main-loop
 description: Autonomous heartbeat \u2014 review goals, check async results, act on pending items, and schedule next wakeup.
@@ -131418,8 +132150,8 @@ You are the watchdog. Your only job is to verify the heartbeat is running and fo
 `;
 async function writeSkillIfMissing(dir, skillName, content) {
   const { mkdir: mkdir10, writeFile: writeFile9, access } = await import("fs/promises");
-  const skillDir = join28(dir, `skill-${skillName}`);
-  const skillFile = join28(skillDir, "SKILL.md");
+  const skillDir = join29(dir, `skill-${skillName}`);
+  const skillFile = join29(skillDir, "SKILL.md");
   try {
     await access(skillFile);
     return false;
@@ -131429,7 +132161,7 @@ async function writeSkillIfMissing(dir, skillName, content) {
   return true;
 }
 async function installHeartbeatSkills() {
-  const sharedSkillsDir = join28(getConfigDir(), "shared", "skills");
+  const sharedSkillsDir = join29(getConfigDir(), "shared", "skills");
   const installed = [];
   const results = await Promise.all([
     writeSkillIfMissing(sharedSkillsDir, "main-loop", MAIN_LOOP_SKILL),
@@ -131603,15 +132335,15 @@ class EnergyManager {
   }
 }
 // ../core/src/energy/storage.ts
-import { dirname as dirname14 } from "path";
-import { mkdirSync as mkdirSync14 } from "fs";
-import { readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname15 } from "path";
+import { mkdirSync as mkdirSync15 } from "fs";
+import { readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
 
 class EnergyStorage {
   path;
   constructor(path2) {
     this.path = path2;
-    mkdirSync14(dirname14(path2), { recursive: true });
+    mkdirSync15(dirname15(path2), { recursive: true });
   }
   async save(state) {
     try {
@@ -131620,7 +132352,7 @@ class EnergyStorage {
   }
   async load() {
     try {
-      const content = await readFile10(this.path, "utf-8");
+      const content = await readFile11(this.path, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -131678,15 +132410,15 @@ function validateToolCalls(toolCalls, tools) {
 }
 
 // ../core/src/voice/utils.ts
-import { existsSync as existsSync20, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir17 } from "os";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { spawnSync } from "child_process";
 function loadApiKeyFromSecrets3(key) {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir17();
-  const secretsPath = join29(homeDir, ".secrets");
-  if (!existsSync20(secretsPath))
+  const secretsPath = join30(homeDir, ".secrets");
+  if (!existsSync21(secretsPath))
     return;
   try {
     const content = readFileSync13(secretsPath, "utf-8");
@@ -131798,7 +132530,7 @@ class SystemSTT {
 // ../core/src/voice/tts.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { readFileSync as readFileSync14, unlinkSync as unlinkSync4 } from "fs";
 class ElevenLabsTTS {
   apiKey;
@@ -131902,7 +132634,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join30(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
+      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -131924,7 +132656,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join30(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
+      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -131951,14 +132683,14 @@ class SystemTTS {
 // ../core/src/voice/player.ts
 import { spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { unlink as unlink6, writeFileSync as writeFileSync13 } from "fs";
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join31(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
+    const tempFile = join32(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
     writeFileSync13(tempFile, Buffer.from(audio));
     const player = this.resolvePlayer(format);
     if (!player) {
@@ -132026,7 +132758,7 @@ class AudioPlayer {
 // ../core/src/voice/recorder.ts
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { readFileSync as readFileSync15, unlink as unlink7 } from "fs";
 class AudioRecorder {
   currentProcess = null;
@@ -132039,7 +132771,7 @@ class AudioRecorder {
     const duration = options.durationSeconds ?? 5;
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
-    const output = join32(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join33(tmpdir4(), `assistants-record-${Date.now()}.wav`);
     this.currentOutputPath = output;
     this.stoppedIntentionally = false;
     const recorder = this.resolveRecorder(sampleRate, channels, duration, output);
@@ -132240,15 +132972,15 @@ class VoiceManager {
 }
 // ../core/src/identity/assistant-manager.ts
 init_src2();
-import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile11, rm as rm3 } from "fs/promises";
-import { join as join34 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir11, readFile as readFile13, writeFile as writeFile11, rm as rm3 } from "fs/promises";
+import { join as join35 } from "path";
 
 // ../core/src/identity/identity-manager.ts
 init_src2();
-import { existsSync as existsSync21 } from "fs";
-import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile10, rm as rm2 } from "fs/promises";
-import { join as join33 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile10, rm as rm2 } from "fs/promises";
+import { join as join34 } from "path";
 var SAFE_ID_PATTERN6 = /^[a-zA-Z0-9_-]+$/;
 function isValidId2(id) {
   return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN6.test(id);
@@ -132289,20 +133021,20 @@ class IdentityManager {
     this.basePath = basePath;
   }
   get identitiesRoot() {
-    return join33(this.basePath, "assistants", this.assistantId, "identities");
+    return join34(this.basePath, "assistants", this.assistantId, "identities");
   }
   get indexPath() {
-    return join33(this.identitiesRoot, "index.json");
+    return join34(this.identitiesRoot, "index.json");
   }
   get activePath() {
-    return join33(this.identitiesRoot, "active.json");
+    return join34(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
     validateId(id, "identityId");
-    return join33(this.identitiesRoot, `${id}.json`);
+    return join34(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
-    return join33(this.basePath, "assistants", this.assistantId, "config.json");
+    return join34(this.basePath, "assistants", this.assistantId, "config.json");
   }
   async initialize() {
     await mkdir10(this.identitiesRoot, { recursive: true });
@@ -132428,11 +133160,11 @@ class IdentityManager {
 `);
   }
   async readIndex() {
-    if (!existsSync21(this.indexPath)) {
+    if (!existsSync22(this.indexPath)) {
       return { identities: [] };
     }
     try {
-      const raw = await readFile11(this.indexPath, "utf-8");
+      const raw = await readFile12(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
       const identities = Array.isArray(data.identities) ? data.identities : [];
       return { identities: identities.filter(isValidId2) };
@@ -132454,10 +133186,10 @@ class IdentityManager {
   }
   async readIdentity(id) {
     const path2 = this.identityPath(id);
-    if (!existsSync21(path2))
+    if (!existsSync22(path2))
       return null;
     try {
-      const raw = await readFile11(path2, "utf-8");
+      const raw = await readFile12(path2, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -132468,10 +133200,10 @@ class IdentityManager {
     await writeFile10(this.identityPath(identity.id), JSON.stringify(identity, null, 2));
   }
   async readActive() {
-    if (!existsSync21(this.activePath))
+    if (!existsSync22(this.activePath))
       return null;
     try {
-      const raw = await readFile11(this.activePath, "utf-8");
+      const raw = await readFile12(this.activePath, "utf-8");
       const data = JSON.parse(raw);
       const id = data.id || null;
       if (id && !isValidId2(id)) {
@@ -132487,10 +133219,10 @@ class IdentityManager {
     await writeFile10(this.activePath, JSON.stringify({ id }, null, 2));
   }
   async loadAssistant() {
-    if (!existsSync21(this.assistantConfigPath()))
+    if (!existsSync22(this.assistantConfigPath()))
       return null;
     try {
-      const raw = await readFile11(this.assistantConfigPath(), "utf-8");
+      const raw = await readFile12(this.assistantConfigPath(), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -132520,17 +133252,17 @@ class AssistantManager {
     this.basePath = basePath;
   }
   get assistantsRoot() {
-    return join34(this.basePath, "assistants");
+    return join35(this.basePath, "assistants");
   }
   get indexPath() {
-    return join34(this.assistantsRoot, "index.json");
+    return join35(this.assistantsRoot, "index.json");
   }
   get activePath() {
-    return join34(this.basePath, "active.json");
+    return join35(this.basePath, "active.json");
   }
   assistantConfigPath(id) {
     validateId2(id, "assistantId");
-    return join34(this.assistantsRoot, id, "config.json");
+    return join35(this.assistantsRoot, id, "config.json");
   }
   async initialize() {
     await mkdir11(this.assistantsRoot, { recursive: true });
@@ -132585,7 +133317,7 @@ class AssistantManager {
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
-    await rm3(join34(this.assistantsRoot, id), { recursive: true, force: true });
+    await rm3(join35(this.assistantsRoot, id), { recursive: true, force: true });
     this.assistants.delete(id);
     await this.removeFromIndex(id);
     if (this.activeId === id) {
@@ -132616,11 +133348,11 @@ class AssistantManager {
     return new IdentityManager(assistantId, this.basePath);
   }
   async readIndex() {
-    if (!existsSync22(this.indexPath)) {
+    if (!existsSync23(this.indexPath)) {
       return { assistants: [] };
     }
     try {
-      const raw = await readFile12(this.indexPath, "utf-8");
+      const raw = await readFile13(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
       const assistants = Array.isArray(data.assistants) ? data.assistants : [];
       return { assistants: assistants.filter(isValidId3) };
@@ -132642,10 +133374,10 @@ class AssistantManager {
   }
   async readAssistant(id) {
     const configPath = this.assistantConfigPath(id);
-    if (!existsSync22(configPath))
+    if (!existsSync23(configPath))
       return null;
     try {
-      const raw = await readFile12(configPath, "utf-8");
+      const raw = await readFile13(configPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -132653,15 +133385,15 @@ class AssistantManager {
   }
   async persistAssistant(assistant) {
     validateId2(assistant.id, "assistantId");
-    const dir = join34(this.assistantsRoot, assistant.id);
+    const dir = join35(this.assistantsRoot, assistant.id);
     await mkdir11(dir, { recursive: true });
     await writeFile11(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
   }
   async readActive() {
-    if (!existsSync22(this.activePath))
+    if (!existsSync23(this.activePath))
       return null;
     try {
-      const raw = await readFile12(this.activePath, "utf-8");
+      const raw = await readFile13(this.activePath, "utf-8");
       const data = JSON.parse(raw);
       const id = data.id || null;
       if (id && !isValidId3(id)) {
@@ -132678,7 +133410,7 @@ class AssistantManager {
   }
 }
 // ../core/src/inbox/inbox-manager.ts
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // ../../node_modules/.bun/@aws-sdk+middleware-expect-continue@3.972.3/node_modules/@aws-sdk/middleware-expect-continue/dist-es/index.js
 var import_protocol_http = __toESM(require_dist_cjs2(), 1);
@@ -141536,8 +142268,8 @@ class S3InboxClient {
 }
 
 // ../core/src/inbox/storage/local-cache.ts
-import { join as join36, basename as basename5 } from "path";
-import { mkdir as mkdir12, readFile as readFile14, writeFile as writeFile13, rm as rm4, readdir as readdir4, stat as stat3 } from "fs/promises";
+import { join as join37, basename as basename5 } from "path";
+import { mkdir as mkdir12, readFile as readFile15, writeFile as writeFile13, rm as rm4, readdir as readdir4, stat as stat3 } from "fs/promises";
 import { createHash as createHash5 } from "crypto";
 var STRICT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var SAFE_FILENAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -141574,18 +142306,18 @@ class LocalInboxCache {
     validateAssistantId(options.assistantId);
     this.assistantId = options.assistantId;
     this.basePath = options.basePath;
-    this.cacheDir = join36(this.basePath, this.assistantId);
+    this.cacheDir = join37(this.basePath, this.assistantId);
   }
   async ensureDirectories() {
-    await mkdir12(join36(this.cacheDir, "emails"), { recursive: true });
-    await mkdir12(join36(this.cacheDir, "attachments"), { recursive: true });
+    await mkdir12(join37(this.cacheDir, "emails"), { recursive: true });
+    await mkdir12(join37(this.cacheDir, "attachments"), { recursive: true });
   }
   async loadIndex() {
     if (this.index)
       return this.index;
     try {
-      const indexPath = join36(this.cacheDir, "index.json");
-      const content = await readFile14(indexPath, "utf-8");
+      const indexPath = join37(this.cacheDir, "index.json");
+      const content = await readFile15(indexPath, "utf-8");
       this.index = JSON.parse(content);
       return this.index;
     } catch {
@@ -141597,7 +142329,7 @@ class LocalInboxCache {
     if (!this.index)
       return;
     await this.ensureDirectories();
-    const indexPath = join36(this.cacheDir, "index.json");
+    const indexPath = join37(this.cacheDir, "index.json");
     await writeFile13(indexPath, JSON.stringify(this.index, null, 2));
   }
   async saveEmail(email) {
@@ -141606,7 +142338,7 @@ class LocalInboxCache {
       throw new Error(`Failed to create safe filename for email ID: "${email.id}"`);
     }
     await this.ensureDirectories();
-    const emailPath = join36(this.cacheDir, "emails", `${filename}.json`);
+    const emailPath = join37(this.cacheDir, "emails", `${filename}.json`);
     await writeFile13(emailPath, JSON.stringify(email, null, 2));
     const index = await this.loadIndex();
     const existingIdx = index.emails.findIndex((e3) => e3.id === email.id);
@@ -141641,8 +142373,8 @@ class LocalInboxCache {
       return null;
     }
     try {
-      const emailPath = join36(this.cacheDir, "emails", `${filename}.json`);
-      const content = await readFile14(emailPath, "utf-8");
+      const emailPath = join37(this.cacheDir, "emails", `${filename}.json`);
+      const content = await readFile15(emailPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -141701,9 +142433,9 @@ class LocalInboxCache {
     if (!safeFilename) {
       throw new Error("Invalid attachment filename");
     }
-    const attachmentDir = join36(this.cacheDir, "attachments", emailFilename);
+    const attachmentDir = join37(this.cacheDir, "attachments", emailFilename);
     await mkdir12(attachmentDir, { recursive: true });
-    const attachmentPath = join36(attachmentDir, safeFilename);
+    const attachmentPath = join37(attachmentDir, safeFilename);
     await writeFile13(attachmentPath, content);
     return attachmentPath;
   }
@@ -141717,7 +142449,7 @@ class LocalInboxCache {
       return null;
     }
     try {
-      const attachmentPath = join36(this.cacheDir, "attachments", emailFilename, safeFilename);
+      const attachmentPath = join37(this.cacheDir, "attachments", emailFilename, safeFilename);
       await stat3(attachmentPath);
       return attachmentPath;
     } catch {
@@ -141749,10 +142481,10 @@ class LocalInboxCache {
     for (const { id, filename } of toRemove) {
       index.emails = index.emails.filter((e3) => e3.id !== id);
       try {
-        await rm4(join36(this.cacheDir, "emails", `${filename}.json`));
+        await rm4(join37(this.cacheDir, "emails", `${filename}.json`));
       } catch {}
       try {
-        await rm4(join36(this.cacheDir, "attachments", filename), { recursive: true });
+        await rm4(join37(this.cacheDir, "attachments", filename), { recursive: true });
       } catch {}
     }
     if (toRemove.length > 0) {
@@ -141763,20 +142495,20 @@ class LocalInboxCache {
   async getCacheSize() {
     let totalSize = 0;
     try {
-      const emailsDir = join36(this.cacheDir, "emails");
+      const emailsDir = join37(this.cacheDir, "emails");
       const files = await readdir4(emailsDir);
       for (const file of files) {
-        const fileStat = await stat3(join36(emailsDir, file));
+        const fileStat = await stat3(join37(emailsDir, file));
         totalSize += fileStat.size;
       }
     } catch {}
     try {
-      const attachmentsDir = join36(this.cacheDir, "attachments");
+      const attachmentsDir = join37(this.cacheDir, "attachments");
       const dirs = await readdir4(attachmentsDir);
       for (const dir of dirs) {
-        const files = await readdir4(join36(attachmentsDir, dir));
+        const files = await readdir4(join37(attachmentsDir, dir));
         for (const file of files) {
-          const fileStat = await stat3(join36(attachmentsDir, dir, file));
+          const fileStat = await stat3(join37(attachmentsDir, dir, file));
           totalSize += fileStat.size;
         }
       }
@@ -144364,7 +145096,7 @@ class InboxManager {
   }
 }
 function createInboxManager(assistantId, assistantName, config, configDir) {
-  const basePath = join37(configDir, "inbox");
+  const basePath = join38(configDir, "inbox");
   return new InboxManager({
     assistantId,
     assistantName,
@@ -147125,13 +147857,13 @@ init_src2();
 
 // ../core/src/messages/storage/local-storage.ts
 await init_runtime();
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { homedir as homedir19 } from "os";
 import { mkdir as mkdir13, readdir as readdir5, rm as rm5 } from "fs/promises";
 function getMessagesBasePath() {
   const envOverride = process.env.ASSISTANTS_DIR;
   const home = envOverride && envOverride.trim() ? envOverride : homedir19();
-  return join38(home, ".assistants", "messages");
+  return join39(home, ".assistants", "messages");
 }
 var SAFE_ID_PATTERN8 = /^[a-zA-Z0-9_-]+$/;
 
@@ -147152,27 +147884,27 @@ class LocalMessagesStorage {
     const assistantPath = this.getAssistantPath(assistantId);
     await Promise.all([
       mkdir13(this.basePath, { recursive: true }),
-      mkdir13(join38(assistantPath, "messages"), { recursive: true }),
-      mkdir13(join38(assistantPath, "threads"), { recursive: true })
+      mkdir13(join39(assistantPath, "messages"), { recursive: true }),
+      mkdir13(join39(assistantPath, "threads"), { recursive: true })
     ]);
   }
   getAssistantPath(assistantId) {
     this.validateSafeId(assistantId, "assistantId");
-    return join38(this.basePath, assistantId);
+    return join39(this.basePath, assistantId);
   }
   getIndexPath(assistantId) {
-    return join38(this.getAssistantPath(assistantId), "index.json");
+    return join39(this.getAssistantPath(assistantId), "index.json");
   }
   getMessagePath(assistantId, messageId) {
     this.validateSafeId(messageId, "messageId");
-    return join38(this.getAssistantPath(assistantId), "messages", `${messageId}.json`);
+    return join39(this.getAssistantPath(assistantId), "messages", `${messageId}.json`);
   }
   getThreadPath(assistantId, threadId) {
     this.validateSafeId(threadId, "threadId");
-    return join38(this.getAssistantPath(assistantId), "threads", `${threadId}.json`);
+    return join39(this.getAssistantPath(assistantId), "threads", `${threadId}.json`);
   }
   getRegistryPath() {
-    return join38(this.basePath, "registry.json");
+    return join39(this.basePath, "registry.json");
   }
   async loadRegistry() {
     try {
@@ -147456,7 +148188,7 @@ class LocalMessagesStorage {
   async listThreads(assistantId) {
     const runtime = getRuntime();
     const assistantPath = this.getAssistantPath(assistantId);
-    const threadsDir = join38(assistantPath, "threads");
+    const threadsDir = join39(assistantPath, "threads");
     try {
       const files = await readdir5(threadsDir);
       const threads = [];
@@ -147464,7 +148196,7 @@ class LocalMessagesStorage {
         if (!file.endsWith(".json"))
           continue;
         try {
-          const threadFile = runtime.file(join38(threadsDir, file));
+          const threadFile = runtime.file(join39(threadsDir, file));
           const thread = await threadFile.json();
           threads.push(thread);
         } catch {}
@@ -147520,8 +148252,8 @@ class LocalMessagesStorage {
 }
 
 // ../core/src/messages/watcher.ts
-import { watch, existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
-import { join as join39 } from "path";
+import { watch, existsSync as existsSync24, readdirSync as readdirSync7 } from "fs";
+import { join as join40 } from "path";
 class InboxWatcher {
   assistantId;
   inboxPath;
@@ -147532,14 +148264,14 @@ class InboxWatcher {
   constructor(assistantId, basePath) {
     this.assistantId = assistantId;
     const base = basePath || getMessagesBasePath();
-    this.inboxPath = join39(base, assistantId, "messages");
+    this.inboxPath = join40(base, assistantId, "messages");
   }
   start() {
     if (this.running)
       return;
     this.running = true;
     this.snapshotExisting();
-    if (!existsSync23(this.inboxPath)) {
+    if (!existsSync24(this.inboxPath)) {
       this.pollForDirectory();
       return;
     }
@@ -147564,8 +148296,8 @@ class InboxWatcher {
   }
   snapshotExisting() {
     try {
-      if (existsSync23(this.inboxPath)) {
-        const files = readdirSync6(this.inboxPath);
+      if (existsSync24(this.inboxPath)) {
+        const files = readdirSync7(this.inboxPath);
         for (const file of files) {
           if (file.endsWith(".json")) {
             this.knownFiles.add(file);
@@ -147607,7 +148339,7 @@ class InboxWatcher {
         clearInterval(interval);
         return;
       }
-      if (existsSync23(this.inboxPath)) {
+      if (existsSync24(this.inboxPath)) {
         clearInterval(interval);
         this.snapshotExisting();
         this.startWatching();
@@ -148284,25 +149016,1096 @@ function registerMessagesTools(registry2, getMessagesManager) {
     registry2.register(tool, executors[tool.name]);
   }
 }
-// ../core/src/sessions/store.ts
-import { join as join40 } from "path";
+// ../core/src/webhooks/storage/local-storage.ts
+await init_runtime();
+import { join as join41 } from "path";
 import { homedir as homedir20 } from "os";
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, writeFileSync as writeFileSync14, readFileSync as readFileSync17, readdirSync as readdirSync7, unlinkSync as unlinkSync5 } from "fs";
+import { mkdir as mkdir14, readdir as readdir6, rm as rm6 } from "fs/promises";
+function getWebhooksBasePath() {
+  const envOverride = process.env.ASSISTANTS_DIR;
+  const home = envOverride && envOverride.trim() ? envOverride : homedir20();
+  return join41(home, ".assistants", "webhooks");
+}
+var SAFE_ID_PATTERN9 = /^[a-zA-Z0-9_-]+$/;
+
+class LocalWebhookStorage {
+  basePath;
+  constructor(options = {}) {
+    this.basePath = options.basePath || getWebhooksBasePath();
+  }
+  validateSafeId(id, idType) {
+    if (!id || typeof id !== "string") {
+      throw new Error(`Invalid ${idType}: must be a non-empty string`);
+    }
+    if (!SAFE_ID_PATTERN9.test(id)) {
+      throw new Error(`Invalid ${idType}: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+    }
+  }
+  async ensureDirectories(webhookId) {
+    const dirs = [
+      mkdir14(this.basePath, { recursive: true }),
+      mkdir14(join41(this.basePath, "registrations"), { recursive: true }),
+      mkdir14(join41(this.basePath, "events"), { recursive: true }),
+      mkdir14(join41(this.basePath, "deliveries"), { recursive: true })
+    ];
+    if (webhookId) {
+      this.validateSafeId(webhookId, "webhookId");
+      dirs.push(mkdir14(join41(this.basePath, "events", webhookId), { recursive: true }));
+      dirs.push(mkdir14(join41(this.basePath, "deliveries", webhookId), { recursive: true }));
+    }
+    await Promise.all(dirs);
+  }
+  getIndexPath() {
+    return join41(this.basePath, "index.json");
+  }
+  getRegistrationPath(webhookId) {
+    this.validateSafeId(webhookId, "webhookId");
+    return join41(this.basePath, "registrations", `${webhookId}.json`);
+  }
+  getEventIndexPath(webhookId) {
+    this.validateSafeId(webhookId, "webhookId");
+    return join41(this.basePath, "events", webhookId, "index.json");
+  }
+  getEventPath(webhookId, eventId) {
+    this.validateSafeId(webhookId, "webhookId");
+    this.validateSafeId(eventId, "eventId");
+    return join41(this.basePath, "events", webhookId, `${eventId}.json`);
+  }
+  getDeliveryPath(webhookId, deliveryId) {
+    this.validateSafeId(webhookId, "webhookId");
+    this.validateSafeId(deliveryId, "deliveryId");
+    return join41(this.basePath, "deliveries", webhookId, `${deliveryId}.json`);
+  }
+  async loadIndex() {
+    try {
+      const runtime = getRuntime();
+      const file = runtime.file(this.getIndexPath());
+      if (!await file.exists()) {
+        return { webhooks: [], lastUpdated: new Date().toISOString() };
+      }
+      return await file.json();
+    } catch {
+      return { webhooks: [], lastUpdated: new Date().toISOString() };
+    }
+  }
+  async saveIndex(index) {
+    const runtime = getRuntime();
+    await mkdir14(this.basePath, { recursive: true });
+    index.lastUpdated = new Date().toISOString();
+    await runtime.write(this.getIndexPath(), JSON.stringify(index, null, 2));
+  }
+  async saveRegistration(registration) {
+    const runtime = getRuntime();
+    await this.ensureDirectories(registration.id);
+    await runtime.write(this.getRegistrationPath(registration.id), JSON.stringify(registration, null, 2));
+    const index = await this.loadIndex();
+    const existing = index.webhooks.findIndex((w6) => w6.id === registration.id);
+    const listItem = {
+      id: registration.id,
+      name: registration.name,
+      source: registration.source,
+      status: registration.status,
+      deliveryCount: registration.deliveryCount,
+      createdAt: registration.createdAt,
+      lastDeliveryAt: registration.lastDeliveryAt
+    };
+    if (existing >= 0) {
+      index.webhooks[existing] = listItem;
+    } else {
+      index.webhooks.unshift(listItem);
+    }
+    await this.saveIndex(index);
+  }
+  async loadRegistration(webhookId) {
+    try {
+      const runtime = getRuntime();
+      const file = runtime.file(this.getRegistrationPath(webhookId));
+      if (!await file.exists()) {
+        return null;
+      }
+      return await file.json();
+    } catch {
+      return null;
+    }
+  }
+  async deleteRegistration(webhookId) {
+    try {
+      const regPath = this.getRegistrationPath(webhookId);
+      const runtime = getRuntime();
+      const file = runtime.file(regPath);
+      if (!await file.exists()) {
+        return false;
+      }
+      await rm6(regPath);
+      const index = await this.loadIndex();
+      const idx = index.webhooks.findIndex((w6) => w6.id === webhookId);
+      if (idx >= 0) {
+        index.webhooks.splice(idx, 1);
+        await this.saveIndex(index);
+      }
+      try {
+        await rm6(join41(this.basePath, "events", webhookId), { recursive: true, force: true });
+        await rm6(join41(this.basePath, "deliveries", webhookId), { recursive: true, force: true });
+      } catch {}
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listRegistrations() {
+    const index = await this.loadIndex();
+    return index.webhooks;
+  }
+  async loadEventIndex(webhookId) {
+    try {
+      const runtime = getRuntime();
+      const file = runtime.file(this.getEventIndexPath(webhookId));
+      if (!await file.exists()) {
+        return {
+          events: [],
+          lastUpdated: new Date().toISOString(),
+          totalEvents: 0,
+          pendingCount: 0
+        };
+      }
+      return await file.json();
+    } catch {
+      return {
+        events: [],
+        lastUpdated: new Date().toISOString(),
+        totalEvents: 0,
+        pendingCount: 0
+      };
+    }
+  }
+  async saveEventIndex(webhookId, index) {
+    const runtime = getRuntime();
+    this.validateSafeId(webhookId, "webhookId");
+    await mkdir14(join41(this.basePath, "events", webhookId), { recursive: true });
+    index.lastUpdated = new Date().toISOString();
+    await runtime.write(this.getEventIndexPath(webhookId), JSON.stringify(index, null, 2));
+  }
+  async saveEvent(event) {
+    const runtime = getRuntime();
+    await this.ensureDirectories(event.webhookId);
+    await runtime.write(this.getEventPath(event.webhookId, event.id), JSON.stringify(event, null, 2));
+    const eventIndex = await this.loadEventIndex(event.webhookId);
+    const payloadStr = JSON.stringify(event.payload);
+    const listItem = {
+      id: event.id,
+      source: event.source,
+      eventType: event.eventType,
+      preview: payloadStr.slice(0, 100) + (payloadStr.length > 100 ? "..." : ""),
+      timestamp: event.timestamp,
+      status: event.status
+    };
+    eventIndex.events.unshift(listItem);
+    eventIndex.totalEvents++;
+    if (event.status === "pending") {
+      eventIndex.pendingCount++;
+    }
+    await this.saveEventIndex(event.webhookId, eventIndex);
+  }
+  async loadEvent(webhookId, eventId) {
+    try {
+      const runtime = getRuntime();
+      const file = runtime.file(this.getEventPath(webhookId, eventId));
+      if (!await file.exists()) {
+        return null;
+      }
+      return await file.json();
+    } catch {
+      return null;
+    }
+  }
+  async updateEventStatus(webhookId, eventId, status, timestamp) {
+    const runtime = getRuntime();
+    const event = await this.loadEvent(webhookId, eventId);
+    if (!event)
+      return;
+    const oldStatus = event.status;
+    event.status = status;
+    if (status === "injected" && timestamp) {
+      event.injectedAt = timestamp;
+    }
+    await runtime.write(this.getEventPath(webhookId, eventId), JSON.stringify(event, null, 2));
+    const eventIndex = await this.loadEventIndex(webhookId);
+    const indexItem = eventIndex.events.find((e6) => e6.id === eventId);
+    if (indexItem) {
+      indexItem.status = status;
+    }
+    if (oldStatus === "pending" && status !== "pending") {
+      eventIndex.pendingCount = Math.max(0, eventIndex.pendingCount - 1);
+    }
+    await this.saveEventIndex(webhookId, eventIndex);
+  }
+  async listEvents(webhookId, options) {
+    const eventIndex = await this.loadEventIndex(webhookId);
+    let events = [...eventIndex.events];
+    if (options?.pendingOnly) {
+      events = events.filter((e6) => e6.status === "pending");
+    }
+    if (options?.limit && options.limit > 0) {
+      events = events.slice(0, options.limit);
+    }
+    return events;
+  }
+  async saveDelivery(delivery) {
+    const runtime = getRuntime();
+    this.validateSafeId(delivery.webhookId, "webhookId");
+    await mkdir14(join41(this.basePath, "deliveries", delivery.webhookId), { recursive: true });
+    await runtime.write(this.getDeliveryPath(delivery.webhookId, delivery.id), JSON.stringify(delivery, null, 2));
+  }
+  async listDeliveries(webhookId, options) {
+    this.validateSafeId(webhookId, "webhookId");
+    const deliveriesDir = join41(this.basePath, "deliveries", webhookId);
+    try {
+      const files = await readdir6(deliveriesDir);
+      const runtime = getRuntime();
+      const deliveries = [];
+      for (const file of files) {
+        if (!file.endsWith(".json"))
+          continue;
+        try {
+          const deliveryFile = runtime.file(join41(deliveriesDir, file));
+          const delivery = await deliveryFile.json();
+          deliveries.push(delivery);
+        } catch {}
+      }
+      deliveries.sort((a5, b8) => new Date(b8.receivedAt).getTime() - new Date(a5.receivedAt).getTime());
+      if (options?.limit && options.limit > 0) {
+        return deliveries.slice(0, options.limit);
+      }
+      return deliveries;
+    } catch {
+      return [];
+    }
+  }
+  async cleanupEvents(webhookId, maxAgeDays) {
+    const cutoffDate = new Date;
+    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+    const cutoffTime = cutoffDate.getTime();
+    const eventIndex = await this.loadEventIndex(webhookId);
+    const toDelete = [];
+    for (const evt of eventIndex.events) {
+      const evtTime = new Date(evt.timestamp).getTime();
+      if (evtTime < cutoffTime) {
+        toDelete.push(evt.id);
+      }
+    }
+    for (const id of toDelete) {
+      try {
+        await rm6(this.getEventPath(webhookId, id));
+      } catch {}
+    }
+    eventIndex.events = eventIndex.events.filter((e6) => !toDelete.includes(e6.id));
+    eventIndex.pendingCount = eventIndex.events.filter((e6) => e6.status === "pending").length;
+    await this.saveEventIndex(webhookId, eventIndex);
+    return toDelete.length;
+  }
+  async enforceMaxEvents(webhookId, maxEvents) {
+    const eventIndex = await this.loadEventIndex(webhookId);
+    if (eventIndex.events.length <= maxEvents) {
+      return 0;
+    }
+    const sorted = [...eventIndex.events].sort((a5, b8) => new Date(a5.timestamp).getTime() - new Date(b8.timestamp).getTime());
+    const toDelete = sorted.slice(0, eventIndex.events.length - maxEvents);
+    for (const evt of toDelete) {
+      try {
+        await rm6(this.getEventPath(webhookId, evt.id));
+      } catch {}
+    }
+    const deleteIds = new Set(toDelete.map((e6) => e6.id));
+    eventIndex.events = eventIndex.events.filter((e6) => !deleteIds.has(e6.id));
+    eventIndex.pendingCount = eventIndex.events.filter((e6) => e6.status === "pending").length;
+    await this.saveEventIndex(webhookId, eventIndex);
+    return toDelete.length;
+  }
+}
+
+// ../core/src/webhooks/watcher.ts
+import { watch as watch2, existsSync as existsSync25, readdirSync as readdirSync8 } from "fs";
+import { join as join42 } from "path";
+class WebhookEventWatcher {
+  basePath;
+  eventsPath;
+  watchers = new Map;
+  callbacks = new Set;
+  knownFiles = new Map;
+  running = false;
+  directoryWatcher = null;
+  constructor(basePath) {
+    this.basePath = basePath || getWebhooksBasePath();
+    this.eventsPath = join42(this.basePath, "events");
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    if (!existsSync25(this.eventsPath)) {
+      this.pollForDirectory();
+      return;
+    }
+    this.startWatchingAll();
+  }
+  stop() {
+    this.running = false;
+    for (const [, watcher] of this.watchers) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    if (this.directoryWatcher) {
+      this.directoryWatcher.close();
+      this.directoryWatcher = null;
+    }
+    this.callbacks.clear();
+    this.knownFiles.clear();
+  }
+  onNewEvent(cb2) {
+    this.callbacks.add(cb2);
+    return () => {
+      this.callbacks.delete(cb2);
+    };
+  }
+  isRunning() {
+    return this.running;
+  }
+  startWatchingAll() {
+    try {
+      this.directoryWatcher = watch2(this.eventsPath, (eventType, filename) => {
+        if (!filename || eventType !== "rename")
+          return;
+        const dirPath = join42(this.eventsPath, filename);
+        if (existsSync25(dirPath) && !this.watchers.has(filename)) {
+          this.watchWebhookDir(filename);
+        }
+      });
+      this.directoryWatcher.on("error", () => {
+        if (this.running) {
+          this.directoryWatcher?.close();
+          this.directoryWatcher = null;
+          setTimeout(() => {
+            if (this.running)
+              this.startWatchingAll();
+          }, 5000);
+        }
+      });
+    } catch {}
+    try {
+      const dirs = readdirSync8(this.eventsPath);
+      for (const dir of dirs) {
+        this.watchWebhookDir(dir);
+      }
+    } catch {}
+  }
+  watchWebhookDir(webhookId) {
+    if (this.watchers.has(webhookId))
+      return;
+    const dirPath = join42(this.eventsPath, webhookId);
+    if (!existsSync25(dirPath))
+      return;
+    const known = new Set;
+    try {
+      const files = readdirSync8(dirPath);
+      for (const file of files) {
+        if (file.endsWith(".json") && file !== "index.json") {
+          known.add(file);
+        }
+      }
+    } catch {}
+    this.knownFiles.set(webhookId, known);
+    try {
+      const watcher = watch2(dirPath, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".json") || filename === "index.json")
+          return;
+        const knownSet = this.knownFiles.get(webhookId);
+        if (eventType === "rename" && knownSet && !knownSet.has(filename)) {
+          knownSet.add(filename);
+          const eventId = filename.replace(".json", "");
+          this.notifyCallbacks(webhookId, eventId);
+        }
+      });
+      watcher.on("error", () => {
+        if (this.running) {
+          watcher.close();
+          this.watchers.delete(webhookId);
+          setTimeout(() => {
+            if (this.running)
+              this.watchWebhookDir(webhookId);
+          }, 5000);
+        }
+      });
+      this.watchers.set(webhookId, watcher);
+    } catch {}
+  }
+  pollForDirectory() {
+    if (!this.running)
+      return;
+    const interval = setInterval(() => {
+      if (!this.running) {
+        clearInterval(interval);
+        return;
+      }
+      if (existsSync25(this.eventsPath)) {
+        clearInterval(interval);
+        this.startWatchingAll();
+      }
+    }, 5000);
+  }
+  notifyCallbacks(webhookId, eventId) {
+    for (const cb2 of this.callbacks) {
+      try {
+        cb2(webhookId, eventId);
+      } catch {}
+    }
+  }
+}
+
+// ../core/src/webhooks/manager.ts
+init_crypto();
+
+class WebhooksManager {
+  assistantId;
+  config;
+  storage;
+  watcher = null;
+  eventCallbacks = new Set;
+  rateLimits = new Map;
+  constructor(options) {
+    this.assistantId = options.assistantId;
+    this.config = options.config;
+    this.storage = new LocalWebhookStorage({
+      basePath: options.config.storage?.basePath || getWebhooksBasePath()
+    });
+  }
+  async initialize() {
+    await this.storage.ensureDirectories();
+  }
+  async create(input) {
+    try {
+      const webhookId = generateWebhookId();
+      const secret = generateWebhookSecret();
+      const now2 = new Date().toISOString();
+      const registration = {
+        id: webhookId,
+        name: input.name,
+        source: input.source,
+        description: input.description,
+        secret,
+        eventsFilter: input.eventsFilter || [],
+        status: "active",
+        deliveryCount: 0,
+        createdAt: now2,
+        updatedAt: now2
+      };
+      await this.storage.saveRegistration(registration);
+      const url = `/api/v1/webhooks/receive/${webhookId}`;
+      return {
+        success: true,
+        message: `Webhook "${input.name}" created for source "${input.source}"`,
+        webhookId,
+        secret,
+        url
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        message: `Failed to create webhook: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+  }
+  async list() {
+    return this.storage.listRegistrations();
+  }
+  async get(webhookId) {
+    return this.storage.loadRegistration(webhookId);
+  }
+  async update(input) {
+    try {
+      const registration = await this.storage.loadRegistration(input.id);
+      if (!registration) {
+        return { success: false, message: `Webhook "${input.id}" not found.` };
+      }
+      if (input.name !== undefined)
+        registration.name = input.name;
+      if (input.description !== undefined)
+        registration.description = input.description;
+      if (input.eventsFilter !== undefined)
+        registration.eventsFilter = input.eventsFilter;
+      if (input.status !== undefined)
+        registration.status = input.status;
+      registration.updatedAt = new Date().toISOString();
+      await this.storage.saveRegistration(registration);
+      return {
+        success: true,
+        message: `Webhook "${registration.name}" updated.`,
+        webhookId: registration.id
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        message: `Failed to update webhook: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+  }
+  async delete(webhookId) {
+    const deleted = await this.storage.deleteRegistration(webhookId);
+    if (deleted) {
+      return { success: true, message: `Webhook ${webhookId} deleted.` };
+    }
+    return { success: false, message: `Webhook ${webhookId} not found.` };
+  }
+  async receiveEvent(input) {
+    try {
+      const registration = await this.storage.loadRegistration(input.webhookId);
+      if (!registration) {
+        return { success: false, message: "Webhook not found." };
+      }
+      if (registration.status !== "active") {
+        return { success: false, message: "Webhook is not active." };
+      }
+      if (!this.checkRateLimit(input.webhookId)) {
+        return { success: false, message: "Rate limit exceeded." };
+      }
+      const maxTimestampAge = this.config.security?.maxTimestampAgeMs || 300000;
+      if (!isTimestampValid(input.timestamp, maxTimestampAge)) {
+        return { success: false, message: "Timestamp too old or invalid." };
+      }
+      const payloadStr = JSON.stringify(input.payload);
+      if (!verifySignature(payloadStr, input.signature, registration.secret)) {
+        return { success: false, message: "Invalid signature." };
+      }
+      if (registration.eventsFilter.length > 0 && !registration.eventsFilter.includes(input.eventType)) {
+        return { success: false, message: `Event type "${input.eventType}" not accepted by this webhook.` };
+      }
+      const eventId = generateEventId();
+      const deliveryId = generateDeliveryId();
+      const now2 = new Date().toISOString();
+      const event = {
+        id: eventId,
+        webhookId: input.webhookId,
+        source: registration.source,
+        eventType: input.eventType,
+        payload: input.payload,
+        timestamp: input.timestamp,
+        signature: input.signature,
+        status: "pending"
+      };
+      await this.storage.saveEvent(event);
+      const delivery = {
+        id: deliveryId,
+        webhookId: input.webhookId,
+        eventId,
+        receivedAt: now2,
+        status: "accepted",
+        httpStatus: 200,
+        remoteIp: input.remoteIp
+      };
+      await this.storage.saveDelivery(delivery);
+      registration.deliveryCount++;
+      registration.lastDeliveryAt = now2;
+      registration.updatedAt = now2;
+      await this.storage.saveRegistration(registration);
+      return {
+        success: true,
+        message: "Event received.",
+        deliveryId,
+        eventId
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        message: `Failed to process event: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+  }
+  async sendTestEvent(webhookId) {
+    const registration = await this.storage.loadRegistration(webhookId);
+    if (!registration) {
+      return { success: false, message: `Webhook "${webhookId}" not found.` };
+    }
+    const { signPayload: signPayload2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+    const payload = { test: true, message: "Test event from assistant", timestamp: new Date().toISOString() };
+    const payloadStr = JSON.stringify(payload);
+    const signature = signPayload2(payloadStr, registration.secret);
+    return this.receiveEvent({
+      webhookId,
+      payload,
+      signature,
+      timestamp: new Date().toISOString(),
+      eventType: "test"
+    });
+  }
+  async listEvents(webhookId, options) {
+    return this.storage.listEvents(webhookId, options);
+  }
+  async listDeliveries(webhookId, options) {
+    return this.storage.listDeliveries(webhookId, options);
+  }
+  async getPendingForInjection() {
+    const injectionConfig = this.config.injection || {};
+    if (injectionConfig.enabled === false) {
+      return [];
+    }
+    const maxPerTurn = injectionConfig.maxPerTurn || 5;
+    const webhooks = await this.storage.listRegistrations();
+    const allPending = [];
+    for (const webhook of webhooks) {
+      if (webhook.status !== "active")
+        continue;
+      const pendingItems = await this.storage.listEvents(webhook.id, { pendingOnly: true });
+      for (const item of pendingItems) {
+        const event = await this.storage.loadEvent(webhook.id, item.id);
+        if (event && event.status === "pending") {
+          allPending.push(event);
+        }
+      }
+    }
+    allPending.sort((a5, b8) => new Date(a5.timestamp).getTime() - new Date(b8.timestamp).getTime());
+    return allPending.slice(0, maxPerTurn);
+  }
+  async markInjected(events) {
+    const now2 = new Date().toISOString();
+    for (const { webhookId, eventId } of events) {
+      await this.storage.updateEventStatus(webhookId, eventId, "injected", now2);
+    }
+  }
+  buildInjectionContext(events) {
+    if (events.length === 0) {
+      return "";
+    }
+    const lines = [];
+    lines.push("## Pending Webhook Events");
+    lines.push("");
+    lines.push(`You have ${events.length} pending webhook event(s):`);
+    for (const evt of events) {
+      lines.push("");
+      lines.push(`### ${evt.source}: ${evt.eventType}`);
+      lines.push(`**Webhook:** ${evt.webhookId} | **Received:** ${formatDate2(evt.timestamp)}`);
+      lines.push("");
+      lines.push("```json");
+      lines.push(JSON.stringify(evt.payload, null, 2));
+      lines.push("```");
+      lines.push(`*Event ID: ${evt.id}*`);
+      lines.push("---");
+    }
+    lines.push("");
+    lines.push("Process these events as appropriate. Use webhook tools to manage webhooks.");
+    return lines.join(`
+`);
+  }
+  startWatching() {
+    if (this.watcher)
+      return;
+    this.watcher = new WebhookEventWatcher(this.config.storage?.basePath);
+    this.watcher.onNewEvent(async (webhookId, eventId) => {
+      try {
+        const event = await this.storage.loadEvent(webhookId, eventId);
+        if (event) {
+          for (const cb2 of this.eventCallbacks) {
+            try {
+              cb2(event);
+            } catch {}
+          }
+        }
+      } catch {}
+    });
+    this.watcher.start();
+  }
+  stopWatching() {
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher = null;
+    }
+    this.eventCallbacks.clear();
+  }
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => {
+      this.eventCallbacks.delete(callback);
+    };
+  }
+  isWatching() {
+    return this.watcher?.isRunning() ?? false;
+  }
+  checkRateLimit(webhookId) {
+    const maxPerMinute = this.config.security?.rateLimitPerMinute || 60;
+    const now2 = Date.now();
+    const windowMs = 60000;
+    let entry = this.rateLimits.get(webhookId);
+    if (!entry || now2 - entry.windowStart >= windowMs) {
+      entry = { count: 0, windowStart: now2 };
+      this.rateLimits.set(webhookId, entry);
+    }
+    entry.count++;
+    return entry.count <= maxPerMinute;
+  }
+  async cleanup() {
+    const maxAgeDays = this.config.storage?.maxAgeDays || 30;
+    const maxEvents = this.config.storage?.maxEvents || 1000;
+    const webhooks = await this.storage.listRegistrations();
+    let totalDeleted = 0;
+    for (const webhook of webhooks) {
+      totalDeleted += await this.storage.cleanupEvents(webhook.id, maxAgeDays);
+      totalDeleted += await this.storage.enforceMaxEvents(webhook.id, maxEvents);
+    }
+    return totalDeleted;
+  }
+}
+function formatDate2(isoDate) {
+  const date = new Date(isoDate);
+  return date.toLocaleString();
+}
+function createWebhooksManager(assistantId, config) {
+  return new WebhooksManager({
+    assistantId,
+    config
+  });
+}
+
+// ../core/src/webhooks/index.ts
+init_crypto();
+
+// ../core/src/webhooks/tools.ts
+var webhookCreateTool = {
+  name: "webhook_create",
+  description: "Create a new webhook endpoint. Returns the URL and secret needed for the external source to send events. The secret is used for HMAC-SHA256 signature verification.",
+  parameters: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: 'Human-readable name for the webhook (e.g., "Gmail notifications")'
+      },
+      source: {
+        type: "string",
+        description: 'Source identifier (e.g., "gmail", "notion", "github", "custom")'
+      },
+      description: {
+        type: "string",
+        description: "Description of what this webhook handles (optional)"
+      },
+      eventsFilter: {
+        type: "array",
+        description: 'Event types to accept (optional, empty = accept all). Example: ["message.received", "issue.opened"]',
+        items: { type: "string", description: "Event type name" }
+      }
+    },
+    required: ["name", "source"]
+  }
+};
+var webhookListTool = {
+  name: "webhook_list",
+  description: "List all registered webhooks with their status, source, and delivery counts.",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+var webhookGetTool = {
+  name: "webhook_get",
+  description: "Get full details of a webhook including its secret, URL, events filter, and delivery count.",
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "The webhook ID (e.g., whk_abc123)"
+      }
+    },
+    required: ["id"]
+  }
+};
+var webhookUpdateTool = {
+  name: "webhook_update",
+  description: "Update a webhook registration. Can change name, description, events filter, or status (active/paused).",
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "The webhook ID to update"
+      },
+      name: {
+        type: "string",
+        description: "New name (optional)"
+      },
+      description: {
+        type: "string",
+        description: "New description (optional)"
+      },
+      eventsFilter: {
+        type: "array",
+        description: "New events filter (optional)",
+        items: { type: "string", description: "Event type name" }
+      },
+      status: {
+        type: "string",
+        description: "New status: active or paused (optional)",
+        enum: ["active", "paused"]
+      }
+    },
+    required: ["id"]
+  }
+};
+var webhookDeleteTool = {
+  name: "webhook_delete",
+  description: "Delete a webhook registration and all its event history.",
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "The webhook ID to delete"
+      }
+    },
+    required: ["id"]
+  }
+};
+var webhookEventsTool = {
+  name: "webhook_events",
+  description: "List recent events received by a webhook. Shows event type, payload preview, and status.",
+  parameters: {
+    type: "object",
+    properties: {
+      webhookId: {
+        type: "string",
+        description: "The webhook ID to list events for"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of events to return (default: 20)"
+      },
+      pendingOnly: {
+        type: "boolean",
+        description: "Only show pending (unprocessed) events (default: false)"
+      }
+    },
+    required: ["webhookId"]
+  }
+};
+var webhookTestTool = {
+  name: "webhook_test",
+  description: "Send a test event to a webhook to verify it is working correctly.",
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "The webhook ID to send a test event to"
+      }
+    },
+    required: ["id"]
+  }
+};
+function createWebhookToolExecutors(getWebhooksManager) {
+  return {
+    webhook_create: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured. Set webhooks.enabled: true in config.";
+      }
+      const name2 = String(input.name || "").trim();
+      const source = String(input.source || "").trim();
+      const description = input.description ? String(input.description).trim() : undefined;
+      const eventsFilter = Array.isArray(input.eventsFilter) ? input.eventsFilter.map(String) : undefined;
+      if (!name2)
+        return "Error: Webhook name is required.";
+      if (!source)
+        return "Error: Source identifier is required.";
+      const result = await manager.create({ name: name2, source, description, eventsFilter });
+      if (result.success) {
+        const lines = [];
+        lines.push(`Webhook created successfully!`);
+        lines.push("");
+        lines.push(`**ID:** ${result.webhookId}`);
+        lines.push(`**URL:** ${result.url}`);
+        lines.push(`**Secret:** ${result.secret}`);
+        lines.push("");
+        lines.push("**Setup instructions for the external source:**");
+        lines.push(`1. Set webhook URL to: \`<your-base-url>${result.url}\``);
+        lines.push(`2. Set signing secret to: \`${result.secret}\``);
+        lines.push("3. Include these headers with each POST:");
+        lines.push("   - `X-Webhook-Signature`: HMAC-SHA256 hex digest of the JSON body");
+        lines.push("   - `X-Webhook-Timestamp`: ISO 8601 timestamp");
+        lines.push("   - `X-Webhook-Event`: Event type name");
+        return lines.join(`
+`);
+      }
+      return `Error: ${result.message}`;
+    },
+    webhook_list: async () => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      try {
+        const webhooks = await manager.list();
+        if (webhooks.length === 0) {
+          return "No webhooks registered. Use webhook_create to create one.";
+        }
+        const lines = [];
+        lines.push(`## Webhooks (${webhooks.length})`);
+        lines.push("");
+        for (const wh of webhooks) {
+          const statusIcon = wh.status === "active" ? "\u25CF" : wh.status === "paused" ? "\u25D0" : "\u2717";
+          const statusColor = wh.status === "active" ? "" : ` [${wh.status}]`;
+          const lastDelivery = wh.lastDeliveryAt ? new Date(wh.lastDeliveryAt).toLocaleDateString() : "never";
+          lines.push(`${statusIcon} **${wh.name}** (${wh.id})${statusColor}`);
+          lines.push(`   Source: ${wh.source} | Events: ${wh.deliveryCount} | Last: ${lastDelivery}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error listing webhooks: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    webhook_get: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      const id = String(input.id || "").trim();
+      if (!id)
+        return "Error: Webhook ID is required.";
+      try {
+        const webhook = await manager.get(id);
+        if (!webhook) {
+          return `Webhook ${id} not found.`;
+        }
+        const lines = [];
+        lines.push(`## Webhook: ${webhook.name}`);
+        lines.push("");
+        lines.push(`**ID:** ${webhook.id}`);
+        lines.push(`**Source:** ${webhook.source}`);
+        lines.push(`**Status:** ${webhook.status}`);
+        if (webhook.description) {
+          lines.push(`**Description:** ${webhook.description}`);
+        }
+        lines.push(`**Secret:** ${webhook.secret}`);
+        lines.push(`**URL:** /api/v1/webhooks/receive/${webhook.id}`);
+        lines.push(`**Events Filter:** ${webhook.eventsFilter.length > 0 ? webhook.eventsFilter.join(", ") : "all"}`);
+        lines.push(`**Deliveries:** ${webhook.deliveryCount}`);
+        lines.push(`**Created:** ${new Date(webhook.createdAt).toLocaleString()}`);
+        if (webhook.lastDeliveryAt) {
+          lines.push(`**Last Delivery:** ${new Date(webhook.lastDeliveryAt).toLocaleString()}`);
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error getting webhook: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    webhook_update: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      const id = String(input.id || "").trim();
+      if (!id)
+        return "Error: Webhook ID is required.";
+      const name2 = input.name ? String(input.name).trim() : undefined;
+      const description = input.description ? String(input.description).trim() : undefined;
+      const eventsFilter = Array.isArray(input.eventsFilter) ? input.eventsFilter.map(String) : undefined;
+      const status = input.status;
+      const result = await manager.update({ id, name: name2, description, eventsFilter, status });
+      return result.message;
+    },
+    webhook_delete: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      const id = String(input.id || "").trim();
+      if (!id)
+        return "Error: Webhook ID is required.";
+      const result = await manager.delete(id);
+      return result.message;
+    },
+    webhook_events: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      const webhookId = String(input.webhookId || "").trim();
+      if (!webhookId)
+        return "Error: Webhook ID is required.";
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      const pendingOnly = input.pendingOnly === true;
+      try {
+        const events = await manager.listEvents(webhookId, { limit: limit2, pendingOnly });
+        if (events.length === 0) {
+          return pendingOnly ? "No pending events for this webhook." : "No events received for this webhook.";
+        }
+        const lines = [];
+        lines.push(`## Events for ${webhookId} (${events.length})`);
+        lines.push("");
+        for (const evt of events) {
+          const statusIcon = evt.status === "pending" ? "\u23F3" : evt.status === "injected" ? "\uD83D\uDCE8" : evt.status === "processed" ? "\u2713" : "\u2717";
+          const date = new Date(evt.timestamp).toLocaleString();
+          lines.push(`${statusIcon} **${evt.eventType}** (${evt.id})`);
+          lines.push(`   Source: ${evt.source} | Status: ${evt.status} | ${date}`);
+          lines.push(`   Preview: ${evt.preview}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error listing events: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    webhook_test: async (input) => {
+      const manager = getWebhooksManager();
+      if (!manager) {
+        return "Error: Webhooks are not enabled or configured.";
+      }
+      const id = String(input.id || "").trim();
+      if (!id)
+        return "Error: Webhook ID is required.";
+      const result = await manager.sendTestEvent(id);
+      if (result.success) {
+        return `Test event sent successfully! Event ID: ${result.eventId}, Delivery ID: ${result.deliveryId}`;
+      }
+      return `Error: ${result.message}`;
+    }
+  };
+}
+var webhookTools = [
+  webhookCreateTool,
+  webhookListTool,
+  webhookGetTool,
+  webhookUpdateTool,
+  webhookDeleteTool,
+  webhookEventsTool,
+  webhookTestTool
+];
+function registerWebhookTools(registry2, getWebhooksManager) {
+  const executors = createWebhookToolExecutors(getWebhooksManager);
+  for (const tool of webhookTools) {
+    registry2.register(tool, executors[tool.name]);
+  }
+}
+// ../core/src/sessions/store.ts
+import { join as join43 } from "path";
+import { homedir as homedir21 } from "os";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14, readFileSync as readFileSync17, readdirSync as readdirSync9, unlinkSync as unlinkSync5 } from "fs";
 
 class SessionStore {
   basePath;
   constructor(basePath) {
-    const envHome = process.env.HOME || process.env.USERPROFILE || homedir20();
-    this.basePath = basePath || join40(envHome, ".assistants", "sessions");
+    const envHome = process.env.HOME || process.env.USERPROFILE || homedir21();
+    this.basePath = basePath || join43(envHome, ".assistants", "sessions");
     this.ensureDir();
   }
   ensureDir() {
-    if (!existsSync24(this.basePath)) {
-      mkdirSync15(this.basePath, { recursive: true });
+    if (!existsSync26(this.basePath)) {
+      mkdirSync16(this.basePath, { recursive: true });
     }
   }
   getSessionPath(id) {
-    return join40(this.basePath, `${id}.json`);
+    return join43(this.basePath, `${id}.json`);
   }
   save(data) {
     try {
@@ -148313,7 +150116,7 @@ class SessionStore {
   load(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (!existsSync24(filePath))
+      if (!existsSync26(filePath))
         return null;
       return JSON.parse(readFileSync17(filePath, "utf-8"));
     } catch {
@@ -148323,11 +150126,11 @@ class SessionStore {
   list() {
     try {
       this.ensureDir();
-      const files = readdirSync7(this.basePath).filter((f6) => f6.endsWith(".json"));
+      const files = readdirSync9(this.basePath).filter((f6) => f6.endsWith(".json"));
       const sessions = [];
       for (const file of files) {
         try {
-          const data = JSON.parse(readFileSync17(join40(this.basePath, file), "utf-8"));
+          const data = JSON.parse(readFileSync17(join43(this.basePath, file), "utf-8"));
           sessions.push(data);
         } catch {}
       }
@@ -148339,7 +150142,7 @@ class SessionStore {
   delete(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (existsSync24(filePath)) {
+      if (existsSync26(filePath)) {
         unlinkSync5(filePath);
       }
     } catch {}
@@ -148387,6 +150190,7 @@ class EmbeddedClient {
     this.assistantLoop = createAssistant({
       cwd: this.cwd,
       sessionId,
+      assistantId: options?.assistantId,
       allowedTools: options?.allowedTools,
       extraSystemPrompt: options?.systemPrompt,
       model: options?.model,
@@ -148637,6 +150441,12 @@ class EmbeddedClient {
     }
     return null;
   }
+  getWebhooksManager() {
+    if (typeof this.assistantLoop.getWebhooksManager === "function") {
+      return this.assistantLoop.getWebhooksManager();
+    }
+    return null;
+  }
   getWalletManager() {
     if (typeof this.assistantLoop.getWalletManager === "function") {
       return this.assistantLoop.getWalletManager();
@@ -148748,17 +150558,25 @@ class SessionRegistry {
   maxBufferedChunks = 2000;
   store;
   constructor(clientFactory) {
-    this.clientFactory = clientFactory ?? ((cwd) => new EmbeddedClient(cwd));
+    this.clientFactory = clientFactory ?? ((cwd, options) => new EmbeddedClient(cwd, options));
     this.store = new SessionStore;
   }
   async createSession(cwdOrOptions) {
     const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
-    const client = this.clientFactory(options.cwd);
+    const clientOptions = {
+      sessionId: options.sessionId,
+      initialMessages: options.initialMessages,
+      startedAt: options.startedAt,
+      assistantId: options.assistantId
+    };
+    const client = this.clientFactory(options.cwd, clientOptions);
     await client.initialize();
+    const parsedStartedAt = options.startedAt ? new Date(options.startedAt).getTime() : Date.now();
+    const startedAt = Number.isNaN(parsedStartedAt) ? Date.now() : parsedStartedAt;
     const sessionInfo = {
       id: client.getSessionId(),
       cwd: options.cwd,
-      startedAt: Date.now(),
+      startedAt,
       updatedAt: Date.now(),
       isProcessing: false,
       client,
@@ -150497,9 +152315,9 @@ function createSelfAwarenessToolExecutors(context) {
       return JSON.stringify(response, null, 2);
     },
     workspace_map: async (input) => {
-      const { readdir: readdir6, stat: stat5, access } = await import("fs/promises");
+      const { readdir: readdir7, stat: stat5, access } = await import("fs/promises");
       const { execSync } = await import("child_process");
-      const { join: join41, basename: basename6 } = await import("path");
+      const { join: join44, basename: basename6 } = await import("path");
       const depth = input.depth ?? 3;
       const includeGitStatus = input.include_git_status !== false;
       const includeRecentFiles = input.include_recent_files !== false;
@@ -150534,7 +152352,7 @@ function createSelfAwarenessToolExecutors(context) {
         if (currentDepth > depth)
           return [];
         try {
-          const entries = await readdir6(dir, { withFileTypes: true });
+          const entries = await readdir7(dir, { withFileTypes: true });
           const nodes = [];
           let fileCount = 0;
           for (const entry of entries) {
@@ -150545,7 +152363,7 @@ function createSelfAwarenessToolExecutors(context) {
               break;
             }
             if (entry.isDirectory()) {
-              const children = await buildTree(join41(dir, entry.name), currentDepth + 1);
+              const children = await buildTree(join44(dir, entry.name), currentDepth + 1);
               nodes.push({
                 name: entry.name,
                 type: "directory",
@@ -150571,7 +152389,7 @@ function createSelfAwarenessToolExecutors(context) {
       };
       if (includeGitStatus) {
         try {
-          await access(join41(cwd, ".git"));
+          await access(join44(cwd, ".git"));
           gitStatus.isRepo = true;
           try {
             const branch = execSync("git branch --show-current", { cwd, encoding: "utf-8" }).trim();
@@ -150598,11 +152416,11 @@ function createSelfAwarenessToolExecutors(context) {
           if (recentFiles.length >= 10)
             return;
           try {
-            const entries = await readdir6(dir, { withFileTypes: true });
+            const entries = await readdir7(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (shouldIgnore(entry.name))
                 continue;
-              const fullPath = join41(dir, entry.name);
+              const fullPath = join44(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isFile()) {
                 try {
@@ -150636,12 +152454,12 @@ function createSelfAwarenessToolExecutors(context) {
       let projectName = basename6(cwd);
       for (const indicator of projectIndicators) {
         try {
-          await access(join41(cwd, indicator.file));
+          await access(join44(cwd, indicator.file));
           projectType = indicator.type;
           if (indicator.file === "package.json") {
             try {
-              const { readFile: readFile15 } = await import("fs/promises");
-              const pkg = JSON.parse(await readFile15(join41(cwd, indicator.file), "utf-8"));
+              const { readFile: readFile16 } = await import("fs/promises");
+              const pkg = JSON.parse(await readFile16(join44(cwd, indicator.file), "utf-8"));
               projectName = pkg.name || projectName;
             } catch {}
           }
@@ -153203,8 +155021,8 @@ await __promiseAll([
   init_config(),
   init_runtime()
 ]);
-import { join as join41, dirname as dirname17 } from "path";
-import { existsSync as existsSync25, mkdirSync as mkdirSync16 } from "fs";
+import { join as join44, dirname as dirname18 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17 } from "fs";
 var MAX_KEY_LENGTH2 = 256;
 var MAX_VALUE_SIZE = 65536;
 var MAX_SUMMARY_LENGTH2 = 500;
@@ -153217,10 +155035,10 @@ class GlobalMemoryManager {
   config;
   constructor(options = {}) {
     const baseDir = getConfigDir();
-    const path2 = options.dbPath || join41(baseDir, "memory.db");
-    const dir = dirname17(path2);
-    if (!existsSync25(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    const path2 = options.dbPath || join44(baseDir, "memory.db");
+    const dir = dirname18(path2);
+    if (!existsSync27(dir)) {
+      mkdirSync17(dir, { recursive: true });
     }
     const runtime = getRuntime();
     this.db = runtime.openDatabase(path2);
@@ -154623,9 +156441,9 @@ function createCapabilityChain(scope, capabilities) {
   };
 }
 // ../core/src/capabilities/storage.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
-import { join as join42, dirname as dirname18 } from "path";
-import { homedir as homedir21 } from "os";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
+import { join as join45, dirname as dirname19 } from "path";
+import { homedir as homedir22 } from "os";
 var DEFAULT_STORAGE_CONFIG = {
   enabled: true,
   autoSave: true
@@ -154644,15 +156462,15 @@ class CapabilityStorage {
     if (this.config.storagePath) {
       return this.config.storagePath;
     }
-    const home = process.env.HOME || process.env.USERPROFILE || homedir21();
-    return join42(home, ".assistants", "capabilities", "store.json");
+    const home = process.env.HOME || process.env.USERPROFILE || homedir22();
+    return join45(home, ".assistants", "capabilities", "store.json");
   }
   load() {
     if (!this.config.enabled)
       return;
     try {
       const path2 = this.getStoragePath();
-      if (!existsSync26(path2))
+      if (!existsSync28(path2))
         return;
       const data = JSON.parse(readFileSync18(path2, "utf-8"));
       if (data.chains) {
@@ -154672,9 +156490,9 @@ class CapabilityStorage {
       return;
     try {
       const path2 = this.getStoragePath();
-      const dir = dirname18(path2);
-      if (!existsSync26(dir)) {
-        mkdirSync17(dir, { recursive: true });
+      const dir = dirname19(path2);
+      if (!existsSync28(dir)) {
+        mkdirSync18(dir, { recursive: true });
       }
       const data = {
         version: 1,
@@ -155016,6 +156834,7 @@ class AssistantLoop {
   heartbeatManager = null;
   heartbeatPersistence = null;
   heartbeatRecovery = null;
+  heartbeatRuntimeConfig = null;
   lastUserMessage = null;
   lastToolName = null;
   pendingToolCalls = new Map;
@@ -155057,6 +156876,7 @@ class AssistantLoop {
   secretsManager = null;
   jobManager = null;
   messagesManager = null;
+  webhooksManager = null;
   memoryManager = null;
   memoryInjector = null;
   contextInjector = null;
@@ -155064,6 +156884,7 @@ class AssistantLoop {
   subassistantManager = null;
   depth = 0;
   pendingMessagesContext = null;
+  pendingWebhooksContext = null;
   pendingMemoryContext = null;
   identityContext = null;
   projectContext = null;
@@ -155272,6 +157093,20 @@ class AssistantLoop {
         }
       });
     }
+    if (this.config?.webhooks?.enabled) {
+      const assistant = this.assistantManager?.getActive();
+      const assistantId = assistant?.id || this.sessionId;
+      this.webhooksManager = createWebhooksManager(assistantId, this.config.webhooks);
+      await this.webhooksManager.initialize();
+      registerWebhookTools(this.toolRegistry, () => this.webhooksManager);
+      this.webhooksManager.startWatching();
+      this.webhooksManager.onEvent((event) => {
+        const context = this.webhooksManager.buildInjectionContext([event]);
+        if (context) {
+          this.pendingWebhooksContext = context;
+        }
+      });
+    }
     const memoryConfig = this.config?.memory;
     if (memoryConfig?.enabled !== false) {
       const assistant = this.assistantManager?.getActive();
@@ -155374,6 +157209,11 @@ class AssistantLoop {
         }
       }
     });
+    registerHeartbeatTools(this.toolRegistry, {
+      sessionId: this.sessionId,
+      getHeartbeatState: () => this.getHeartbeatState(),
+      getHeartbeatConfig: () => this.heartbeatRuntimeConfig
+    });
     registerContextEntryTools(this.toolRegistry, {
       cwd: this.cwd,
       getActiveProjectId: () => this.activeProjectId,
@@ -155483,6 +157323,102 @@ class AssistantLoop {
     if (this.extraSystemPrompt) {
       this.context.addSystemMessage(this.extraSystemPrompt);
     }
+    if (this.config?.heartbeat?.enabled !== false) {
+      this.context.addSystemMessage(`## Heartbeat Basics
+- The system can trigger scheduled runs via \`/main-loop\` or \`/watchdog\`.
+- If invoked with those commands, follow the heartbeat skill instructions.
+- Heartbeat schedules use the id \`heartbeat-${this.sessionId}\`.`);
+    }
+    if (this.config?.heartbeat?.autonomous) {
+      const maxSleepMin = Math.round((this.config.heartbeat.maxSleepMs ?? 1800000) / 60000);
+      this.context.addSystemMessage(`## Autonomous Heartbeat System
+
+You are running in **autonomous mode**. You manage your own wakeup schedule.
+
+### How it works
+- After every turn, a safety-net hook ensures a heartbeat schedule exists
+- The heartbeat fires \`/main-loop\` which runs your autonomous check-in skill
+- A watchdog monitors your health and forces a wakeup if you're overdue
+
+### Your responsibilities at the END of every turn
+1. **Save state** to memory before the turn ends:
+   - \`memory_save agent.heartbeat.intention "what you plan to do next"\`
+   - \`memory_save agent.state.pending "items waiting for follow-up"\`
+   - \`memory_save agent.state.lastActions "what you just did"\`
+2. **Schedule your next heartbeat**:
+   - Delete old: \`schedule_delete heartbeat-${this.sessionId}\`
+   - Create new: \`schedule_create\` with \`kind: "once"\`, \`actionType: "message"\`, \`message: "/main-loop"\`, and \`at\` set to your chosen time
+3. **Save goals** when they change: \`memory_save agent.goals "..."\`
+
+### Timing guidelines
+| Situation | Wake up in |
+|-----------|-----------|
+| Active jobs running or tasks pending | 1\u20133 minutes |
+| Goals exist but nothing urgent | 5\u201315 minutes |
+| Nothing pending, user idle | 15\u2013${maxSleepMin} minutes (max) |
+
+### Key memory keys
+- \`agent.heartbeat.last\` \u2014 when you last ran (save ISO timestamp)
+- \`agent.heartbeat.next\` \u2014 when you plan to run next
+- \`agent.heartbeat.intention\` \u2014 why you're waking up
+- \`agent.goals\` \u2014 your active goals
+- \`agent.state.pending\` \u2014 items waiting
+- \`agent.state.lastActions\` \u2014 what you did recently
+
+### Rules
+- **Stay fast** \u2014 if work takes >30s, delegate to a subassistant
+- **Never sleep longer than ${maxSleepMin} minutes** \u2014 the system enforces this cap
+- **Always schedule your next heartbeat** \u2014 if you forget, the safety net creates a default one
+`);
+    }
+    if (this.config.heartbeat?.enabled !== false) {
+      this.context.addSystemMessage(`## Heartbeat Basics
+- The system can trigger scheduled runs via \`/main-loop\` or \`/watchdog\`.
+- If invoked with those commands, follow the heartbeat skill instructions.
+- Heartbeat schedules use the id \`heartbeat-${this.sessionId}\`.`);
+    }
+    if (this.config.heartbeat?.autonomous) {
+      const maxSleepMin = Math.round((this.config.heartbeat.maxSleepMs ?? 1800000) / 60000);
+      this.context.addSystemMessage(`## Autonomous Heartbeat System
+
+You are running in **autonomous mode**. You manage your own wakeup schedule.
+
+### How it works
+- After every turn, a safety-net hook ensures a heartbeat schedule exists
+- The heartbeat fires \`/main-loop\` which runs your autonomous check-in skill
+- A watchdog monitors your health and forces a wakeup if you're overdue
+
+### Your responsibilities at the END of every turn
+1. **Save state** to memory before the turn ends:
+   - \`memory_save agent.heartbeat.intention "what you plan to do next"\`
+   - \`memory_save agent.state.pending "items waiting for follow-up"\`
+   - \`memory_save agent.state.lastActions "what you just did"\`
+2. **Schedule your next heartbeat**:
+   - Delete old: \`schedule_delete heartbeat-${this.sessionId}\`
+   - Create new: \`schedule_create\` with \`kind: "once"\`, \`actionType: "message"\`, \`message: "/main-loop"\`, and \`at\` set to your chosen time
+3. **Save goals** when they change: \`memory_save agent.goals "..."\`
+
+### Timing guidelines
+| Situation | Wake up in |
+|-----------|-----------|
+| Active jobs running or tasks pending | 1\u20133 minutes |
+| Goals exist but nothing urgent | 5\u201315 minutes |
+| Nothing pending, user idle | 15\u2013${maxSleepMin} minutes (max) |
+
+### Key memory keys
+- \`agent.heartbeat.last\` \u2014 when you last ran (save ISO timestamp)
+- \`agent.heartbeat.next\` \u2014 when you plan to run next
+- \`agent.heartbeat.intention\` \u2014 why you're waking up
+- \`agent.goals\` \u2014 your active goals
+- \`agent.state.pending\` \u2014 items waiting
+- \`agent.state.lastActions\` \u2014 what you did recently
+
+### Rules
+- **Stay fast** \u2014 if work takes >30s, delegate to a subassistant
+- **Never sleep longer than ${maxSleepMin} minutes** \u2014 the system enforces this cap
+- **Always schedule your next heartbeat** \u2014 if you forget, the safety net creates a default one
+`);
+    }
     this.contextManager?.refreshState(this.context.getMessages());
     await this.hookExecutor.execute(this.hookLoader.getHooks("SessionStart"), {
       session_id: this.sessionId,
@@ -155500,6 +157436,7 @@ class AssistantLoop {
     this.isRunning = true;
     try {
       await this.injectPendingMessages();
+      await this.injectPendingWebhookEvents();
       await this.injectMemoryContext(userMessage);
       await this.injectContextInfo();
     } catch (error2) {
@@ -156216,6 +158153,7 @@ class AssistantLoop {
       getWalletManager: () => this.walletManager,
       getSecretsManager: () => this.secretsManager,
       getMessagesManager: () => this.messagesManager,
+      getWebhooksManager: () => this.webhooksManager,
       getMemoryManager: () => this.memoryManager,
       refreshIdentityContext: async () => {
         if (this.identityManager) {
@@ -156242,6 +158180,8 @@ class AssistantLoop {
         this.setProjectContext(content);
       },
       getVoiceState: () => this.getVoiceState(),
+      getHeartbeatState: () => this.getHeartbeatState(),
+      getHeartbeatConfig: () => this.heartbeatRuntimeConfig,
       enableVoice: () => {
         if (!this.voiceManager) {
           throw new Error("Voice support is not available.");
@@ -156452,6 +158392,7 @@ class AssistantLoop {
     this.voiceManager?.stopSpeaking();
     this.voiceManager?.stopListening();
     this.messagesManager?.stopWatching();
+    this.webhooksManager?.stopWatching();
     this.memoryManager?.close();
     this.memoryManager = null;
     this.memoryInjector = null;
@@ -156499,12 +158440,16 @@ class AssistantLoop {
     const lastActivity = this.heartbeatManager.getLastActivity();
     const age = Date.now() - lastActivity;
     const stats = this.heartbeatManager.getStats();
+    const intervalMs = this.heartbeatRuntimeConfig?.intervalMs ?? this.config?.heartbeat?.intervalMs ?? 15000;
+    const nextHeartbeatAt = this.heartbeatManager.getNextHeartbeatAt();
     return {
       enabled: true,
       state: this.heartbeatManager.getState(),
       lastActivity: new Date(lastActivity).toISOString(),
       uptimeSeconds: stats.uptimeSeconds,
-      isStale: age > staleThresholdMs
+      isStale: age > staleThresholdMs,
+      intervalMs,
+      nextHeartbeatAt: new Date(nextHeartbeatAt).toISOString()
     };
   }
   getAssistantManager() {
@@ -156516,6 +158461,9 @@ class AssistantLoop {
   getMessagesManager() {
     return this.messagesManager;
   }
+  getWebhooksManager() {
+    return this.webhooksManager;
+  }
   getWalletManager() {
     return this.walletManager;
   }
@@ -156747,7 +158695,8 @@ ${content.trim()}`);
     const heartbeatConfig = this.buildHeartbeatConfig(this.config);
     if (!heartbeatConfig)
       return;
-    const statePath = join43(getConfigDir(), "state", `${this.sessionId}.json`);
+    this.heartbeatRuntimeConfig = heartbeatConfig;
+    const statePath = join46(getConfigDir(), "state", `${this.sessionId}.json`);
     this.heartbeatManager = new HeartbeatManager(heartbeatConfig);
     this.heartbeatPersistence = new StatePersistence(statePath);
     this.heartbeatRecovery = new RecoveryManager(this.heartbeatPersistence, heartbeatConfig.persistPath, heartbeatConfig.staleThresholdMs, {
@@ -156868,7 +158817,7 @@ ${content.trim()}`);
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join43(getConfigDir(), "energy", "state.json");
+    const statePath = join46(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -156929,6 +158878,29 @@ ${effects.message}
       this.pendingMessagesContext = null;
     }
   }
+  async injectPendingWebhookEvents() {
+    if (!this.webhooksManager)
+      return;
+    try {
+      if (this.pendingWebhooksContext) {
+        const previous = this.pendingWebhooksContext.trim();
+        this.context.removeSystemMessages((content) => content.trim() === previous);
+        this.pendingWebhooksContext = null;
+      }
+      const pending = await this.webhooksManager.getPendingForInjection();
+      if (pending.length === 0) {
+        return;
+      }
+      this.pendingWebhooksContext = this.webhooksManager.buildInjectionContext(pending);
+      if (this.pendingWebhooksContext) {
+        this.context.addSystemMessage(this.pendingWebhooksContext);
+      }
+      await this.webhooksManager.markInjected(pending.map((e6) => ({ webhookId: e6.webhookId, eventId: e6.id })));
+    } catch (error2) {
+      console.error("Failed to inject pending webhook events:", error2);
+      this.pendingWebhooksContext = null;
+    }
+  }
   async injectMemoryContext(userMessage) {
     if (!this.memoryInjector || !this.memoryInjector.isEnabled())
       return;
@@ -157198,11 +159170,13 @@ ${this.identityContext}`);
       return null;
     const intervalMs = Math.max(1000, config.heartbeat?.intervalMs ?? 15000);
     const staleThresholdMs = Math.max(intervalMs * 2, config.heartbeat?.staleThresholdMs ?? 120000);
-    const persistPath = config.heartbeat?.persistPath ?? join43(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const persistPath = config.heartbeat?.persistPath ?? join46(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const historyPath = config.heartbeat?.historyPath ?? join46(getConfigDir(), "heartbeats", "runs", `${this.sessionId}.jsonl`);
     return {
       intervalMs,
       staleThresholdMs,
-      persistPath
+      persistPath,
+      historyPath
     };
   }
   async buildSummaryClient(contextConfig) {
@@ -157586,9 +159560,9 @@ class StatsTracker {
   }
 }
 // ../core/src/tools/connector-index.ts
-import { join as join44, dirname as dirname19 } from "path";
-import { homedir as homedir22 } from "os";
-import { existsSync as existsSync27, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16, readFileSync as readFileSync19 } from "fs";
+import { join as join47, dirname as dirname20 } from "path";
+import { homedir as homedir23 } from "os";
+import { existsSync as existsSync29, mkdirSync as mkdirSync19, writeFileSync as writeFileSync16, readFileSync as readFileSync19 } from "fs";
 var TAG_KEYWORDS = {
   email: ["email", "mail", "inbox", "send", "receive", "message", "compose"],
   calendar: ["calendar", "event", "meeting", "schedule", "appointment"],
@@ -157622,16 +159596,16 @@ class ConnectorIndex {
   }
   getHomeDir() {
     const envHome = process.env.HOME || process.env.USERPROFILE;
-    return envHome && envHome.trim().length > 0 ? envHome : homedir22();
+    return envHome && envHome.trim().length > 0 ? envHome : homedir23();
   }
   getCachePath() {
-    return join44(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
+    return join47(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
   }
   loadDiskCache() {
     ConnectorIndex.indexLoaded = true;
     try {
       const cachePath = this.getCachePath();
-      if (!existsSync27(cachePath))
+      if (!existsSync29(cachePath))
         return;
       const data = JSON.parse(readFileSync19(cachePath, "utf-8"));
       if (data.version !== INDEX_VERSION)
@@ -157647,9 +159621,9 @@ class ConnectorIndex {
   saveDiskCache() {
     try {
       const cachePath = this.getCachePath();
-      const cacheDir = dirname19(cachePath);
-      if (!existsSync27(cacheDir)) {
-        mkdirSync18(cacheDir, { recursive: true });
+      const cacheDir = dirname20(cachePath);
+      if (!existsSync29(cacheDir)) {
+        mkdirSync19(cacheDir, { recursive: true });
       }
       const data = {
         version: INDEX_VERSION,
@@ -158140,7 +160114,8 @@ async function runHeadless(options) {
     jsonSchema,
     continue: shouldContinue,
     resume,
-    cwdProvided
+    cwdProvided,
+    timeoutMs
   } = options;
   let sessionData = null;
   if (resume) {
@@ -158221,7 +160196,14 @@ IMPORTANT: Your response MUST be valid JSON conforming to this schema:
 ${jsonSchema}`;
   }
   try {
-    await client.send(message);
+    if (timeoutMs && timeoutMs > 0) {
+      await Promise.race([
+        client.send(message),
+        new Promise((_3, reject) => setTimeout(() => reject(new Error(`Headless run timed out after ${timeoutMs}ms`)), timeoutMs))
+      ]);
+    } else {
+      await client.send(message);
+    }
   } catch (error2) {
     hadError = true;
     errorMessage = error2 instanceof Error ? error2.message : String(error2);
@@ -158331,6 +160313,7 @@ function parseArgs(argv) {
     version: false,
     help: false,
     print: null,
+    headlessTimeoutMs: null,
     outputFormat: "text",
     allowedTools: [],
     systemPrompt: null,
@@ -158419,6 +160402,21 @@ function parseArgs(argv) {
       }
       continue;
     }
+    if (arg === "--headless-timeout" || arg === "--headless-timeout-ms") {
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push(`${arg} requires a millisecond value`);
+      } else {
+        const parsed = Number(nextArg);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+          options.errors.push(`${arg} must be a positive number of milliseconds`);
+        } else {
+          options.headlessTimeoutMs = Math.floor(parsed);
+        }
+        i5++;
+      }
+      continue;
+    }
     if (arg === "--continue" || arg === "-c") {
       options.continue = true;
       continue;