@hasna/assistants 1.1.6 → 1.1.9

package/dist/lib.js

@@ -6918,6 +6918,34 @@ function mergeConfig(base, override) {
         ...override.webhooks?.security || {}
       }
     },
+    channels: {
+      ...base.channels || {},
+      ...override.channels || {},
+      injection: {
+        ...base.channels?.injection || {},
+        ...override.channels?.injection || {}
+      },
+      storage: {
+        ...base.channels?.storage || {},
+        ...override.channels?.storage || {}
+      }
+    },
+    telephony: {
+      ...base.telephony || {},
+      ...override.telephony || {},
+      injection: {
+        ...base.telephony?.injection || {},
+        ...override.telephony?.injection || {}
+      },
+      storage: {
+        ...base.telephony?.storage || {},
+        ...override.telephony?.storage || {}
+      },
+      voice: {
+        ...base.telephony?.voice || {},
+        ...override.telephony?.voice || {}
+      }
+    },
     memory: {
       ...base.memory || {},
       ...override.memory || {},
@@ -6951,6 +6979,36 @@ function mergeConfig(base, override) {
           ...override.input?.paste?.thresholds || {}
         }
       }
+    },
+    budget: {
+      ...base.budget || {},
+      ...override.budget || {},
+      session: {
+        ...base.budget?.session || {},
+        ...override.budget?.session || {}
+      },
+      assistant: {
+        ...base.budget?.assistant || {},
+        ...override.budget?.assistant || {}
+      },
+      swarm: {
+        ...base.budget?.swarm || {},
+        ...override.budget?.swarm || {}
+      },
+      project: {
+        ...base.budget?.project || {},
+        ...override.budget?.project || {}
+      }
+    },
+    guardrails: {
+      ...base.guardrails || {},
+      ...override.guardrails || {}
+    },
+    capabilities: {
+      ...base.capabilities || {},
+      ...override.capabilities || {},
+      allowedTools: override.capabilities?.allowedTools ?? base.capabilities?.allowedTools,
+      deniedTools: override.capabilities?.deniedTools ?? base.capabilities?.deniedTools
     }
   };
 }
@@ -7274,6 +7332,33 @@ var init_config = __esm(async () => {
         rateLimitPerMinute: 60
       }
     },
+    channels: {
+      enabled: false,
+      injection: {
+        enabled: true,
+        maxPerTurn: 10
+      },
+      storage: {
+        maxMessagesPerChannel: 5000,
+        maxAgeDays: 90
+      }
+    },
+    telephony: {
+      enabled: false,
+      injection: {
+        enabled: true,
+        maxPerTurn: 5
+      },
+      storage: {
+        maxCallLogs: 1000,
+        maxSmsLogs: 5000,
+        maxAgeDays: 90
+      },
+      voice: {
+        recordCalls: false,
+        maxCallDurationSeconds: 3600
+      }
+    },
     memory: {
       enabled: true,
       injection: {
@@ -7479,6 +7564,35 @@ var init_models2 = __esm(() => {
   ];
 });
 
+// ../core/src/utils/atomic-write.ts
+import { writeFileSync as writeFileSync7, renameSync, unlinkSync as unlinkSync2 } from "fs";
+import { writeFile as writeFile3, rename, unlink as unlink3 } from "fs/promises";
+function atomicWriteFileSync(path, data) {
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync7(tmpPath, data);
+    renameSync(tmpPath, path);
+  } catch (error) {
+    try {
+      unlinkSync2(tmpPath);
+    } catch {}
+    throw error;
+  }
+}
+async function atomicWriteFile(path, data) {
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  try {
+    await writeFile3(tmpPath, data);
+    await rename(tmpPath, path);
+  } catch (error) {
+    try {
+      await unlink3(tmpPath);
+    } catch {}
+    throw error;
+  }
+}
+var init_atomic_write = () => {};
+
 // ../../node_modules/.bun/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js
 var require_array = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -12946,8 +13060,11 @@ var init_defaults = __esm(() => {
 function matchPattern(pattern, value) {
   if (pattern.startsWith("/") && pattern.endsWith("/")) {
     try {
-      const regex2 = new RegExp(pattern.slice(1, -1));
-      return regex2.test(value);
+      const regexStr = pattern.slice(1, -1);
+      if (regexStr.length > 500)
+        return false;
+      const regex2 = new RegExp(regexStr);
+      return regex2.test(value.slice(0, 1e4));
     } catch {
       return false;
     }
@@ -12967,8 +13084,13 @@ function evaluateCondition(condition, context) {
     case "input_matches": {
       const input = JSON.stringify(context.toolInput || {});
       try {
-        const regex = new RegExp(String(condition.value));
-        result = regex.test(input);
+        const regexStr = String(condition.value);
+        if (regexStr.length > 500) {
+          result = false;
+          break;
+        }
+        const regex = new RegExp(regexStr);
+        result = regex.test(input.slice(0, 1e4));
       } catch {
         result = false;
       }
@@ -13167,7 +13289,7 @@ var init_evaluator = __esm(() => {
 });
 
 // ../core/src/guardrails/store.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync9, 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) {
@@ -13219,7 +13341,7 @@ class GuardrailsStore {
       mkdirSync8(dir, { recursive: true });
     }
     ensurePolicyIds(config);
-    writeFileSync8(filePath, JSON.stringify({ guardrails: config }, null, 2), "utf-8");
+    writeFileSync9(filePath, JSON.stringify({ guardrails: config }, null, 2), "utf-8");
   }
   loadAll() {
     const userConfig = this.loadFrom("user");
@@ -51348,11 +51470,10 @@ import { homedir as homedir11 } from "os";
 import {
   existsSync as existsSync15,
   mkdirSync as mkdirSync9,
-  writeFileSync as writeFileSync9,
   readFileSync as readFileSync8,
   readdirSync as readdirSync6,
   rmSync,
-  renameSync
+  renameSync as renameSync2
 } from "fs";
 
 class SharedWorkspaceManager {
@@ -51376,7 +51497,7 @@ class SharedWorkspaceManager {
         const oldAgentsDir = join23(wsPath, "agents");
         const newAssistantsDir = join23(wsPath, "assistants");
         if (existsSync15(oldAgentsDir) && !existsSync15(newAssistantsDir)) {
-          renameSync(oldAgentsDir, newAssistantsDir);
+          renameSync2(oldAgentsDir, newAssistantsDir);
         }
       }
     } catch {}
@@ -51404,7 +51525,7 @@ class SharedWorkspaceManager {
     for (const assistantId of workspace.participants) {
       mkdirSync9(join23(wsPath, "assistants", assistantId), { recursive: true });
     }
-    writeFileSync9(this.getMetadataPath(id), JSON.stringify(workspace, null, 2));
+    atomicWriteFileSync(this.getMetadataPath(id), JSON.stringify(workspace, null, 2));
     return workspace;
   }
   join(workspaceId, assistantId) {
@@ -51415,7 +51536,7 @@ class SharedWorkspaceManager {
     if (!workspace.participants.includes(assistantId)) {
       workspace.participants.push(assistantId);
       workspace.updatedAt = Date.now();
-      writeFileSync9(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
+      atomicWriteFileSync(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
     }
     const assistantDir = join23(this.getWorkspacePath(workspaceId), "assistants", assistantId);
     if (!existsSync15(assistantDir)) {
@@ -51467,7 +51588,7 @@ class SharedWorkspaceManager {
     if (workspace) {
       workspace.status = "archived";
       workspace.updatedAt = Date.now();
-      writeFileSync9(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
+      atomicWriteFileSync(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
     }
   }
   delete(workspaceId) {
@@ -51479,6 +51600,7 @@ class SharedWorkspaceManager {
 }
 var init_shared = __esm(() => {
   init_src2();
+  init_atomic_write();
 });
 
 // ../core/src/workspace/index.ts
@@ -51534,7 +51656,7 @@ var init_defaults2 = __esm(() => {
 // ../core/src/budget/tracker.ts
 import { join as join24, dirname as dirname11 } from "path";
 import { homedir as homedir12 } from "os";
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync9 } from "fs";
 function createEmptyUsage() {
   const now2 = new Date().toISOString();
   return {
@@ -51615,7 +51737,7 @@ class BudgetTracker {
       if (!existsSync16(stateDir)) {
         mkdirSync10(stateDir, { recursive: true });
       }
-      writeFileSync10(statePath, JSON.stringify(usage, null, 2));
+      atomicWriteFileSync(statePath, JSON.stringify(usage, null, 2));
     } catch {}
   }
   saveState() {
@@ -51634,7 +51756,7 @@ class BudgetTracker {
         swarm: this.swarmUsage,
         projects: Object.fromEntries(this.projectUsages)
       };
-      writeFileSync10(statePath, JSON.stringify(state, null, 2));
+      atomicWriteFileSync(statePath, JSON.stringify(state, null, 2));
     } catch {}
   }
   isEnabled() {
@@ -51943,6 +52065,7 @@ class BudgetTracker {
 var PERSISTENCE_VERSION = 2;
 var init_tracker = __esm(() => {
   init_defaults2();
+  init_atomic_write();
 });
 
 // ../core/src/budget/tools.ts
@@ -110816,7 +110939,7 @@ await init_runtime();
 
 // ../core/src/agent/loop.ts
 init_src2();
-import { join as join46 } from "path";
+import { join as join48 } from "path";
 
 // ../core/src/agent/context.ts
 init_src2();
@@ -121524,9 +121647,10 @@ Path: ${path}`;
 init_src2();
 
 // ../core/src/scheduler/store.ts
+init_atomic_write();
 await init_config();
 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";
+import { mkdir as mkdir6, readdir as readdir2, readFile as readFile5, unlink as unlink4, 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) {
@@ -121579,7 +121703,7 @@ async function saveSchedule(cwd, schedule) {
   if (!path) {
     throw new Error(`Invalid schedule id: ${schedule.id}`);
   }
-  await writeFile3(path, JSON.stringify(schedule, null, 2), "utf-8");
+  await atomicWriteFile(path, JSON.stringify(schedule, null, 2));
 }
 async function getSchedule(cwd, id) {
   try {
@@ -121597,7 +121721,7 @@ async function deleteSchedule(cwd, id) {
     const path = schedulePath(cwd, id);
     if (!path)
       return false;
-    await unlink3(path);
+    await unlink4(path);
     return true;
   } catch {
     return false;
@@ -121676,9 +121800,12 @@ async function updateSchedule(cwd, id, updater) {
     return null;
   }
 }
-async function acquireScheduleLock(cwd, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS, allowRetry = true) {
+var MAX_LOCK_RETRIES = 2;
+async function acquireScheduleLock(cwd, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS, retryDepth = 0) {
   if (!isSafeId3(id))
     return false;
+  if (retryDepth >= MAX_LOCK_RETRIES)
+    return false;
   await ensureDirs(cwd);
   const path = lockPath(cwd, id);
   const now2 = Date.now();
@@ -121694,14 +121821,14 @@ async function acquireScheduleLock(cwd, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS
       const updatedAt = lock?.updatedAt || lock?.createdAt || 0;
       const ttl = lock?.ttlMs ?? ttlMs;
       if (now2 - updatedAt > ttl) {
-        await unlink3(path);
-        return acquireScheduleLock(cwd, id, ownerId, ttlMs, false);
+        await unlink4(path);
+        return acquireScheduleLock(cwd, id, ownerId, ttlMs, retryDepth + 1);
       }
     } catch {
-      if (allowRetry) {
+      if (retryDepth < MAX_LOCK_RETRIES) {
         try {
-          await unlink3(path);
-          return acquireScheduleLock(cwd, id, ownerId, ttlMs, false);
+          await unlink4(path);
+          return acquireScheduleLock(cwd, id, ownerId, ttlMs, retryDepth + 1);
         } catch {
           return false;
         }
@@ -121718,7 +121845,7 @@ async function releaseScheduleLock(cwd, id, ownerId) {
     const raw = await readFile5(path, "utf-8");
     const lock = JSON.parse(raw);
     if (lock?.ownerId === ownerId) {
-      await unlink3(path);
+      await unlink4(path);
     }
   } catch {}
 }
@@ -121731,7 +121858,7 @@ async function refreshScheduleLock(cwd, id, ownerId) {
     const lock = JSON.parse(raw);
     if (lock?.ownerId === ownerId) {
       const updated = { ...lock, updatedAt: Date.now() };
-      await writeFile3(path, JSON.stringify(updated, null, 2), "utf-8");
+      await atomicWriteFile(path, JSON.stringify(updated, null, 2));
     }
   } catch {}
 }
@@ -122079,7 +122206,7 @@ class SchedulerTool {
 // ../core/src/tools/image.ts
 init_src2();
 await init_runtime();
-import { existsSync as existsSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync12, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
 import { tmpdir } from "os";
 import { join as join16 } from "path";
 import { homedir as homedir8 } from "os";
@@ -122206,7 +122333,7 @@ class ImageDisplayTool {
         }
         const ext = contentType.split("/")[1]?.split(";")[0] || "png";
         tempFile = join16(tmpdir(), `assistants-image-${generateId()}.${ext}`);
-        writeFileSync7(tempFile, buffer);
+        writeFileSync8(tempFile, buffer);
         localPath = tempFile;
       } catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
@@ -122245,7 +122372,7 @@ class ImageDisplayTool {
     } finally {
       if (tempFile && existsSync12(tempFile)) {
         try {
-          unlinkSync2(tempFile);
+          unlinkSync3(tempFile);
         } catch {}
       }
     }
@@ -123492,7 +123619,7 @@ init_src2();
 // ../core/src/jobs/job-store.ts
 await init_config();
 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";
+import { mkdir as mkdir8, readdir as readdir3, readFile as readFile7, unlink as unlink5, writeFile as writeFile5 } from "fs/promises";
 var SAFE_ID_PATTERN5 = /^[a-zA-Z0-9_-]+$/;
 function jobsDir() {
   return join20(getConfigDir(), "jobs");
@@ -123535,7 +123662,7 @@ async function deleteJob(id) {
     const path = jobPath(id);
     if (!path)
       return false;
-    await unlink4(path);
+    await unlink5(path);
     return true;
   } catch {
     return false;
@@ -124181,9 +124308,15 @@ async function getTasks(cwd) {
   const data = await loadTaskStore(cwd);
   return data.tasks;
 }
-async function getTask(cwd, id) {
+async function resolveTaskId(cwd, idOrPrefix, filter) {
   const data = await loadTaskStore(cwd);
-  return data.tasks.find((t) => t.id === id) || null;
+  const candidates = filter ? data.tasks.filter(filter) : data.tasks;
+  const exact = candidates.find((t) => t.id === idOrPrefix);
+  if (exact) {
+    return { task: exact, matches: [exact] };
+  }
+  const matches = candidates.filter((t) => t.id.startsWith(idOrPrefix));
+  return { task: matches.length === 1 ? matches[0] : null, matches };
 }
 function calculateNextRunAt(recurrence, fromTime) {
   if (recurrence.endAt && fromTime >= recurrence.endAt) {
@@ -124484,7 +124617,10 @@ class BuiltinCommands {
     loader.register(this.jobsCommand());
     loader.register(this.messagesCommand());
     loader.register(this.webhooksCommand());
+    loader.register(this.channelsCommand());
+    loader.register(this.phoneCommand());
     loader.register(this.tasksCommand());
+    loader.register(this.setupCommand());
     loader.register(this.exitCommand());
   }
   voiceCommand() {
@@ -124579,10 +124715,10 @@ Usage: \`/say <text>\`
         }
         try {
           await context.speak(text);
-          context.emit("done");
         } catch (error) {
           context.emit("error", error instanceof Error ? error.message : String(error));
         }
+        context.emit("done");
         return { handled: true };
       }
     };
@@ -124626,6 +124762,7 @@ Recording audio via microphone...
           return { handled: false, prompt: transcript };
         } catch (error) {
           context.emit("error", error instanceof Error ? error.message : String(error));
+          context.emit("done");
           return { handled: true };
         }
       }
@@ -125220,7 +125357,7 @@ Usage: /identity create --template <name>
           }
           if (action === "edit") {
             context.emit("done");
-            return { handled: true, showPanel: "identity", panelInitialValue: `edit:${match.id}` };
+            return { handled: true, showPanel: "identity", panelValue: `edit:${match.id}` };
           }
           context.emit("text", `
 ## Identity Details
@@ -126282,7 +126419,7 @@ To enable:
           context.emit("done");
           return { handled: true };
         }
-        const parts = args.trim().split(/\s+/);
+        const parts = splitArgs(args.trim());
         const subcommand = parts[0]?.toLowerCase() || "";
         if (!subcommand || subcommand === "ui") {
           context.emit("done");
@@ -126614,8 +126751,14 @@ Copy these to your shell or .env file.
               context.emit("done");
               return { handled: true };
             }
-            context.emit("text", `Job ${job.id} marked for cancellation. Use job_cancel tool for full cancellation.
+            const deleted = await deleteJob(job.id);
+            if (deleted) {
+              context.emit("text", `Job ${job.id} cancelled and removed.
+`);
+            } else {
+              context.emit("text", `Failed to cancel job ${job.id}.
 `);
+            }
             context.emit("done");
             return { handled: true };
           }
@@ -126830,6 +126973,15 @@ To enable:
             return { handled: true };
           }
           try {
+            const email = await inboxManager.read(emailId);
+            if (email && email.attachments) {
+              if (index >= email.attachments.length) {
+                context.emit("text", `Invalid attachment index. Email has ${email.attachments.length} attachment(s) (0-${email.attachments.length - 1}).
+`);
+                context.emit("done");
+                return { handled: true };
+              }
+            }
             const path = await inboxManager.downloadAttachment(emailId, index);
             context.emit("text", `Downloaded to: ${path}
 `);
@@ -127485,6 +127637,477 @@ Configure the external source with the URL and secret above.
         context.emit("text", `Unknown command: ${subcommand}
 `);
         context.emit("text", `Use /webhooks help for available commands.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  channelsCommand() {
+    return {
+      name: "channels",
+      description: "Manage channels for agent collaboration",
+      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: "channels" };
+        }
+        const manager = context.getChannelsManager?.();
+        if (!manager) {
+          context.emit("text", `Channels are not enabled. Set channels.enabled: true in config.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "list") {
+          try {
+            const channels = manager.listChannels();
+            if (channels.length === 0) {
+              context.emit("text", `No channels exist. Use /channels create <name> to create one.
+`);
+            } else {
+              context.emit("text", `Channels (${channels.length}):
+
+`);
+              for (const ch of channels) {
+                const unread = ch.unreadCount > 0 ? ` (${ch.unreadCount} unread)` : "";
+                context.emit("text", `  #${ch.name}${unread}
+`);
+                if (ch.description) {
+                  context.emit("text", `    ${ch.description}
+`);
+                }
+                context.emit("text", `    Members: ${ch.memberCount} | Last: ${ch.lastMessagePreview || "no messages"}
+`);
+              }
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "create") {
+          const parts = splitArgs(subArgs);
+          const name = parts[0];
+          const description = parts.slice(1).join(" ") || undefined;
+          if (!name) {
+            context.emit("text", `Usage: /channels create <name> [description]
+`);
+            context.emit("text", `Example: /channels create general "Team discussion"
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const result = manager.createChannel(name, description);
+            if (result.success) {
+              context.emit("text", `Channel created!
+
+`);
+              context.emit("text", `  Name: #${name}
+`);
+              context.emit("text", `  ID:   ${result.channelId}
+`);
+              if (description) {
+                context.emit("text", `  Desc: ${description}
+`);
+              }
+            } 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 === "join") {
+          const channel = subArgs.trim();
+          if (!channel) {
+            context.emit("text", `Usage: /channels join <channel-name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = manager.join(channel);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "leave") {
+          const channel = subArgs.trim();
+          if (!channel) {
+            context.emit("text", `Usage: /channels leave <channel-name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = manager.leave(channel);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "send") {
+          const parts = splitArgs(subArgs);
+          const channel = parts[0];
+          const message = parts.slice(1).join(" ");
+          if (!channel || !message) {
+            context.emit("text", `Usage: /channels send <channel> <message>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = manager.send(channel, message);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "read") {
+          const parts = subArgs.trim().split(/\s+/);
+          const channel = parts[0];
+          const limit = parts[1] ? parseInt(parts[1], 10) : 20;
+          if (!channel) {
+            context.emit("text", `Usage: /channels read <channel> [limit]
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const result = manager.readMessages(channel, limit);
+            if (!result) {
+              context.emit("text", `Channel "${channel}" not found.
+`);
+            } else if (result.messages.length === 0) {
+              context.emit("text", `No messages in #${result.channel.name}.
+`);
+            } else {
+              context.emit("text", `#${result.channel.name} \u2014 Recent (${result.messages.length}):
+
+`);
+              for (const msg of result.messages) {
+                const date = new Date(msg.createdAt).toLocaleString();
+                context.emit("text", `  [${msg.senderName}] (${date})
+`);
+                context.emit("text", `  ${msg.content}
+
+`);
+              }
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "members") {
+          const channel = subArgs.trim();
+          if (!channel) {
+            context.emit("text", `Usage: /channels members <channel>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          try {
+            const ch = manager.getChannel(channel);
+            if (!ch) {
+              context.emit("text", `Channel "${channel}" not found.
+`);
+            } else {
+              const members = manager.getMembers(channel);
+              context.emit("text", `#${ch.name} Members (${members.length}):
+
+`);
+              for (const m of members) {
+                const roleTag = m.role === "owner" ? " (owner)" : "";
+                context.emit("text", `  ${m.assistantName}${roleTag}
+`);
+              }
+            }
+          } catch (error) {
+            context.emit("text", `Error: ${error instanceof Error ? error.message : String(error)}
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "invite") {
+          const parts = subArgs.trim().split(/\s+/);
+          const channel = parts[0];
+          const agent = parts[1];
+          if (!channel || !agent) {
+            context.emit("text", `Usage: /channels invite <channel> <agent-name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = manager.invite(channel, agent, agent);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "delete") {
+          const channel = subArgs.trim();
+          if (!channel) {
+            context.emit("text", `Usage: /channels delete <channel>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = manager.archiveChannel(channel);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "help") {
+          context.emit("text", `Channel Commands:
+
+`);
+          context.emit("text", `/channels                      Open channels panel
+`);
+          context.emit("text", `/channels list                 List all channels
+`);
+          context.emit("text", `/channels create <name> [desc] Create a channel
+`);
+          context.emit("text", `/channels join <channel>       Join a channel
+`);
+          context.emit("text", `/channels leave <channel>      Leave a channel
+`);
+          context.emit("text", `/channels send <ch> <msg>      Send a message
+`);
+          context.emit("text", `/channels read <ch> [limit]    Read messages
+`);
+          context.emit("text", `/channels members <ch>         List members
+`);
+          context.emit("text", `/channels invite <ch> <agent>  Invite an agent
+`);
+          context.emit("text", `/channels delete <ch>          Archive a channel
+`);
+          context.emit("text", `/channels help                 Show this help
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `Unknown command: ${subcommand}
+`);
+        context.emit("text", `Use /channels help for available commands.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  phoneCommand() {
+    return {
+      name: "phone",
+      description: "Manage telephony: SMS, calls, WhatsApp, routing",
+      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: "telephony" };
+        }
+        const manager = context.getTelephonyManager?.();
+        if (!manager) {
+          context.emit("text", `Telephony is not enabled. Set telephony.enabled: true in config.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "numbers") {
+          const numbers = manager.listPhoneNumbers();
+          if (numbers.length === 0) {
+            context.emit("text", `No phone numbers configured. Use /phone sync to import from Twilio.
+`);
+          } else {
+            context.emit("text", `Phone Numbers (${numbers.length}):
+
+`);
+            for (const num of numbers) {
+              const caps = [];
+              if (num.capabilities.voice)
+                caps.push("voice");
+              if (num.capabilities.sms)
+                caps.push("sms");
+              if (num.capabilities.whatsapp)
+                caps.push("whatsapp");
+              const name = num.friendlyName ? ` (${num.friendlyName})` : "";
+              context.emit("text", `  ${num.number}${name} [${caps.join(", ")}]
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "sync") {
+          context.emit("text", `Syncing phone numbers from Twilio...
+`);
+          const result = await manager.syncPhoneNumbers();
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "sms") {
+          const smsParts = subArgs.trim().split(/\s+/);
+          const smsAction = smsParts[0];
+          if (smsAction === "send") {
+            const to = smsParts[1];
+            const body = smsParts.slice(2).join(" ");
+            if (!to || !body) {
+              context.emit("text", `Usage: /phone sms send <to> <body>
+`);
+              context.emit("done");
+              return { handled: true };
+            }
+            const result = await manager.sendSms(to, body);
+            context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          } else if (smsAction === "list" || !smsAction) {
+            const messages = manager.getSmsHistory({ limit: 20 });
+            if (messages.length === 0) {
+              context.emit("text", `No SMS history.
+`);
+            } else {
+              context.emit("text", `Recent SMS (${messages.length}):
+
+`);
+              for (const msg of messages) {
+                const dir = msg.direction === "inbound" ? "IN" : "OUT";
+                context.emit("text", `  [${dir}] ${msg.fromNumber} \u2192 ${msg.toNumber}: ${msg.bodyPreview}
+`);
+              }
+            }
+          } else {
+            context.emit("text", `Usage: /phone sms [send <to> <body> | list]
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "call") {
+          const to = subArgs.trim();
+          if (!to) {
+            context.emit("text", `Usage: /phone call <to>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = await manager.makeCall(to);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "calls") {
+          const calls = manager.getCallHistory({ limit: 20 });
+          if (calls.length === 0) {
+            context.emit("text", `No call history.
+`);
+          } else {
+            context.emit("text", `Recent Calls (${calls.length}):
+
+`);
+            for (const call of calls) {
+              const dir = call.direction === "inbound" ? "IN" : "OUT";
+              const dur = call.duration != null ? `${call.duration}s` : "-";
+              context.emit("text", `  [${dir}] ${call.fromNumber} \u2192 ${call.toNumber} | ${call.status} | ${dur}
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "routes") {
+          const rules = manager.listRoutingRules();
+          if (rules.length === 0) {
+            context.emit("text", `No routing rules configured.
+`);
+          } else {
+            context.emit("text", `Routing Rules (${rules.length}):
+
+`);
+            for (const rule of rules) {
+              const enabled = rule.enabled ? "" : " [DISABLED]";
+              context.emit("text", `  ${rule.name} (priority: ${rule.priority})${enabled}
+`);
+              context.emit("text", `    Target: ${rule.targetAssistantName} | Type: ${rule.messageType}
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "status") {
+          const status = manager.getStatus();
+          context.emit("text", `Telephony Status:
+
+`);
+          context.emit("text", `  Enabled:       ${status.enabled ? "Yes" : "No"}
+`);
+          context.emit("text", `  Twilio:        ${status.twilioConfigured ? "Configured" : "Not configured"}
+`);
+          context.emit("text", `  ElevenLabs:    ${status.elevenLabsConfigured ? "Configured" : "Not configured"}
+`);
+          context.emit("text", `  Numbers:       ${status.phoneNumbers}
+`);
+          context.emit("text", `  Active calls:  ${status.activeCalls}
+`);
+          context.emit("text", `  Routes:        ${status.routingRules}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "help") {
+          context.emit("text", `Phone Commands:
+
+`);
+          context.emit("text", `/phone                         Open telephony panel
+`);
+          context.emit("text", `/phone numbers                 List phone numbers
+`);
+          context.emit("text", `/phone sync                    Sync numbers from Twilio
+`);
+          context.emit("text", `/phone sms send <to> <body>    Send SMS
+`);
+          context.emit("text", `/phone sms list                Recent SMS
+`);
+          context.emit("text", `/phone call <to>               Initiate call
+`);
+          context.emit("text", `/phone calls                   Recent calls
+`);
+          context.emit("text", `/phone routes                  Routing rules
+`);
+          context.emit("text", `/phone status                  Status summary
+`);
+          context.emit("text", `/phone help                    Show this help
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `Unknown command: ${subcommand}
+`);
+        context.emit("text", `Use /phone help for available commands.
 `);
         context.emit("done");
         return { handled: true };
@@ -127502,6 +128125,24 @@ Configure the external source with the URL and secret above.
       handler: async (args, context) => {
         const parts = splitArgs(args);
         const sub = parts[0] || "";
+        const formatTaskMatch = (task) => {
+          const desc = task.description.length > 60 ? `${task.description.slice(0, 60)}...` : task.description;
+          return `${task.id} - ${desc}`;
+        };
+        const emitResolveError = (id, matches, label) => {
+          if (matches.length > 1) {
+            const listed = matches.slice(0, 5).map(formatTaskMatch).join(`
+`);
+            const more = matches.length > 5 ? `
+...and ${matches.length - 5} more` : "";
+            context.emit("text", `Multiple ${label} match "${id}". Use a longer ID prefix.
+${listed}${more}
+`);
+            return;
+          }
+          context.emit("text", `${label} not found: ${id}
+`);
+        };
         if (!sub || sub === "ui") {
           context.emit("done");
           return { handled: true, showPanel: "tasks" };
@@ -127573,6 +128214,9 @@ Configure the external source with the URL and secret above.
           output += `  /tasks run               Run next pending task
 `;
           output += `  /tasks help              Show this help
+`;
+          output += `
+Note: You can use a unique ID prefix from /tasks list.
 `;
           context.emit("text", output);
           context.emit("done");
@@ -127591,16 +128235,16 @@ Configure the external source with the URL and secret above.
 **Task Queue** ${paused ? "(Paused)" : ""}
 
 `;
-          output += `| Status | Pri | Description | Created |
+          output += `| Status | Pri | ID | Description | Created |
 `;
-          output += `|--------|-----|-------------|----------|
+          output += `|--------|-----|----|-------------|----------|
 `;
           for (const task of tasks) {
             const statusIcon = task.status === "pending" ? "\u25CB" : task.status === "in_progress" ? "\u25D0" : task.status === "completed" ? "\u25CF" : "\u2717";
             const priorityIcon = task.priority === "high" ? "\u2191" : task.priority === "low" ? "\u2193" : "-";
             const desc = task.description.slice(0, 40) + (task.description.length > 40 ? "..." : "");
             const created = new Date(task.createdAt).toLocaleDateString();
-            output += `| ${statusIcon} | ${priorityIcon} | ${desc} | ${created} |
+            output += `| ${statusIcon} | ${priorityIcon} | ${task.id} | ${desc} | ${created} |
 `;
           }
           context.emit("text", output);
@@ -127642,10 +128286,9 @@ Configure the external source with the URL and secret above.
             context.emit("done");
             return { handled: true };
           }
-          const task = await getTask(context.cwd, id);
+          const { task, matches } = await resolveTaskId(context.cwd, id);
           if (!task) {
-            context.emit("text", `Task not found: ${id}
-`);
+            emitResolveError(id, matches, "Task");
             context.emit("done");
             return { handled: true };
           }
@@ -127695,12 +128338,18 @@ Configure the external source with the URL and secret above.
             context.emit("done");
             return { handled: true };
           }
-          const deleted = await deleteTask(context.cwd, id);
+          const { task, matches } = await resolveTaskId(context.cwd, id);
+          if (!task) {
+            emitResolveError(id, matches, "Task");
+            context.emit("done");
+            return { handled: true };
+          }
+          const deleted = await deleteTask(context.cwd, task.id);
           if (deleted) {
-            context.emit("text", `Task deleted: ${id}
+            context.emit("text", `Task deleted: ${task.id}
 `);
           } else {
-            context.emit("text", `Task not found: ${id}
+            context.emit("text", `Task not found: ${task.id}
 `);
           }
           context.emit("done");
@@ -127735,12 +128384,18 @@ Configure the external source with the URL and secret above.
             context.emit("done");
             return { handled: true };
           }
-          const task = await updateTask(context.cwd, id, { priority: newPriority });
+          const { task: resolved, matches } = await resolveTaskId(context.cwd, id);
+          if (!resolved) {
+            emitResolveError(id, matches, "Task");
+            context.emit("done");
+            return { handled: true };
+          }
+          const task = await updateTask(context.cwd, resolved.id, { priority: newPriority });
           if (task) {
             context.emit("text", `Task priority updated to ${newPriority}: ${task.description}
 `);
           } else {
-            context.emit("text", `Task not found: ${id}
+            context.emit("text", `Task not found: ${resolved.id}
 `);
           }
           context.emit("done");
@@ -127940,6 +128595,20 @@ Unknown workspace command. Use /workspace help for available commands.
       }
     };
   }
+  setupCommand() {
+    return {
+      name: "setup",
+      aliases: ["onboarding"],
+      description: "Run the interactive setup wizard",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (_args, context) => {
+        context.emit("done");
+        return { handled: true, showPanel: "setup" };
+      }
+    };
+  }
   exitCommand() {
     return {
       name: "exit",
@@ -128099,7 +128768,7 @@ Usage: /session assign <agent-name>
           return {
             handled: true,
             showPanel: "resume",
-            panelInitialValue: showAll ? "all" : "cwd"
+            panelValue: showAll ? "all" : "cwd"
           };
         }
         if (cleanedArgs === "list" || cleanedArgs === "--list") {
@@ -130563,7 +131232,11 @@ Switched to **${modelDef.name}** (${modelId})
           return { handled: true };
         }
         const [action, ...rest] = args.trim().split(/\s+/).filter(Boolean);
-        if (!action) {
+        if (!action || action === "ui") {
+          context.emit("done");
+          return { handled: true, showPanel: "memory" };
+        }
+        if (action === "help") {
           const stats = await manager.getStats();
           context.emit("text", `
 /memory - Persistent Memory Management
@@ -130579,6 +131252,8 @@ Switched to **${modelDef.name}** (${modelId})
 
 `);
           context.emit("text", `Commands:
+`);
+          context.emit("text", `  /memory                         Open interactive memory panel
 `);
           context.emit("text", `  /memory list [cat] [opts]     List memories (filter by category/scope/tags)
 `);
@@ -131398,7 +132073,7 @@ Note: custom heartbeat historyPath does not include {sessionId}; showing current
           return {
             handled: true,
             showPanel: "connectors",
-            panelInitialValue: argWithoutFlag || undefined
+            panelValue: argWithoutFlag || undefined
           };
         }
         const connectorName = argWithoutFlag;
@@ -131939,7 +132614,7 @@ class HeartbeatManager {
 // ../core/src/heartbeat/persistence.ts
 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";
+import { readFile as readFile10, writeFile as writeFile8, unlink as unlink6 } from "fs/promises";
 
 class StatePersistence {
   path;
@@ -131962,7 +132637,7 @@ class StatePersistence {
   }
   async clear() {
     try {
-      await unlink5(this.path);
+      await unlink6(this.path);
     } catch {}
   }
 }
@@ -132531,7 +133206,7 @@ class SystemSTT {
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join31 } from "path";
-import { readFileSync as readFileSync14, unlinkSync as unlinkSync4 } from "fs";
+import { readFileSync as readFileSync14, unlinkSync as unlinkSync5 } from "fs";
 class ElevenLabsTTS {
   apiKey;
   voiceId;
@@ -132634,7 +133309,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
+      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -132648,7 +133323,7 @@ class SystemTTS {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
       const audio = readFileSync14(output);
-      unlinkSync4(output);
+      unlinkSync5(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
         format: "aiff"
@@ -132656,7 +133331,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
+      const output = join31(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -132670,7 +133345,7 @@ class SystemTTS {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
       const audio = readFileSync14(output);
-      unlinkSync4(output);
+      unlinkSync5(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
         format: "wav"
@@ -132684,13 +133359,13 @@ class SystemTTS {
 import { spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join32 } from "path";
-import { unlink as unlink6, writeFileSync as writeFileSync13 } from "fs";
+import { unlink as unlink7, writeFileSync as writeFileSync13, appendFileSync as appendFileSync3 } from "fs";
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join32(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
+    const tempFile = join32(tmpdir3(), `assistants-audio-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
     writeFileSync13(tempFile, Buffer.from(audio));
     const player = this.resolvePlayer(format);
     if (!player) {
@@ -132702,25 +133377,51 @@ class AudioPlayer {
       this.currentProcess.on("close", () => {
         this.playing = false;
         this.currentProcess = null;
-        unlink6(tempFile, () => {});
+        unlink7(tempFile, () => {});
         resolve5();
       });
       this.currentProcess.on("error", (error2) => {
         this.playing = false;
-        this.currentProcess = null;
-        unlink6(tempFile, () => {});
+        if (this.currentProcess) {
+          this.currentProcess.kill();
+          this.currentProcess = null;
+        }
+        unlink7(tempFile, () => {});
         reject(error2);
       });
     });
   }
   async playStream(chunks, options = {}) {
-    const buffers = [];
+    const format = options.format ?? "mp3";
+    const tempFile = join32(tmpdir3(), `assistants-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
+    writeFileSync13(tempFile, Buffer.alloc(0));
     for await (const chunk of chunks) {
-      buffers.push(Buffer.from(chunk));
+      appendFileSync3(tempFile, Buffer.from(chunk));
+    }
+    const player = this.resolvePlayer(format);
+    if (!player) {
+      unlink7(tempFile, () => {});
+      throw new Error("No supported audio player found.");
     }
-    const combined = Buffer.concat(buffers);
-    const arrayBuffer = combined.buffer.slice(combined.byteOffset, combined.byteOffset + combined.byteLength);
-    await this.play(arrayBuffer, options);
+    return new Promise((resolve5, reject) => {
+      this.playing = true;
+      this.currentProcess = spawn(player.command, [...player.args, tempFile]);
+      this.currentProcess.on("close", () => {
+        this.playing = false;
+        this.currentProcess = null;
+        unlink7(tempFile, () => {});
+        resolve5();
+      });
+      this.currentProcess.on("error", (error2) => {
+        this.playing = false;
+        if (this.currentProcess) {
+          this.currentProcess.kill();
+          this.currentProcess = null;
+        }
+        unlink7(tempFile, () => {});
+        reject(error2);
+      });
+    });
   }
   stop() {
     if (this.currentProcess) {
@@ -132759,7 +133460,7 @@ class AudioPlayer {
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join33 } from "path";
-import { readFileSync as readFileSync15, unlink as unlink7 } from "fs";
+import { readFileSync as readFileSync15, unlink as unlink8 } from "fs";
 class AudioRecorder {
   currentProcess = null;
   stoppedIntentionally = false;
@@ -132794,7 +133495,7 @@ class AudioRecorder {
       });
     });
     const data = readFileSync15(output);
-    unlink7(output, () => {});
+    unlink8(output, () => {});
     this.currentOutputPath = null;
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
@@ -150087,25 +150788,2519 @@ function registerWebhookTools(registry2, getWebhooksManager) {
     registry2.register(tool, executors[tool.name]);
   }
 }
+// ../core/src/channels/store.ts
+init_src2();
+await __promiseAll([
+  init_config(),
+  init_runtime()
+]);
+import { join as join43, dirname as dirname17 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16 } from "fs";
+function generateChannelId() {
+  return `ch_${generateId().slice(0, 12)}`;
+}
+function generateMessageId2() {
+  return `cmsg_${generateId().slice(0, 12)}`;
+}
+
+class ChannelStore {
+  db;
+  constructor(dbPath) {
+    const baseDir = getConfigDir();
+    const path2 = dbPath || join43(baseDir, "channels.db");
+    const dir = dirname17(path2);
+    if (!existsSync26(dir)) {
+      mkdirSync16(dir, { recursive: true });
+    }
+    const runtime = getRuntime();
+    this.db = runtime.openDatabase(path2);
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS channels (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT,
+        created_by TEXT NOT NULL,
+        created_by_name TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS channel_members (
+        channel_id TEXT NOT NULL,
+        assistant_id TEXT NOT NULL,
+        assistant_name TEXT NOT NULL,
+        role TEXT NOT NULL DEFAULT 'member',
+        joined_at TEXT NOT NULL,
+        last_read_at TEXT,
+        PRIMARY KEY (channel_id, assistant_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS channel_messages (
+        id TEXT PRIMARY KEY,
+        channel_id TEXT NOT NULL,
+        sender_id TEXT NOT NULL,
+        sender_name TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_channel_messages_channel
+        ON channel_messages(channel_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_channel_members_assistant
+        ON channel_members(assistant_id);
+    `);
+  }
+  createChannel(name2, description, createdBy, createdByName) {
+    const normalizedName = name2.toLowerCase().replace(/^#/, "").replace(/[^a-z0-9_-]/g, "-");
+    const existing = this.getChannelByName(normalizedName);
+    if (existing) {
+      return {
+        success: false,
+        message: `Channel #${normalizedName} already exists.`
+      };
+    }
+    const id = generateChannelId();
+    const now2 = new Date().toISOString();
+    const stmt = this.db.prepare(`INSERT INTO channels (id, name, description, created_by, created_by_name, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'active', ?, ?)`);
+    stmt.run(id, normalizedName, description, createdBy, createdByName, now2, now2);
+    this.addMember(id, createdBy, createdByName, "owner");
+    return {
+      success: true,
+      message: `Channel #${normalizedName} created.`,
+      channelId: id
+    };
+  }
+  getChannel(id) {
+    const stmt = this.db.prepare("SELECT * FROM channels WHERE id = ?");
+    const row = stmt.get(id);
+    return row ? this.rowToChannel(row) : null;
+  }
+  getChannelByName(name2) {
+    const normalizedName = name2.toLowerCase().replace(/^#/, "");
+    const stmt = this.db.prepare("SELECT * FROM channels WHERE name = ?");
+    const row = stmt.get(normalizedName);
+    return row ? this.rowToChannel(row) : null;
+  }
+  resolveChannel(nameOrId) {
+    return this.getChannel(nameOrId) || this.getChannelByName(nameOrId);
+  }
+  listChannels(options) {
+    let query;
+    const params = [];
+    if (options?.assistantId) {
+      query = `
+        SELECT c.*,
+          (SELECT COUNT(*) FROM channel_members WHERE channel_id = c.id) as member_count,
+          (SELECT content FROM channel_messages WHERE channel_id = c.id ORDER BY created_at DESC LIMIT 1) as last_message_preview,
+          (SELECT created_at FROM channel_messages WHERE channel_id = c.id ORDER BY created_at DESC LIMIT 1) as last_message_at,
+          (SELECT COUNT(*) FROM channel_messages WHERE channel_id = c.id
+            AND created_at > COALESCE(
+              (SELECT last_read_at FROM channel_members WHERE channel_id = c.id AND assistant_id = ?),
+              '1970-01-01'
+            )
+          ) as unread_count
+        FROM channels c
+        INNER JOIN channel_members cm ON c.id = cm.channel_id AND cm.assistant_id = ?
+      `;
+      params.push(options.assistantId, options.assistantId);
+      if (options?.status) {
+        query += " WHERE c.status = ?";
+        params.push(options.status);
+      }
+    } else {
+      query = `
+        SELECT c.*,
+          (SELECT COUNT(*) FROM channel_members WHERE channel_id = c.id) as member_count,
+          (SELECT content FROM channel_messages WHERE channel_id = c.id ORDER BY created_at DESC LIMIT 1) as last_message_preview,
+          (SELECT created_at FROM channel_messages WHERE channel_id = c.id ORDER BY created_at DESC LIMIT 1) as last_message_at,
+          0 as unread_count
+        FROM channels c
+      `;
+      if (options?.status) {
+        query += " WHERE c.status = ?";
+        params.push(options.status);
+      }
+    }
+    query += " ORDER BY last_message_at DESC NULLS LAST, c.created_at DESC";
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      id: String(row.id),
+      name: String(row.name),
+      description: row.description ? String(row.description) : null,
+      status: String(row.status),
+      memberCount: Number(row.member_count),
+      lastMessageAt: row.last_message_at ? String(row.last_message_at) : null,
+      lastMessagePreview: row.last_message_preview ? String(row.last_message_preview).slice(0, 100) : null,
+      unreadCount: Number(row.unread_count),
+      createdAt: String(row.created_at)
+    }));
+  }
+  archiveChannel(id) {
+    const now2 = new Date().toISOString();
+    const stmt = this.db.prepare("UPDATE channels SET status = ?, updated_at = ? WHERE id = ? AND status = ?");
+    const result = stmt.run("archived", now2, id, "active");
+    return result.changes > 0;
+  }
+  addMember(channelId, assistantId, assistantName, role = "member") {
+    try {
+      const now2 = new Date().toISOString();
+      const stmt = this.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, assistant_id, assistant_name, role, joined_at)
+         VALUES (?, ?, ?, ?, ?)`);
+      const result = stmt.run(channelId, assistantId, assistantName, role, now2);
+      return result.changes > 0;
+    } catch {
+      return false;
+    }
+  }
+  removeMember(channelId, assistantId) {
+    const stmt = this.db.prepare("DELETE FROM channel_members WHERE channel_id = ? AND assistant_id = ?");
+    const result = stmt.run(channelId, assistantId);
+    return result.changes > 0;
+  }
+  getMembers(channelId) {
+    const stmt = this.db.prepare("SELECT * FROM channel_members WHERE channel_id = ? ORDER BY joined_at ASC");
+    const rows = stmt.all(channelId);
+    return rows.map((row) => this.rowToMember(row));
+  }
+  isMember(channelId, assistantId) {
+    const stmt = this.db.prepare("SELECT 1 FROM channel_members WHERE channel_id = ? AND assistant_id = ?");
+    const row = stmt.get(channelId, assistantId);
+    return !!row;
+  }
+  sendMessage(channelId, senderId, senderName, content) {
+    const id = generateMessageId2();
+    const now2 = new Date().toISOString();
+    const stmt = this.db.prepare(`INSERT INTO channel_messages (id, channel_id, sender_id, sender_name, content, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+    stmt.run(id, channelId, senderId, senderName, content, now2);
+    this.db.prepare("UPDATE channels SET updated_at = ? WHERE id = ?").run(now2, channelId);
+    this.db.prepare("UPDATE channel_members SET last_read_at = ? WHERE channel_id = ? AND assistant_id = ?").run(now2, channelId, senderId);
+    return id;
+  }
+  getMessages(channelId, options) {
+    const limit2 = options?.limit || 50;
+    let query = "SELECT * FROM channel_messages WHERE channel_id = ?";
+    const params = [channelId];
+    if (options?.before) {
+      query += " AND created_at < ?";
+      params.push(options.before);
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit2);
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToMessage(row)).reverse();
+  }
+  getUnreadMessages(channelId, assistantId) {
+    const stmt = this.db.prepare(`
+      SELECT m.* FROM channel_messages m
+      INNER JOIN channel_members cm ON cm.channel_id = m.channel_id AND cm.assistant_id = ?
+      WHERE m.channel_id = ?
+        AND m.created_at > COALESCE(cm.last_read_at, '1970-01-01')
+        AND m.sender_id != ?
+      ORDER BY m.created_at ASC
+    `);
+    const rows = stmt.all(assistantId, channelId, assistantId);
+    return rows.map((row) => this.rowToMessage(row));
+  }
+  getAllUnreadMessages(assistantId, maxTotal) {
+    const limit2 = maxTotal || 50;
+    const stmt = this.db.prepare(`
+      SELECT m.* FROM channel_messages m
+      INNER JOIN channel_members cm ON cm.channel_id = m.channel_id AND cm.assistant_id = ?
+      WHERE m.created_at > COALESCE(cm.last_read_at, '1970-01-01')
+        AND m.sender_id != ?
+      ORDER BY m.created_at ASC
+      LIMIT ?
+    `);
+    const rows = stmt.all(assistantId, assistantId, limit2);
+    return rows.map((row) => this.rowToMessage(row));
+  }
+  markRead(channelId, assistantId) {
+    const now2 = new Date().toISOString();
+    this.db.prepare("UPDATE channel_members SET last_read_at = ? WHERE channel_id = ? AND assistant_id = ?").run(now2, channelId, assistantId);
+  }
+  getUnreadCounts(assistantId) {
+    const stmt = this.db.prepare(`
+      SELECT cm.channel_id, COUNT(m.id) as unread_count
+      FROM channel_members cm
+      LEFT JOIN channel_messages m ON m.channel_id = cm.channel_id
+        AND m.created_at > COALESCE(cm.last_read_at, '1970-01-01')
+        AND m.sender_id != ?
+      WHERE cm.assistant_id = ?
+      GROUP BY cm.channel_id
+    `);
+    const rows = stmt.all(assistantId, assistantId);
+    const counts = new Map;
+    for (const row of rows) {
+      counts.set(String(row.channel_id), Number(row.unread_count));
+    }
+    return counts;
+  }
+  cleanup(maxAgeDays, maxMessagesPerChannel) {
+    let deleted = 0;
+    const cutoff = new Date;
+    cutoff.setDate(cutoff.getDate() - maxAgeDays);
+    const cutoffStr = cutoff.toISOString();
+    const ageResult = this.db.prepare("DELETE FROM channel_messages WHERE created_at < ?").run(cutoffStr);
+    deleted += ageResult.changes;
+    const channels = this.db.prepare("SELECT id FROM channels").all();
+    for (const ch2 of channels) {
+      const channelId = String(ch2.id);
+      const countResult = this.db.prepare("SELECT COUNT(*) as cnt FROM channel_messages WHERE channel_id = ?").get(channelId);
+      const count = Number(countResult.cnt);
+      if (count > maxMessagesPerChannel) {
+        const excess = count - maxMessagesPerChannel;
+        const trimResult = this.db.prepare(`
+          DELETE FROM channel_messages WHERE id IN (
+            SELECT id FROM channel_messages WHERE channel_id = ?
+            ORDER BY created_at ASC LIMIT ?
+          )
+        `).run(channelId, excess);
+        deleted += trimResult.changes;
+      }
+    }
+    return deleted;
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {}
+  }
+  rowToChannel(row) {
+    return {
+      id: String(row.id),
+      name: String(row.name),
+      description: row.description ? String(row.description) : null,
+      createdBy: String(row.created_by),
+      createdByName: String(row.created_by_name),
+      status: String(row.status),
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+  rowToMember(row) {
+    return {
+      channelId: String(row.channel_id),
+      assistantId: String(row.assistant_id),
+      assistantName: String(row.assistant_name),
+      role: String(row.role),
+      joinedAt: String(row.joined_at),
+      lastReadAt: row.last_read_at ? String(row.last_read_at) : null
+    };
+  }
+  rowToMessage(row) {
+    return {
+      id: String(row.id),
+      channelId: String(row.channel_id),
+      senderId: String(row.sender_id),
+      senderName: String(row.sender_name),
+      content: String(row.content),
+      createdAt: String(row.created_at)
+    };
+  }
+}
+
+// ../core/src/channels/manager.ts
+class ChannelsManager {
+  assistantId;
+  assistantName;
+  config;
+  store;
+  constructor(options) {
+    this.assistantId = options.assistantId;
+    this.assistantName = options.assistantName;
+    this.config = options.config;
+    this.store = new ChannelStore;
+  }
+  createChannel(name2, description) {
+    return this.store.createChannel(name2, description || null, this.assistantId, this.assistantName);
+  }
+  listChannels() {
+    return this.store.listChannels({ status: "active" });
+  }
+  listMyChannels() {
+    return this.store.listChannels({
+      status: "active",
+      assistantId: this.assistantId
+    });
+  }
+  getChannel(nameOrId) {
+    return this.store.resolveChannel(nameOrId);
+  }
+  archiveChannel(nameOrId) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    const success = this.store.archiveChannel(channel.id);
+    if (success) {
+      return { success: true, message: `Channel #${channel.name} archived.`, channelId: channel.id };
+    }
+    return { success: false, message: `Failed to archive #${channel.name}. It may already be archived.` };
+  }
+  join(nameOrId) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    if (channel.status !== "active") {
+      return { success: false, message: `Channel #${channel.name} is archived.` };
+    }
+    if (this.store.isMember(channel.id, this.assistantId)) {
+      return { success: false, message: `Already a member of #${channel.name}.` };
+    }
+    this.store.addMember(channel.id, this.assistantId, this.assistantName);
+    return { success: true, message: `Joined #${channel.name}.`, channelId: channel.id };
+  }
+  leave(nameOrId) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    if (!this.store.isMember(channel.id, this.assistantId)) {
+      return { success: false, message: `Not a member of #${channel.name}.` };
+    }
+    this.store.removeMember(channel.id, this.assistantId);
+    return { success: true, message: `Left #${channel.name}.`, channelId: channel.id };
+  }
+  invite(nameOrId, targetId, targetName) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    if (channel.status !== "active") {
+      return { success: false, message: `Channel #${channel.name} is archived.` };
+    }
+    if (this.store.isMember(channel.id, targetId)) {
+      return { success: false, message: `${targetName} is already a member of #${channel.name}.` };
+    }
+    this.store.addMember(channel.id, targetId, targetName);
+    return {
+      success: true,
+      message: `Invited ${targetName} to #${channel.name}.`,
+      channelId: channel.id
+    };
+  }
+  getMembers(nameOrId) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel)
+      return [];
+    return this.store.getMembers(channel.id);
+  }
+  send(nameOrId, content) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    if (channel.status !== "active") {
+      return { success: false, message: `Channel #${channel.name} is archived.` };
+    }
+    if (!this.store.isMember(channel.id, this.assistantId)) {
+      return { success: false, message: `You are not a member of #${channel.name}. Join first.` };
+    }
+    const messageId = this.store.sendMessage(channel.id, this.assistantId, this.assistantName, content);
+    return {
+      success: true,
+      message: `Message sent to #${channel.name} (${messageId}).`,
+      channelId: channel.id
+    };
+  }
+  readMessages(nameOrId, limit2) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel)
+      return null;
+    const messages = this.store.getMessages(channel.id, { limit: limit2 });
+    this.store.markRead(channel.id, this.assistantId);
+    return { channel, messages };
+  }
+  markRead(nameOrId) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (channel) {
+      this.store.markRead(channel.id, this.assistantId);
+    }
+  }
+  getUnreadForInjection() {
+    const injectionConfig = this.config.injection || {};
+    if (injectionConfig.enabled === false) {
+      return [];
+    }
+    const maxPerTurn = injectionConfig.maxPerTurn || 10;
+    return this.store.getAllUnreadMessages(this.assistantId, maxPerTurn);
+  }
+  buildInjectionContext(messages) {
+    if (messages.length === 0) {
+      return "";
+    }
+    const byChannel = new Map;
+    for (const msg of messages) {
+      const existing = byChannel.get(msg.channelId) || [];
+      existing.push(msg);
+      byChannel.set(msg.channelId, existing);
+    }
+    const lines = [];
+    lines.push("## Unread Channel Messages");
+    lines.push("");
+    for (const [channelId, channelMessages] of byChannel) {
+      const channel = this.store.getChannel(channelId);
+      const channelName = channel ? `#${channel.name}` : channelId;
+      lines.push(`### ${channelName} (${channelMessages.length} new)`);
+      for (const msg of channelMessages) {
+        const ago = formatTimeAgo(msg.createdAt);
+        lines.push(`**${msg.senderName}** (${ago}): ${msg.content}`);
+      }
+      lines.push("");
+    }
+    lines.push("Use channel_read for history, channel_send to reply.");
+    return lines.join(`
+`);
+  }
+  markInjected(messages) {
+    const channelIds = new Set(messages.map((m5) => m5.channelId));
+    for (const channelId of channelIds) {
+      this.store.markRead(channelId, this.assistantId);
+    }
+  }
+  cleanup() {
+    const maxAgeDays = this.config.storage?.maxAgeDays || 90;
+    const maxMessages = this.config.storage?.maxMessagesPerChannel || 5000;
+    return this.store.cleanup(maxAgeDays, maxMessages);
+  }
+  close() {
+    this.store.close();
+  }
+}
+function formatTimeAgo(isoDate) {
+  const now2 = Date.now();
+  const then = new Date(isoDate).getTime();
+  const diffMs = now2 - then;
+  if (diffMs < 60000) {
+    const secs = Math.floor(diffMs / 1000);
+    return `${secs}s ago`;
+  }
+  if (diffMs < 3600000) {
+    const mins = Math.floor(diffMs / 60000);
+    return `${mins}m ago`;
+  }
+  if (diffMs < 86400000) {
+    const hours = Math.floor(diffMs / 3600000);
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(diffMs / 86400000);
+  return `${days}d ago`;
+}
+function createChannelsManager(assistantId, assistantName, config) {
+  return new ChannelsManager({
+    assistantId,
+    assistantName,
+    config
+  });
+}
+// ../core/src/channels/tools.ts
+var channelListTool = {
+  name: "channel_list",
+  description: "List channels. By default shows only channels you are a member of. Set mine_only to false to see all channels.",
+  parameters: {
+    type: "object",
+    properties: {
+      mine_only: {
+        type: "boolean",
+        description: "Only list channels you are a member of (default: true)"
+      }
+    },
+    required: []
+  }
+};
+var channelJoinTool = {
+  name: "channel_join",
+  description: "Join a channel by name or ID to start receiving messages.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: 'Channel name (e.g., "general" or "#general") or channel ID'
+      }
+    },
+    required: ["channel"]
+  }
+};
+var channelLeaveTool = {
+  name: "channel_leave",
+  description: "Leave a channel. You will stop receiving messages from it.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: "Channel name or ID"
+      }
+    },
+    required: ["channel"]
+  }
+};
+var channelSendTool = {
+  name: "channel_send",
+  description: "Send a message to a channel. You must be a member of the channel.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: "Channel name or ID"
+      },
+      message: {
+        type: "string",
+        description: "Message content to send"
+      }
+    },
+    required: ["channel", "message"]
+  }
+};
+var channelReadTool = {
+  name: "channel_read",
+  description: "Read recent messages from a channel. Also marks the channel as read.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: "Channel name or ID"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of messages to return (default: 20)"
+      }
+    },
+    required: ["channel"]
+  }
+};
+var channelMembersTool = {
+  name: "channel_members",
+  description: "List all members of a channel with their roles.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: "Channel name or ID"
+      }
+    },
+    required: ["channel"]
+  }
+};
+var channelInviteTool = {
+  name: "channel_invite",
+  description: "Invite another assistant to join a channel.",
+  parameters: {
+    type: "object",
+    properties: {
+      channel: {
+        type: "string",
+        description: "Channel name or ID"
+      },
+      assistant: {
+        type: "string",
+        description: "Assistant name or ID to invite"
+      }
+    },
+    required: ["channel", "assistant"]
+  }
+};
+function createChannelToolExecutors(getChannelsManager) {
+  return {
+    channel_list: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured. Set channels.enabled: true in config.";
+      }
+      const mineOnly = input.mine_only !== false;
+      try {
+        const channels = mineOnly ? manager.listMyChannels() : manager.listChannels();
+        if (channels.length === 0) {
+          return mineOnly ? "You are not a member of any channels. Use channel_list with mine_only: false to see all, or channel_join to join one." : "No channels exist yet.";
+        }
+        const lines = [];
+        const label = mineOnly ? "My Channels" : "All Channels";
+        lines.push(`## ${label} (${channels.length})`);
+        lines.push("");
+        for (const ch2 of channels) {
+          const unread = ch2.unreadCount > 0 ? ` (${ch2.unreadCount} unread)` : "";
+          const lastMsg = ch2.lastMessagePreview ? `Last: ${ch2.lastMessagePreview}` : "No messages yet";
+          lines.push(`**#${ch2.name}**${unread}`);
+          if (ch2.description) {
+            lines.push(`  ${ch2.description}`);
+          }
+          lines.push(`  Members: ${ch2.memberCount} | ${lastMsg}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error listing channels: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    channel_join: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      if (!channel) {
+        return "Error: Channel name or ID is required.";
+      }
+      const result = manager.join(channel);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    channel_leave: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      if (!channel) {
+        return "Error: Channel name or ID is required.";
+      }
+      const result = manager.leave(channel);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    channel_send: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      const message = String(input.message || "").trim();
+      if (!channel)
+        return "Error: Channel name or ID is required.";
+      if (!message)
+        return "Error: Message content is required.";
+      const result = manager.send(channel, message);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    channel_read: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      if (!channel)
+        return "Error: Channel name or ID is required.";
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      try {
+        const result = manager.readMessages(channel, limit2);
+        if (!result) {
+          return `Channel "${channel}" not found.`;
+        }
+        const { channel: ch2, messages } = result;
+        if (messages.length === 0) {
+          return `No messages in #${ch2.name}.`;
+        }
+        const lines = [];
+        lines.push(`## #${ch2.name} \u2014 Recent Messages (${messages.length})`);
+        lines.push("");
+        for (const msg of messages) {
+          const date = new Date(msg.createdAt).toLocaleString();
+          lines.push(`**${msg.senderName}** (${date}):`);
+          lines.push(msg.content);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error reading messages: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    channel_members: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      if (!channel)
+        return "Error: Channel name or ID is required.";
+      try {
+        const ch2 = manager.getChannel(channel);
+        if (!ch2) {
+          return `Channel "${channel}" not found.`;
+        }
+        const members = manager.getMembers(channel);
+        if (members.length === 0) {
+          return `No members in #${ch2.name}.`;
+        }
+        const lines = [];
+        lines.push(`## #${ch2.name} Members (${members.length})`);
+        lines.push("");
+        for (const member of members) {
+          const roleTag = member.role === "owner" ? " (owner)" : "";
+          const joined = new Date(member.joinedAt).toLocaleDateString();
+          lines.push(`- **${member.assistantName}**${roleTag} \u2014 joined ${joined}`);
+        }
+        return lines.join(`
+`);
+      } catch (error2) {
+        return `Error listing members: ${error2 instanceof Error ? error2.message : String(error2)}`;
+      }
+    },
+    channel_invite: async (input) => {
+      const manager = getChannelsManager();
+      if (!manager) {
+        return "Error: Channels are not enabled or configured.";
+      }
+      const channel = String(input.channel || "").trim();
+      const assistant = String(input.assistant || "").trim();
+      if (!channel)
+        return "Error: Channel name or ID is required.";
+      if (!assistant)
+        return "Error: Assistant name or ID is required.";
+      const result = manager.invite(channel, assistant, assistant);
+      return result.success ? result.message : `Error: ${result.message}`;
+    }
+  };
+}
+var channelTools = [
+  channelListTool,
+  channelJoinTool,
+  channelLeaveTool,
+  channelSendTool,
+  channelReadTool,
+  channelMembersTool,
+  channelInviteTool
+];
+function registerChannelTools(registry2, getChannelsManager) {
+  const executors = createChannelToolExecutors(getChannelsManager);
+  for (const tool of channelTools) {
+    registry2.register(tool, executors[tool.name]);
+  }
+}
+// ../core/src/telephony/store.ts
+init_src2();
+await __promiseAll([
+  init_config(),
+  init_runtime()
+]);
+import { join as join44, dirname as dirname18 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17 } from "fs";
+function generatePhoneId() {
+  return `ph_${generateId().slice(0, 12)}`;
+}
+function generateCallId() {
+  return `call_${generateId().slice(0, 12)}`;
+}
+function generateSmsId() {
+  return `sms_${generateId().slice(0, 12)}`;
+}
+function generateRuleId() {
+  return `rule_${generateId().slice(0, 12)}`;
+}
+
+class TelephonyStore {
+  db;
+  constructor(dbPath) {
+    const baseDir = getConfigDir();
+    const path2 = dbPath || join44(baseDir, "telephony.db");
+    const dir = dirname18(path2);
+    if (!existsSync27(dir)) {
+      mkdirSync17(dir, { recursive: true });
+    }
+    const runtime = getRuntime();
+    this.db = runtime.openDatabase(path2);
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS phone_numbers (
+        id TEXT PRIMARY KEY,
+        number TEXT NOT NULL UNIQUE,
+        friendly_name TEXT,
+        twilio_sid TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        voice_capable INTEGER NOT NULL DEFAULT 1,
+        sms_capable INTEGER NOT NULL DEFAULT 1,
+        whatsapp_capable INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS call_logs (
+        id TEXT PRIMARY KEY,
+        call_sid TEXT,
+        from_number TEXT NOT NULL,
+        to_number TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        assistant_id TEXT,
+        duration INTEGER,
+        recording_url TEXT,
+        started_at TEXT,
+        ended_at TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sms_logs (
+        id TEXT PRIMARY KEY,
+        message_sid TEXT,
+        from_number TEXT NOT NULL,
+        to_number TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        message_type TEXT NOT NULL DEFAULT 'sms',
+        body TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'queued',
+        assistant_id TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS routing_rules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        priority INTEGER NOT NULL DEFAULT 100,
+        from_pattern TEXT,
+        to_pattern TEXT,
+        message_type TEXT NOT NULL DEFAULT 'all',
+        time_of_day TEXT,
+        day_of_week TEXT,
+        keyword TEXT,
+        target_assistant_id TEXT NOT NULL,
+        target_assistant_name TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_call_logs_assistant ON call_logs(assistant_id);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_status ON call_logs(status);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_created ON call_logs(created_at);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_sid ON call_logs(call_sid);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_assistant ON sms_logs(assistant_id);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_created ON sms_logs(created_at);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_sid ON sms_logs(message_sid);
+      CREATE INDEX IF NOT EXISTS idx_routing_rules_priority ON routing_rules(priority, enabled);
+    `);
+  }
+  addPhoneNumber(number, friendlyName, twilioSid, capabilities) {
+    const id = generatePhoneId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO phone_numbers (id, number, friendly_name, twilio_sid, voice_capable, sms_capable, whatsapp_capable, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, number, friendlyName, twilioSid, capabilities?.voice !== false ? 1 : 0, capabilities?.sms !== false ? 1 : 0, capabilities?.whatsapp ? 1 : 0, now2, now2);
+    return this.getPhoneNumber(id);
+  }
+  getPhoneNumber(id) {
+    const row = this.db.prepare("SELECT * FROM phone_numbers WHERE id = ?").get(id);
+    return row ? this.rowToPhoneNumber(row) : null;
+  }
+  getPhoneNumberByNumber(number) {
+    const row = this.db.prepare("SELECT * FROM phone_numbers WHERE number = ?").get(number);
+    return row ? this.rowToPhoneNumber(row) : null;
+  }
+  listPhoneNumbers(status) {
+    let query = "SELECT * FROM phone_numbers";
+    const params = [];
+    if (status) {
+      query += " WHERE status = ?";
+      params.push(status);
+    }
+    query += " ORDER BY created_at DESC";
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((r6) => this.rowToPhoneNumber(r6));
+  }
+  updatePhoneNumberStatus(id, status) {
+    const now2 = new Date().toISOString();
+    const result = this.db.prepare("UPDATE phone_numbers SET status = ?, updated_at = ? WHERE id = ?").run(status, now2, id);
+    return result.changes > 0;
+  }
+  deletePhoneNumber(id) {
+    const result = this.db.prepare("DELETE FROM phone_numbers WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  createCallLog(params) {
+    const id = generateCallId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO call_logs (id, call_sid, from_number, to_number, direction, status, assistant_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.callSid || null, params.fromNumber, params.toNumber, params.direction, params.status || "pending", params.assistantId || null, now2);
+    return this.getCallLog(id);
+  }
+  getCallLog(id) {
+    const row = this.db.prepare("SELECT * FROM call_logs WHERE id = ?").get(id);
+    return row ? this.rowToCallLog(row) : null;
+  }
+  getCallLogBySid(callSid) {
+    const row = this.db.prepare("SELECT * FROM call_logs WHERE call_sid = ?").get(callSid);
+    return row ? this.rowToCallLog(row) : null;
+  }
+  updateCallLog(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.status !== undefined) {
+      sets.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.callSid !== undefined) {
+      sets.push("call_sid = ?");
+      params.push(updates.callSid);
+    }
+    if (updates.duration !== undefined) {
+      sets.push("duration = ?");
+      params.push(updates.duration);
+    }
+    if (updates.recordingUrl !== undefined) {
+      sets.push("recording_url = ?");
+      params.push(updates.recordingUrl);
+    }
+    if (updates.startedAt !== undefined) {
+      sets.push("started_at = ?");
+      params.push(updates.startedAt);
+    }
+    if (updates.endedAt !== undefined) {
+      sets.push("ended_at = ?");
+      params.push(updates.endedAt);
+    }
+    if (sets.length === 0)
+      return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE call_logs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  listCallLogs(options) {
+    const conditions = [];
+    const params = [];
+    const limit2 = options?.limit || 50;
+    if (options?.assistantId) {
+      conditions.push("assistant_id = ?");
+      params.push(options.assistantId);
+    }
+    if (options?.direction) {
+      conditions.push("direction = ?");
+      params.push(options.direction);
+    }
+    if (options?.status) {
+      conditions.push("status = ?");
+      params.push(options.status);
+    }
+    let query = "SELECT * FROM call_logs";
+    if (conditions.length > 0) {
+      query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit2);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => ({
+      id: String(row.id),
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      status: String(row.status),
+      duration: row.duration != null ? Number(row.duration) : null,
+      startedAt: row.started_at ? String(row.started_at) : null,
+      createdAt: String(row.created_at)
+    }));
+  }
+  createSmsLog(params) {
+    const id = generateSmsId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO sms_logs (id, message_sid, from_number, to_number, direction, message_type, body, status, assistant_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.messageSid || null, params.fromNumber, params.toNumber, params.direction, params.messageType || "sms", params.body, params.status || "queued", params.assistantId || null, now2);
+    return this.getSmsLog(id);
+  }
+  getSmsLog(id) {
+    const row = this.db.prepare("SELECT * FROM sms_logs WHERE id = ?").get(id);
+    return row ? this.rowToSmsLog(row) : null;
+  }
+  updateSmsStatus(id, status) {
+    const result = this.db.prepare("UPDATE sms_logs SET status = ? WHERE id = ?").run(status, id);
+    return result.changes > 0;
+  }
+  listSmsLogs(options) {
+    const conditions = [];
+    const params = [];
+    const limit2 = options?.limit || 50;
+    if (options?.assistantId) {
+      conditions.push("assistant_id = ?");
+      params.push(options.assistantId);
+    }
+    if (options?.direction) {
+      conditions.push("direction = ?");
+      params.push(options.direction);
+    }
+    if (options?.messageType) {
+      conditions.push("message_type = ?");
+      params.push(options.messageType);
+    }
+    let query = "SELECT * FROM sms_logs";
+    if (conditions.length > 0) {
+      query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit2);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => ({
+      id: String(row.id),
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      messageType: String(row.message_type),
+      bodyPreview: String(row.body).slice(0, 100),
+      status: String(row.status),
+      createdAt: String(row.created_at)
+    }));
+  }
+  getUnreadInboundSms(assistantId, limit2) {
+    const maxLimit = limit2 || 50;
+    const rows = this.db.prepare(`SELECT * FROM sms_logs
+       WHERE direction = 'inbound' AND assistant_id = ? AND status = 'received'
+       ORDER BY created_at ASC LIMIT ?`).all(assistantId, maxLimit);
+    return rows.map((r6) => this.rowToSmsLog(r6));
+  }
+  createRoutingRule(params) {
+    const id = generateRuleId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO routing_rules (id, name, priority, from_pattern, to_pattern, message_type, time_of_day, day_of_week, keyword, target_assistant_id, target_assistant_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.name, params.priority ?? 100, params.fromPattern || null, params.toPattern || null, params.messageType || "all", params.timeOfDay || null, params.dayOfWeek || null, params.keyword || null, params.targetAssistantId, params.targetAssistantName, now2, now2);
+    return this.getRoutingRule(id);
+  }
+  getRoutingRule(id) {
+    const row = this.db.prepare("SELECT * FROM routing_rules WHERE id = ?").get(id);
+    return row ? this.rowToRoutingRule(row) : null;
+  }
+  listRoutingRules() {
+    const rows = this.db.prepare("SELECT * FROM routing_rules ORDER BY priority ASC, created_at ASC").all();
+    return rows.map((r6) => this.rowToRoutingRule(r6));
+  }
+  updateRoutingRule(id, updates) {
+    const sets = [];
+    const params = [];
+    const now2 = new Date().toISOString();
+    if (updates.name !== undefined) {
+      sets.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.priority !== undefined) {
+      sets.push("priority = ?");
+      params.push(updates.priority);
+    }
+    if (updates.enabled !== undefined) {
+      sets.push("enabled = ?");
+      params.push(updates.enabled ? 1 : 0);
+    }
+    sets.push("updated_at = ?");
+    params.push(now2);
+    if (sets.length === 1)
+      return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE routing_rules SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  deleteRoutingRule(id) {
+    const result = this.db.prepare("DELETE FROM routing_rules WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  resolveRouting(params) {
+    const rules = this.db.prepare(`SELECT * FROM routing_rules WHERE enabled = 1 ORDER BY priority ASC`).all();
+    for (const row of rules) {
+      const rule = this.rowToRoutingRule(row);
+      if (rule.messageType !== "all" && rule.messageType !== params.messageType)
+        continue;
+      if (rule.fromPattern && !matchPattern2(rule.fromPattern, params.fromNumber))
+        continue;
+      if (rule.toPattern && !matchPattern2(rule.toPattern, params.toNumber))
+        continue;
+      if (rule.keyword && params.body) {
+        if (!params.body.toLowerCase().includes(rule.keyword.toLowerCase()))
+          continue;
+      } else if (rule.keyword && !params.body) {
+        continue;
+      }
+      if (rule.timeOfDay && !matchTimeOfDay(rule.timeOfDay))
+        continue;
+      if (rule.dayOfWeek && !matchDayOfWeek(rule.dayOfWeek))
+        continue;
+      return {
+        assistantId: rule.targetAssistantId,
+        assistantName: rule.targetAssistantName,
+        ruleId: rule.id
+      };
+    }
+    return null;
+  }
+  cleanup(maxAgeDays, maxCallLogs, maxSmsLogs) {
+    let deleted = 0;
+    const cutoff = new Date;
+    cutoff.setDate(cutoff.getDate() - maxAgeDays);
+    const cutoffStr = cutoff.toISOString();
+    const callResult = this.db.prepare("DELETE FROM call_logs WHERE created_at < ?").run(cutoffStr);
+    deleted += callResult.changes;
+    const smsResult = this.db.prepare("DELETE FROM sms_logs WHERE created_at < ?").run(cutoffStr);
+    deleted += smsResult.changes;
+    const callCount = this.db.prepare("SELECT COUNT(*) as cnt FROM call_logs").get();
+    if (Number(callCount.cnt) > maxCallLogs) {
+      const excess = Number(callCount.cnt) - maxCallLogs;
+      const trimResult = this.db.prepare(`DELETE FROM call_logs WHERE id IN (
+          SELECT id FROM call_logs ORDER BY created_at ASC LIMIT ?
+        )`).run(excess);
+      deleted += trimResult.changes;
+    }
+    const smsCount = this.db.prepare("SELECT COUNT(*) as cnt FROM sms_logs").get();
+    if (Number(smsCount.cnt) > maxSmsLogs) {
+      const excess = Number(smsCount.cnt) - maxSmsLogs;
+      const trimResult = this.db.prepare(`DELETE FROM sms_logs WHERE id IN (
+          SELECT id FROM sms_logs ORDER BY created_at ASC LIMIT ?
+        )`).run(excess);
+      deleted += trimResult.changes;
+    }
+    return deleted;
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {}
+  }
+  rowToPhoneNumber(row) {
+    return {
+      id: String(row.id),
+      number: String(row.number),
+      friendlyName: row.friendly_name ? String(row.friendly_name) : null,
+      twilioSid: row.twilio_sid ? String(row.twilio_sid) : null,
+      status: String(row.status),
+      capabilities: {
+        voice: Boolean(row.voice_capable),
+        sms: Boolean(row.sms_capable),
+        whatsapp: Boolean(row.whatsapp_capable)
+      },
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+  rowToCallLog(row) {
+    return {
+      id: String(row.id),
+      callSid: row.call_sid ? String(row.call_sid) : null,
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      status: String(row.status),
+      assistantId: row.assistant_id ? String(row.assistant_id) : null,
+      duration: row.duration != null ? Number(row.duration) : null,
+      recordingUrl: row.recording_url ? String(row.recording_url) : null,
+      startedAt: row.started_at ? String(row.started_at) : null,
+      endedAt: row.ended_at ? String(row.ended_at) : null,
+      createdAt: String(row.created_at)
+    };
+  }
+  rowToSmsLog(row) {
+    return {
+      id: String(row.id),
+      messageSid: row.message_sid ? String(row.message_sid) : null,
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      messageType: String(row.message_type),
+      body: String(row.body),
+      status: String(row.status),
+      assistantId: row.assistant_id ? String(row.assistant_id) : null,
+      createdAt: String(row.created_at)
+    };
+  }
+  rowToRoutingRule(row) {
+    return {
+      id: String(row.id),
+      name: String(row.name),
+      priority: Number(row.priority),
+      fromPattern: row.from_pattern ? String(row.from_pattern) : null,
+      toPattern: row.to_pattern ? String(row.to_pattern) : null,
+      messageType: String(row.message_type),
+      timeOfDay: row.time_of_day ? String(row.time_of_day) : null,
+      dayOfWeek: row.day_of_week ? String(row.day_of_week) : null,
+      keyword: row.keyword ? String(row.keyword) : null,
+      targetAssistantId: String(row.target_assistant_id),
+      targetAssistantName: String(row.target_assistant_name),
+      enabled: Boolean(row.enabled),
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+}
+function matchPattern2(pattern, value) {
+  if (pattern === "*")
+    return true;
+  if (pattern.endsWith("*")) {
+    return value.startsWith(pattern.slice(0, -1));
+  }
+  if (pattern.startsWith("*")) {
+    return value.endsWith(pattern.slice(1));
+  }
+  return pattern === value;
+}
+function matchTimeOfDay(timeRange) {
+  const [start, end] = timeRange.split("-");
+  if (!start || !end)
+    return true;
+  const now2 = new Date;
+  const currentMinutes = now2.getHours() * 60 + now2.getMinutes();
+  const [startH, startM] = start.split(":").map(Number);
+  const [endH, endM] = end.split(":").map(Number);
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+  if (startMinutes <= endMinutes) {
+    return currentMinutes >= startMinutes && currentMinutes <= endMinutes;
+  }
+  return currentMinutes >= startMinutes || currentMinutes <= endMinutes;
+}
+function matchDayOfWeek(dayList) {
+  const days = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+  const today = days[new Date().getDay()];
+  const allowedDays = dayList.toLowerCase().split(",").map((d5) => d5.trim());
+  return allowedDays.includes(today);
+}
+
+// ../core/src/telephony/twilio-client.ts
+var TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
+
+class TwilioClient {
+  accountSid;
+  authToken;
+  authHeader;
+  constructor(config) {
+    this.accountSid = config.accountSid;
+    this.authToken = config.authToken;
+    this.authHeader = "Basic " + Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64");
+  }
+  isConfigured() {
+    return Boolean(this.accountSid && this.authToken);
+  }
+  async makeCall(params) {
+    const body = new URLSearchParams;
+    body.append("To", params.to);
+    body.append("From", params.from);
+    if (params.url) {
+      body.append("Url", params.url);
+    } else if (params.twiml) {
+      body.append("Twiml", params.twiml);
+    }
+    if (params.statusCallback) {
+      body.append("StatusCallback", params.statusCallback);
+      body.append("StatusCallbackEvent", "initiated ringing answered completed");
+      body.append("StatusCallbackMethod", "POST");
+    }
+    if (params.record) {
+      body.append("Record", "true");
+    }
+    return this.post(`/Accounts/${this.accountSid}/Calls.json`, body);
+  }
+  async updateCall(callSid, updates) {
+    const body = new URLSearchParams;
+    if (updates.status) {
+      body.append("Status", updates.status);
+    }
+    if (updates.url) {
+      body.append("Url", updates.url);
+    }
+    if (updates.twiml) {
+      body.append("Twiml", updates.twiml);
+    }
+    return this.post(`/Accounts/${this.accountSid}/Calls/${callSid}.json`, body);
+  }
+  async getCall(callSid) {
+    return this.get(`/Accounts/${this.accountSid}/Calls/${callSid}.json`);
+  }
+  async sendSms(params) {
+    const body = new URLSearchParams;
+    body.append("To", params.to);
+    body.append("From", params.from);
+    body.append("Body", params.body);
+    if (params.statusCallback) {
+      body.append("StatusCallback", params.statusCallback);
+    }
+    return this.post(`/Accounts/${this.accountSid}/Messages.json`, body);
+  }
+  async sendWhatsApp(params) {
+    const to3 = params.to.startsWith("whatsapp:") ? params.to : `whatsapp:${params.to}`;
+    const from = params.from.startsWith("whatsapp:") ? params.from : `whatsapp:${params.from}`;
+    return this.sendSms({
+      ...params,
+      to: to3,
+      from
+    });
+  }
+  async listPhoneNumbers() {
+    return this.get(`/Accounts/${this.accountSid}/IncomingPhoneNumbers.json`);
+  }
+  async getPhoneNumber(phoneSid) {
+    return this.get(`/Accounts/${this.accountSid}/IncomingPhoneNumbers/${phoneSid}.json`);
+  }
+  async updatePhoneNumber(phoneSid, updates) {
+    const body = new URLSearchParams;
+    if (updates.voiceUrl) {
+      body.append("VoiceUrl", updates.voiceUrl);
+      body.append("VoiceMethod", updates.voiceMethod || "POST");
+    }
+    if (updates.smsUrl) {
+      body.append("SmsUrl", updates.smsUrl);
+      body.append("SmsMethod", updates.smsMethod || "POST");
+    }
+    if (updates.statusCallback) {
+      body.append("StatusCallback", updates.statusCallback);
+    }
+    return this.post(`/Accounts/${this.accountSid}/IncomingPhoneNumbers/${phoneSid}.json`, body);
+  }
+  async verifyCredentials() {
+    return this.get(`/Accounts/${this.accountSid}.json`);
+  }
+  async get(path2) {
+    try {
+      const response = await fetch(`${TWILIO_API_BASE}${path2}`, {
+        method: "GET",
+        headers: {
+          Authorization: this.authHeader,
+          Accept: "application/json"
+        }
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          statusCode: response.status
+        };
+      }
+      return { success: true, data, statusCode: response.status };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2),
+        statusCode: 0
+      };
+    }
+  }
+  async post(path2, body) {
+    try {
+      const response = await fetch(`${TWILIO_API_BASE}${path2}`, {
+        method: "POST",
+        headers: {
+          Authorization: this.authHeader,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: body.toString()
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          statusCode: response.status
+        };
+      }
+      return { success: true, data, statusCode: response.status };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2),
+        statusCode: 0
+      };
+    }
+  }
+}
+
+// ../core/src/telephony/call-manager.ts
+class CallManager {
+  activeCalls = new Map;
+  maxCallDurationMs;
+  staleTimeoutMs;
+  constructor(config) {
+    this.maxCallDurationMs = (config?.maxCallDurationSeconds || 3600) * 1000;
+    this.staleTimeoutMs = (config?.staleTimeoutSeconds || 300) * 1000;
+  }
+  addCall(params) {
+    const call = {
+      callSid: params.callSid,
+      streamSid: null,
+      fromNumber: params.fromNumber,
+      toNumber: params.toNumber,
+      direction: params.direction,
+      state: "connecting",
+      assistantId: params.assistantId || null,
+      bridgeId: null,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    this.activeCalls.set(params.callSid, call);
+    return call;
+  }
+  getCall(callSid) {
+    return this.activeCalls.get(callSid) || null;
+  }
+  updateState(callSid, state) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    const validTransitions = {
+      connecting: ["ringing", "active", "ending"],
+      ringing: ["bridging", "active", "ending"],
+      bridging: ["active", "ending"],
+      active: ["ending"],
+      ending: []
+    };
+    if (!validTransitions[call.state].includes(state)) {
+      return false;
+    }
+    call.state = state;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  setStreamSid(callSid, streamSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    call.streamSid = streamSid;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  setBridgeId(callSid, bridgeId) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    call.bridgeId = bridgeId;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  touchCall(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (call) {
+      call.lastActivityAt = Date.now();
+    }
+  }
+  endCall(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return null;
+    call.state = "ending";
+    this.activeCalls.delete(callSid);
+    return call;
+  }
+  getActiveCalls() {
+    return Array.from(this.activeCalls.values());
+  }
+  getActiveCallCount() {
+    return this.activeCalls.size;
+  }
+  getCallByStreamSid(streamSid) {
+    for (const call of this.activeCalls.values()) {
+      if (call.streamSid === streamSid)
+        return call;
+    }
+    return null;
+  }
+  cleanupStaleCalls() {
+    const now2 = Date.now();
+    const removed = [];
+    for (const [callSid, call] of this.activeCalls) {
+      if (now2 - call.startedAt > this.maxCallDurationMs) {
+        this.activeCalls.delete(callSid);
+        removed.push(callSid);
+        continue;
+      }
+      if (now2 - call.lastActivityAt > this.staleTimeoutMs) {
+        this.activeCalls.delete(callSid);
+        removed.push(callSid);
+      }
+    }
+    return removed;
+  }
+  getCallDuration(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return null;
+    return Math.floor((Date.now() - call.startedAt) / 1000);
+  }
+  endAllCalls() {
+    const calls = Array.from(this.activeCalls.values());
+    this.activeCalls.clear();
+    return calls;
+  }
+}
+
+// ../core/src/telephony/voice-bridge.ts
+init_src2();
+
+// ../core/src/telephony/audio-codec.ts
+var MULAW_MAX = 8191;
+var MULAW_BIAS = 33;
+function pcmSampleToMulaw(sample) {
+  const sign2 = sample >> 8 & 128;
+  if (sign2 !== 0)
+    sample = -sample;
+  if (sample > MULAW_MAX)
+    sample = MULAW_MAX;
+  sample += MULAW_BIAS;
+  let exponent = 7;
+  let mask = 16384;
+  while (exponent > 0 && (sample & mask) === 0) {
+    exponent--;
+    mask >>= 1;
+  }
+  const mantissa = sample >> exponent + 3 & 15;
+  const mulawByte = ~(sign2 | exponent << 4 | mantissa) & 255;
+  return mulawByte;
+}
+function mulawSampleToPcm(mulawByte) {
+  mulawByte = ~mulawByte & 255;
+  const sign2 = mulawByte & 128;
+  const exponent = mulawByte >> 4 & 7;
+  const mantissa = mulawByte & 15;
+  let sample = (mantissa << 3) + MULAW_BIAS << exponent;
+  sample -= MULAW_BIAS;
+  return sign2 !== 0 ? -sample : sample;
+}
+function pcmToMulaw(pcmBuffer) {
+  const numSamples = Math.floor(pcmBuffer.length / 2);
+  const mulawBuffer = Buffer.alloc(numSamples);
+  for (let i5 = 0;i5 < numSamples; i5++) {
+    const sample = pcmBuffer.readInt16LE(i5 * 2);
+    mulawBuffer[i5] = pcmSampleToMulaw(sample);
+  }
+  return mulawBuffer;
+}
+function mulawToPcm(mulawBuffer) {
+  const pcmBuffer = Buffer.alloc(mulawBuffer.length * 2);
+  for (let i5 = 0;i5 < mulawBuffer.length; i5++) {
+    const sample = mulawSampleToPcm(mulawBuffer[i5]);
+    pcmBuffer.writeInt16LE(sample, i5 * 2);
+  }
+  return pcmBuffer;
+}
+function downsample16kTo8k(pcm16k) {
+  const numSamples = Math.floor(pcm16k.length / 2);
+  const outputSamples = Math.floor(numSamples / 2);
+  const pcm8k = Buffer.alloc(outputSamples * 2);
+  for (let i5 = 0;i5 < outputSamples; i5++) {
+    const sample = pcm16k.readInt16LE(i5 * 2 * 2);
+    pcm8k.writeInt16LE(sample, i5 * 2);
+  }
+  return pcm8k;
+}
+function upsample8kTo16k(pcm8k) {
+  const numSamples = Math.floor(pcm8k.length / 2);
+  const pcm16k = Buffer.alloc(numSamples * 2 * 2);
+  for (let i5 = 0;i5 < numSamples; i5++) {
+    const current = pcm8k.readInt16LE(i5 * 2);
+    const next = i5 + 1 < numSamples ? pcm8k.readInt16LE((i5 + 1) * 2) : current;
+    const interpolated = Math.round((current + next) / 2);
+    pcm16k.writeInt16LE(current, i5 * 4);
+    pcm16k.writeInt16LE(interpolated, i5 * 4 + 2);
+  }
+  return pcm16k;
+}
+function twilioToElevenLabs(mulawBuffer) {
+  const pcm8k = mulawToPcm(mulawBuffer);
+  return upsample8kTo16k(pcm8k);
+}
+function elevenLabsToTwilio(pcm16k) {
+  const pcm8k = downsample16kTo8k(pcm16k);
+  return pcmToMulaw(pcm8k);
+}
+function decodeTwilioPayload(base64Payload) {
+  const mulawBuffer = Buffer.from(base64Payload, "base64");
+  return twilioToElevenLabs(mulawBuffer);
+}
+function encodeTwilioPayload(pcm16k) {
+  const mulawBuffer = elevenLabsToTwilio(pcm16k);
+  return mulawBuffer.toString("base64");
+}
+
+// ../core/src/telephony/voice-bridge.ts
+var ELEVENLABS_WS_BASE = "wss://api.elevenlabs.io/v1/convai/conversation";
+
+class VoiceBridge {
+  config;
+  connections = new Map;
+  constructor(config) {
+    this.config = config;
+  }
+  isConfigured() {
+    return Boolean(this.config.elevenLabsApiKey && this.config.elevenLabsAgentId);
+  }
+  async createBridge(callSid, streamSid, sendToTwilio) {
+    const id = `bridge_${generateId().slice(0, 12)}`;
+    const connection = new BridgeConnection({
+      id,
+      callSid,
+      streamSid,
+      config: this.config,
+      sendToTwilio
+    });
+    this.connections.set(id, connection);
+    try {
+      await connection.connect();
+    } catch (error2) {
+      this.connections.delete(id);
+      throw error2;
+    }
+    return id;
+  }
+  handleTwilioMedia(bridgeId, message) {
+    const connection = this.connections.get(bridgeId);
+    if (!connection)
+      return;
+    if (message.event === "media" && message.media?.payload) {
+      connection.forwardToElevenLabs(message.media.payload);
+    } else if (message.event === "stop") {
+      connection.close();
+      this.connections.delete(bridgeId);
+    }
+  }
+  closeBridge(bridgeId) {
+    const connection = this.connections.get(bridgeId);
+    if (connection) {
+      connection.close();
+      this.connections.delete(bridgeId);
+    }
+  }
+  getConnection(bridgeId) {
+    const conn = this.connections.get(bridgeId);
+    if (!conn)
+      return null;
+    return conn.getInfo();
+  }
+  getActiveConnections() {
+    return Array.from(this.connections.values()).map((c6) => c6.getInfo());
+  }
+  closeAll() {
+    for (const connection of this.connections.values()) {
+      connection.close();
+    }
+    this.connections.clear();
+  }
+}
+
+class BridgeConnection {
+  id;
+  callSid;
+  streamSid;
+  config;
+  sendToTwilio;
+  elevenLabsWs = null;
+  state = "connecting";
+  startedAt;
+  constructor(options) {
+    this.id = options.id;
+    this.callSid = options.callSid;
+    this.streamSid = options.streamSid;
+    this.config = options.config;
+    this.sendToTwilio = options.sendToTwilio;
+    this.startedAt = Date.now();
+  }
+  async connect() {
+    const url = `${ELEVENLABS_WS_BASE}?agent_id=${this.config.elevenLabsAgentId}`;
+    return new Promise((resolve5, reject) => {
+      try {
+        this.elevenLabsWs = new WebSocket(url, {
+          headers: {
+            "xi-api-key": this.config.elevenLabsApiKey
+          }
+        });
+        this.elevenLabsWs.onopen = () => {
+          this.state = "active";
+          resolve5();
+        };
+        this.elevenLabsWs.onmessage = (event) => {
+          this.handleElevenLabsMessage(event.data);
+        };
+        this.elevenLabsWs.onerror = (event) => {
+          console.error(`[VoiceBridge ${this.id}] ElevenLabs WS error:`, event);
+          if (this.state === "connecting") {
+            reject(new Error("Failed to connect to ElevenLabs"));
+          }
+        };
+        this.elevenLabsWs.onclose = () => {
+          this.state = "closed";
+        };
+        setTimeout(() => {
+          if (this.state === "connecting") {
+            this.close();
+            reject(new Error("ElevenLabs connection timeout"));
+          }
+        }, 1e4);
+      } catch (error2) {
+        reject(error2);
+      }
+    });
+  }
+  forwardToElevenLabs(base64Payload) {
+    if (this.state !== "active" || !this.elevenLabsWs)
+      return;
+    try {
+      const pcm16k = decodeTwilioPayload(base64Payload);
+      const message = JSON.stringify({
+        user_audio_chunk: pcm16k.toString("base64")
+      });
+      if (this.elevenLabsWs.readyState === WebSocket.OPEN) {
+        this.elevenLabsWs.send(message);
+      }
+    } catch (error2) {
+      console.error(`[VoiceBridge ${this.id}] Error forwarding to ElevenLabs:`, error2);
+    }
+  }
+  handleElevenLabsMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      if (message.audio?.chunk) {
+        const pcm16k = Buffer.from(message.audio.chunk, "base64");
+        const twilioPayload = encodeTwilioPayload(pcm16k);
+        const twilioMessage = JSON.stringify({
+          event: "media",
+          streamSid: this.streamSid,
+          media: {
+            payload: twilioPayload
+          }
+        });
+        this.sendToTwilio(twilioMessage);
+      }
+      if (message.type === "conversation_initiation_metadata") {} else if (message.type === "agent_response") {} else if (message.type === "user_transcript") {}
+    } catch (error2) {
+      console.error(`[VoiceBridge ${this.id}] Error handling ElevenLabs message:`, error2);
+    }
+  }
+  close() {
+    if (this.state === "closed" || this.state === "closing")
+      return;
+    this.state = "closing";
+    if (this.elevenLabsWs) {
+      try {
+        this.elevenLabsWs.close();
+      } catch {}
+      this.elevenLabsWs = null;
+    }
+    this.state = "closed";
+  }
+  getInfo() {
+    return {
+      id: this.id,
+      callSid: this.callSid,
+      streamSid: this.streamSid,
+      state: this.state,
+      startedAt: this.startedAt
+    };
+  }
+}
+
+// ../core/src/telephony/manager.ts
+class TelephonyManager {
+  assistantId;
+  assistantName;
+  config;
+  store;
+  twilioClient = null;
+  callManager;
+  voiceBridge = null;
+  constructor(options) {
+    this.assistantId = options.assistantId;
+    this.assistantName = options.assistantName;
+    this.config = options.config;
+    this.store = new TelephonyStore;
+    this.callManager = new CallManager({
+      maxCallDurationSeconds: options.config.voice?.maxCallDurationSeconds
+    });
+    const accountSid = process.env.TWILIO_ACCOUNT_SID;
+    const authToken = process.env.TWILIO_AUTH_TOKEN;
+    if (accountSid && authToken) {
+      this.twilioClient = new TwilioClient({ accountSid, authToken });
+    }
+    const elevenLabsApiKey = process.env.ELEVENLABS_API_KEY;
+    const elevenLabsAgentId = this.config.elevenLabsAgentId || process.env.ELEVENLABS_AGENT_ID;
+    if (elevenLabsApiKey && elevenLabsAgentId) {
+      this.voiceBridge = new VoiceBridge({
+        elevenLabsApiKey,
+        elevenLabsAgentId
+      });
+    }
+  }
+  async sendSms(to3, body, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured. Set telephony.defaultPhoneNumber or TWILIO_PHONE_NUMBER."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    const statusCallback = webhookUrl ? `${webhookUrl}/api/v1/telephony/webhooks/sms-status` : undefined;
+    const result = await this.twilioClient.sendSms({
+      to: to3,
+      from: fromNumber,
+      body,
+      statusCallback
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to send SMS: ${result.error}` };
+    }
+    const log2 = this.store.createSmsLog({
+      messageSid: result.data?.sid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      messageType: "sms",
+      body,
+      status: "queued",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `SMS sent to ${to3}.`,
+      messageSid: result.data?.sid,
+      id: log2.id
+    };
+  }
+  async sendWhatsApp(to3, body, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    const statusCallback = webhookUrl ? `${webhookUrl}/api/v1/telephony/webhooks/sms-status` : undefined;
+    const result = await this.twilioClient.sendWhatsApp({
+      to: to3,
+      from: fromNumber,
+      body,
+      statusCallback
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to send WhatsApp: ${result.error}` };
+    }
+    const log2 = this.store.createSmsLog({
+      messageSid: result.data?.sid,
+      fromNumber: `whatsapp:${fromNumber}`,
+      toNumber: `whatsapp:${to3}`,
+      direction: "outbound",
+      messageType: "whatsapp",
+      body,
+      status: "queued",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `WhatsApp message sent to ${to3}.`,
+      messageSid: result.data?.sid,
+      id: log2.id
+    };
+  }
+  async makeCall(to3, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    if (!webhookUrl) {
+      return {
+        success: false,
+        message: "No webhook URL configured. Set telephony.webhookUrl or TELEPHONY_WEBHOOK_URL."
+      };
+    }
+    const result = await this.twilioClient.makeCall({
+      to: to3,
+      from: fromNumber,
+      url: `${webhookUrl}/api/v1/telephony/webhooks/voice`,
+      statusCallback: `${webhookUrl}/api/v1/telephony/webhooks/voice-status`,
+      record: this.config.voice?.recordCalls
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to make call: ${result.error}` };
+    }
+    const callSid = result.data?.sid;
+    const log2 = this.store.createCallLog({
+      callSid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      status: "pending",
+      assistantId: this.assistantId
+    });
+    this.callManager.addCall({
+      callSid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `Calling ${to3}...`,
+      callSid,
+      id: log2.id
+    };
+  }
+  getCallHistory(options) {
+    return this.store.listCallLogs({
+      assistantId: this.assistantId,
+      limit: options?.limit || 20
+    });
+  }
+  getSmsHistory(options) {
+    return this.store.listSmsLogs({
+      assistantId: this.assistantId,
+      messageType: options?.messageType,
+      limit: options?.limit || 20
+    });
+  }
+  listPhoneNumbers() {
+    return this.store.listPhoneNumbers("active");
+  }
+  async syncPhoneNumbers() {
+    if (!this.twilioClient) {
+      return { success: false, message: "Twilio is not configured." };
+    }
+    const result = await this.twilioClient.listPhoneNumbers();
+    if (!result.success) {
+      return { success: false, message: `Failed to list numbers: ${result.error}` };
+    }
+    const numbers = result.data?.incoming_phone_numbers || [];
+    let synced = 0;
+    for (const num of numbers) {
+      const phoneNumber = String(num.phone_number || "");
+      const existing = this.store.getPhoneNumberByNumber(phoneNumber);
+      if (!existing && phoneNumber) {
+        this.store.addPhoneNumber(phoneNumber, num.friendly_name ? String(num.friendly_name) : null, num.sid ? String(num.sid) : null, {
+          voice: Boolean(num.capabilities?.voice),
+          sms: Boolean(num.capabilities?.sms)
+        });
+        synced++;
+      }
+    }
+    return {
+      success: true,
+      message: `Synced ${synced} phone number${synced !== 1 ? "s" : ""} from Twilio.`
+    };
+  }
+  listRoutingRules() {
+    return this.store.listRoutingRules();
+  }
+  createRoutingRule(params) {
+    const rule = this.store.createRoutingRule(params);
+    return {
+      success: true,
+      message: `Routing rule "${rule.name}" created (priority ${rule.priority}).`,
+      id: rule.id
+    };
+  }
+  deleteRoutingRule(id) {
+    const success = this.store.deleteRoutingRule(id);
+    return {
+      success,
+      message: success ? "Routing rule deleted." : "Routing rule not found."
+    };
+  }
+  getStatus() {
+    const phoneNumbers = this.store.listPhoneNumbers("active");
+    const recentCalls = this.store.listCallLogs({ limit: 100 });
+    const recentMessages = this.store.listSmsLogs({ limit: 100 });
+    const routingRules = this.store.listRoutingRules();
+    return {
+      enabled: this.config.enabled !== false,
+      twilioConfigured: this.twilioClient?.isConfigured() ?? false,
+      elevenLabsConfigured: this.voiceBridge?.isConfigured() ?? false,
+      phoneNumbers: phoneNumbers.length,
+      activeCalls: this.callManager.getActiveCallCount(),
+      routingRules: routingRules.length,
+      recentCalls: recentCalls.length,
+      recentMessages: recentMessages.length
+    };
+  }
+  getUnreadForInjection() {
+    const injectionConfig = this.config.injection || {};
+    if (injectionConfig.enabled === false) {
+      return [];
+    }
+    const maxPerTurn = injectionConfig.maxPerTurn || 5;
+    return this.store.getUnreadInboundSms(this.assistantId, maxPerTurn);
+  }
+  buildInjectionContext(messages) {
+    if (messages.length === 0)
+      return "";
+    const lines = [];
+    lines.push("## Incoming Telephony Messages");
+    lines.push("");
+    for (const msg of messages) {
+      const type = msg.messageType === "whatsapp" ? "WhatsApp" : "SMS";
+      const ago = formatTimeAgo2(msg.createdAt);
+      lines.push(`**${type} from ${msg.fromNumber}** (${ago}):`);
+      lines.push(msg.body);
+      lines.push("");
+    }
+    lines.push("Use telephony_send_sms or telephony_send_whatsapp to reply.");
+    return lines.join(`
+`);
+  }
+  markInjected(messages) {
+    for (const msg of messages) {
+      this.store.updateSmsStatus(msg.id, "delivered");
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+  getTwilioClient() {
+    return this.twilioClient;
+  }
+  getCallManager() {
+    return this.callManager;
+  }
+  getVoiceBridge() {
+    return this.voiceBridge;
+  }
+  getAssistantId() {
+    return this.assistantId;
+  }
+  getAssistantName() {
+    return this.assistantName;
+  }
+  getConfig() {
+    return this.config;
+  }
+  cleanup() {
+    const maxAgeDays = this.config.storage?.maxAgeDays || 90;
+    const maxCallLogs = this.config.storage?.maxCallLogs || 1000;
+    const maxSmsLogs = this.config.storage?.maxSmsLogs || 5000;
+    this.callManager.cleanupStaleCalls();
+    return this.store.cleanup(maxAgeDays, maxCallLogs, maxSmsLogs);
+  }
+  close() {
+    this.callManager.endAllCalls();
+    this.voiceBridge?.closeAll();
+    this.store.close();
+  }
+}
+function formatTimeAgo2(isoDate) {
+  const now2 = Date.now();
+  const then = new Date(isoDate).getTime();
+  const diffMs = now2 - then;
+  if (diffMs < 60000) {
+    const secs = Math.floor(diffMs / 1000);
+    return `${secs}s ago`;
+  }
+  if (diffMs < 3600000) {
+    const mins = Math.floor(diffMs / 60000);
+    return `${mins}m ago`;
+  }
+  if (diffMs < 86400000) {
+    const hours = Math.floor(diffMs / 3600000);
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(diffMs / 86400000);
+  return `${days}d ago`;
+}
+function createTelephonyManager(assistantId, assistantName, config) {
+  return new TelephonyManager({
+    assistantId,
+    assistantName,
+    config
+  });
+}
+// ../core/src/telephony/tools.ts
+var telephonySendSmsTool = {
+  name: "telephony_send_sms",
+  description: "Send an SMS text message to a phone number.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Recipient phone number in E.164 format (e.g., "+15551234567")'
+      },
+      body: {
+        type: "string",
+        description: "Message content to send"
+      },
+      from: {
+        type: "string",
+        description: "Sender phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to", "body"]
+  }
+};
+var telephonySendWhatsappTool = {
+  name: "telephony_send_whatsapp",
+  description: "Send a WhatsApp message to a phone number.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Recipient phone number in E.164 format (e.g., "+15551234567")'
+      },
+      body: {
+        type: "string",
+        description: "Message content to send"
+      },
+      from: {
+        type: "string",
+        description: "Sender phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to", "body"]
+  }
+};
+var telephonyCallTool = {
+  name: "telephony_call",
+  description: "Initiate an outbound voice call. The call will be connected to the AI voice agent.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Phone number to call in E.164 format (e.g., "+15551234567")'
+      },
+      from: {
+        type: "string",
+        description: "Caller phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to"]
+  }
+};
+var telephonyCallHistoryTool = {
+  name: "telephony_call_history",
+  description: "Get recent call history. Returns call logs with status, duration, and timestamps.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum number of calls to return (default: 20)"
+      }
+    },
+    required: []
+  }
+};
+var telephonySmsHistoryTool = {
+  name: "telephony_sms_history",
+  description: "Get recent SMS and WhatsApp message history.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum messages to return (default: 20)"
+      },
+      type: {
+        type: "string",
+        enum: ["sms", "whatsapp"],
+        description: "Filter by message type (default: all)"
+      }
+    },
+    required: []
+  }
+};
+var telephonyPhoneNumbersTool = {
+  name: "telephony_phone_numbers",
+  description: "List available phone numbers with their capabilities (voice, SMS, WhatsApp).",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+var telephonyRoutingRulesTool = {
+  name: "telephony_routing_rules",
+  description: "View and manage routing rules that direct incoming calls/messages to specific assistants.",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "create", "delete"],
+        description: "Action to perform (default: list)"
+      },
+      name: {
+        type: "string",
+        description: "Rule name (for create)"
+      },
+      priority: {
+        type: "number",
+        description: "Priority (lower = higher priority, for create)"
+      },
+      from_pattern: {
+        type: "string",
+        description: 'From number pattern (e.g., "+1555*", for create)'
+      },
+      message_type: {
+        type: "string",
+        enum: ["sms", "whatsapp", "voice", "all"],
+        description: "Message type filter (for create)"
+      },
+      rule_id: {
+        type: "string",
+        description: "Rule ID (for delete)"
+      }
+    },
+    required: []
+  }
+};
+var telephonyStatusTool = {
+  name: "telephony_status",
+  description: "Get telephony system status including configured numbers, active calls, and connection health.",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+function createTelephonyToolExecutors(getTelephonyManager) {
+  return {
+    telephony_send_sms: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      const body = String(input.body || "").trim();
+      if (!to3)
+        return "Error: Recipient phone number (to) is required.";
+      if (!body)
+        return "Error: Message body is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.sendSms(to3, body, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_send_whatsapp: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      const body = String(input.body || "").trim();
+      if (!to3)
+        return "Error: Recipient phone number (to) is required.";
+      if (!body)
+        return "Error: Message body is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.sendWhatsApp(to3, body, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_call: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      if (!to3)
+        return "Error: Phone number (to) is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.makeCall(to3, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_call_history: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      const calls = manager.getCallHistory({ limit: limit2 });
+      if (calls.length === 0) {
+        return "No call history found.";
+      }
+      const lines = [];
+      lines.push(`## Call History (${calls.length})`);
+      lines.push("");
+      for (const call of calls) {
+        const dir = call.direction === "inbound" ? "IN" : "OUT";
+        const duration = call.duration != null ? `${call.duration}s` : "-";
+        const date = new Date(call.createdAt).toLocaleString();
+        lines.push(`[${dir}] ${call.fromNumber} \u2192 ${call.toNumber} | ${call.status} | ${duration} | ${date}`);
+      }
+      return lines.join(`
+`);
+    },
+    telephony_sms_history: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      const messageType = input.type;
+      const messages = manager.getSmsHistory({ limit: limit2, messageType });
+      if (messages.length === 0) {
+        return "No message history found.";
+      }
+      const lines = [];
+      lines.push(`## Message History (${messages.length})`);
+      lines.push("");
+      for (const msg of messages) {
+        const dir = msg.direction === "inbound" ? "IN" : "OUT";
+        const type = msg.messageType === "whatsapp" ? "WA" : "SMS";
+        const date = new Date(msg.createdAt).toLocaleString();
+        lines.push(`[${dir}/${type}] ${msg.fromNumber} \u2192 ${msg.toNumber} | ${msg.status}`);
+        lines.push(`  ${msg.bodyPreview}`);
+        lines.push(`  ${date}`);
+        lines.push("");
+      }
+      return lines.join(`
+`);
+    },
+    telephony_phone_numbers: async () => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const numbers = manager.listPhoneNumbers();
+      if (numbers.length === 0) {
+        return "No phone numbers configured. Use /phone sync to import from Twilio.";
+      }
+      const lines = [];
+      lines.push(`## Phone Numbers (${numbers.length})`);
+      lines.push("");
+      for (const num of numbers) {
+        const caps = [];
+        if (num.capabilities.voice)
+          caps.push("voice");
+        if (num.capabilities.sms)
+          caps.push("sms");
+        if (num.capabilities.whatsapp)
+          caps.push("whatsapp");
+        const name2 = num.friendlyName ? ` (${num.friendlyName})` : "";
+        lines.push(`  ${num.number}${name2} [${caps.join(", ")}]`);
+      }
+      return lines.join(`
+`);
+    },
+    telephony_routing_rules: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const action = String(input.action || "list");
+      if (action === "list") {
+        const rules = manager.listRoutingRules();
+        if (rules.length === 0) {
+          return "No routing rules configured.";
+        }
+        const lines = [];
+        lines.push(`## Routing Rules (${rules.length})`);
+        lines.push("");
+        for (const rule of rules) {
+          const enabled = rule.enabled ? "" : " [DISABLED]";
+          lines.push(`**${rule.name}** (priority: ${rule.priority})${enabled}`);
+          lines.push(`  ID: ${rule.id}`);
+          lines.push(`  Type: ${rule.messageType} | Target: ${rule.targetAssistantName}`);
+          if (rule.fromPattern)
+            lines.push(`  From: ${rule.fromPattern}`);
+          if (rule.toPattern)
+            lines.push(`  To: ${rule.toPattern}`);
+          if (rule.keyword)
+            lines.push(`  Keyword: ${rule.keyword}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      }
+      if (action === "create") {
+        const name2 = String(input.name || "").trim();
+        if (!name2)
+          return "Error: Rule name is required.";
+        const result = manager.createRoutingRule({
+          name: name2,
+          priority: typeof input.priority === "number" ? input.priority : undefined,
+          fromPattern: input.from_pattern ? String(input.from_pattern) : undefined,
+          messageType: input.message_type,
+          targetAssistantId: manager.getAssistantId(),
+          targetAssistantName: manager.getAssistantName()
+        });
+        return result.success ? result.message : `Error: ${result.message}`;
+      }
+      if (action === "delete") {
+        const ruleId = String(input.rule_id || "").trim();
+        if (!ruleId)
+          return "Error: Rule ID is required.";
+        const result = manager.deleteRoutingRule(ruleId);
+        return result.success ? result.message : `Error: ${result.message}`;
+      }
+      return `Unknown action: ${action}. Use 'list', 'create', or 'delete'.`;
+    },
+    telephony_status: async () => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const status = manager.getStatus();
+      const lines = [];
+      lines.push("## Telephony Status");
+      lines.push("");
+      lines.push(`Enabled:           ${status.enabled ? "Yes" : "No"}`);
+      lines.push(`Twilio configured: ${status.twilioConfigured ? "Yes" : "No (set TWILIO_ACCOUNT_SID + TWILIO_AUTH_TOKEN)"}`);
+      lines.push(`ElevenLabs AI:     ${status.elevenLabsConfigured ? "Yes" : "No (set ELEVENLABS_API_KEY + ELEVENLABS_AGENT_ID)"}`);
+      lines.push(`Phone numbers:     ${status.phoneNumbers}`);
+      lines.push(`Active calls:      ${status.activeCalls}`);
+      lines.push(`Routing rules:     ${status.routingRules}`);
+      lines.push(`Recent calls:      ${status.recentCalls}`);
+      lines.push(`Recent messages:   ${status.recentMessages}`);
+      return lines.join(`
+`);
+    }
+  };
+}
+var telephonyTools = [
+  telephonySendSmsTool,
+  telephonySendWhatsappTool,
+  telephonyCallTool,
+  telephonyCallHistoryTool,
+  telephonySmsHistoryTool,
+  telephonyPhoneNumbersTool,
+  telephonyRoutingRulesTool,
+  telephonyStatusTool
+];
+function registerTelephonyTools(registry2, getTelephonyManager) {
+  const executors = createTelephonyToolExecutors(getTelephonyManager);
+  for (const tool of telephonyTools) {
+    registry2.register(tool, executors[tool.name]);
+  }
+}
 // ../core/src/sessions/store.ts
-import { join as join43 } from "path";
+import { join as join45 } 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";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, writeFileSync as writeFileSync14, readFileSync as readFileSync17, readdirSync as readdirSync9, unlinkSync as unlinkSync6 } from "fs";
 
 class SessionStore {
   basePath;
   constructor(basePath) {
     const envHome = process.env.HOME || process.env.USERPROFILE || homedir21();
-    this.basePath = basePath || join43(envHome, ".assistants", "sessions");
+    this.basePath = basePath || join45(envHome, ".assistants", "sessions");
     this.ensureDir();
   }
   ensureDir() {
-    if (!existsSync26(this.basePath)) {
-      mkdirSync16(this.basePath, { recursive: true });
+    if (!existsSync28(this.basePath)) {
+      mkdirSync18(this.basePath, { recursive: true });
     }
   }
   getSessionPath(id) {
-    return join43(this.basePath, `${id}.json`);
+    return join45(this.basePath, `${id}.json`);
   }
   save(data) {
     try {
@@ -150116,7 +153311,7 @@ class SessionStore {
   load(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (!existsSync26(filePath))
+      if (!existsSync28(filePath))
         return null;
       return JSON.parse(readFileSync17(filePath, "utf-8"));
     } catch {
@@ -150130,7 +153325,7 @@ class SessionStore {
       const sessions = [];
       for (const file of files) {
         try {
-          const data = JSON.parse(readFileSync17(join43(this.basePath, file), "utf-8"));
+          const data = JSON.parse(readFileSync17(join45(this.basePath, file), "utf-8"));
           sessions.push(data);
         } catch {}
       }
@@ -150142,8 +153337,8 @@ class SessionStore {
   delete(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (existsSync26(filePath)) {
-        unlinkSync5(filePath);
+      if (existsSync28(filePath)) {
+        unlinkSync6(filePath);
       }
     } catch {}
   }
@@ -150430,6 +153625,12 @@ class EmbeddedClient {
     }
     return null;
   }
+  getMemoryManager() {
+    if (typeof this.assistantLoop.getMemoryManager === "function") {
+      return this.assistantLoop.getMemoryManager();
+    }
+    return null;
+  }
   async refreshIdentityContext() {
     if (typeof this.assistantLoop.refreshIdentityContext === "function") {
       await this.assistantLoop.refreshIdentityContext();
@@ -150447,6 +153648,18 @@ class EmbeddedClient {
     }
     return null;
   }
+  getChannelsManager() {
+    if (typeof this.assistantLoop.getChannelsManager === "function") {
+      return this.assistantLoop.getChannelsManager();
+    }
+    return null;
+  }
+  getTelephonyManager() {
+    if (typeof this.assistantLoop.getTelephonyManager === "function") {
+      return this.assistantLoop.getTelephonyManager();
+    }
+    return null;
+  }
   getWalletManager() {
     if (typeof this.assistantLoop.getWalletManager === "function") {
       return this.assistantLoop.getWalletManager();
@@ -152317,7 +155530,7 @@ function createSelfAwarenessToolExecutors(context) {
     workspace_map: async (input) => {
       const { readdir: readdir7, stat: stat5, access } = await import("fs/promises");
       const { execSync } = await import("child_process");
-      const { join: join44, basename: basename6 } = await import("path");
+      const { join: join46, basename: basename6 } = await import("path");
       const depth = input.depth ?? 3;
       const includeGitStatus = input.include_git_status !== false;
       const includeRecentFiles = input.include_recent_files !== false;
@@ -152363,7 +155576,7 @@ function createSelfAwarenessToolExecutors(context) {
               break;
             }
             if (entry.isDirectory()) {
-              const children = await buildTree(join44(dir, entry.name), currentDepth + 1);
+              const children = await buildTree(join46(dir, entry.name), currentDepth + 1);
               nodes.push({
                 name: entry.name,
                 type: "directory",
@@ -152389,7 +155602,7 @@ function createSelfAwarenessToolExecutors(context) {
       };
       if (includeGitStatus) {
         try {
-          await access(join44(cwd, ".git"));
+          await access(join46(cwd, ".git"));
           gitStatus.isRepo = true;
           try {
             const branch = execSync("git branch --show-current", { cwd, encoding: "utf-8" }).trim();
@@ -152420,7 +155633,7 @@ function createSelfAwarenessToolExecutors(context) {
             for (const entry of entries) {
               if (shouldIgnore(entry.name))
                 continue;
-              const fullPath = join44(dir, entry.name);
+              const fullPath = join46(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isFile()) {
                 try {
@@ -152454,12 +155667,12 @@ function createSelfAwarenessToolExecutors(context) {
       let projectName = basename6(cwd);
       for (const indicator of projectIndicators) {
         try {
-          await access(join44(cwd, indicator.file));
+          await access(join46(cwd, indicator.file));
           projectType = indicator.type;
           if (indicator.file === "package.json") {
             try {
               const { readFile: readFile16 } = await import("fs/promises");
-              const pkg = JSON.parse(await readFile16(join44(cwd, indicator.file), "utf-8"));
+              const pkg = JSON.parse(await readFile16(join46(cwd, indicator.file), "utf-8"));
               projectName = pkg.name || projectName;
             } catch {}
           }
@@ -154649,6 +157862,21 @@ var taskTools = [
   tasksRecurringCancelTool
 ];
 function createTaskToolExecutors(context) {
+  const formatTaskMatch = (task) => {
+    const desc = task.description.length > 60 ? `${task.description.slice(0, 60)}...` : task.description;
+    return `${task.id} - ${desc}`;
+  };
+  const handleResolveError = (id, matches, label) => {
+    if (matches.length > 1) {
+      const listed = matches.slice(0, 5).map(formatTaskMatch).join(`
+`);
+      const more = matches.length > 5 ? `
+...and ${matches.length - 5} more` : "";
+      return `Multiple ${label} match "${id}". Use a longer ID prefix.
+${listed}${more}`;
+    }
+    return `${label} not found: ${id}`;
+  };
   return {
     tasks_list: async (input) => {
       const tasks = await getTasks(context.cwd);
@@ -154660,16 +157888,16 @@ function createTaskToolExecutors(context) {
       const lines = filtered.map((t9) => {
         const statusIcon = t9.status === "pending" ? "\u25CB" : t9.status === "in_progress" ? "\u25D0" : t9.status === "completed" ? "\u25CF" : "\u2717";
         const priorityIcon = t9.priority === "high" ? "\u2191" : t9.priority === "low" ? "\u2193" : "-";
-        return `${statusIcon} [${priorityIcon}] ${t9.id.slice(0, 8)} - ${t9.description}`;
+        return `${statusIcon} [${priorityIcon}] ${t9.id} - ${t9.description}`;
       });
       return `Tasks (${filtered.length}):
 ${lines.join(`
 `)}`;
     },
     tasks_get: async (input) => {
-      const task = await getTask(context.cwd, input.id);
+      const { task, matches } = await resolveTaskId(context.cwd, input.id);
       if (!task) {
-        return `Task not found: ${input.id}`;
+        return handleResolveError(input.id, matches, "Task");
       }
       const lines = [
         `ID: ${task.id}`,
@@ -154716,7 +157944,11 @@ Priority: ${task.priority}
 Description: ${task.description}`;
     },
     tasks_complete: async (input) => {
-      const task = await completeTask(context.cwd, input.id, input.result);
+      const { task: resolved, matches } = await resolveTaskId(context.cwd, input.id);
+      if (!resolved) {
+        return handleResolveError(input.id, matches, "Task");
+      }
+      const task = await completeTask(context.cwd, resolved.id, input.result);
       if (!task) {
         return `Task not found: ${input.id}`;
       }
@@ -154724,7 +157956,11 @@ Description: ${task.description}`;
 Result: ${input.result}` : ""}`;
     },
     tasks_fail: async (input) => {
-      const task = await failTask(context.cwd, input.id, input.error);
+      const { task: resolved, matches } = await resolveTaskId(context.cwd, input.id);
+      if (!resolved) {
+        return handleResolveError(input.id, matches, "Task");
+      }
+      const task = await failTask(context.cwd, resolved.id, input.error);
       if (!task) {
         return `Task not found: ${input.id}`;
       }
@@ -154755,7 +157991,7 @@ Error: ${input.error}` : ""}`;
         const nextRun = t9.nextRunAt ? new Date(t9.nextRunAt).toISOString() : "completed";
         const count = t9.recurrence?.occurrenceCount ?? 0;
         const statusIcon = t9.status === "pending" ? "\u25D0" : "\u25CF";
-        return `${statusIcon} ${t9.id.slice(0, 8)} - ${t9.description}
+        return `${statusIcon} ${t9.id} - ${t9.description}
    ${schedule} | next: ${nextRun} | runs: ${count}`;
       });
       return `Recurring Tasks (${recurring.length}):
@@ -154788,7 +158024,11 @@ Schedule: ${schedule}
 Next run: ${task.nextRunAt ? new Date(task.nextRunAt).toISOString() : "calculating..."}`;
     },
     tasks_recurring_cancel: async (input) => {
-      const task = await cancelRecurringTask(context.cwd, input.id);
+      const { task: resolved, matches } = await resolveTaskId(context.cwd, input.id, (t9) => t9.isRecurringTemplate === true);
+      if (!resolved) {
+        return handleResolveError(input.id, matches, "Recurring task");
+      }
+      const task = await cancelRecurringTask(context.cwd, resolved.id);
       if (!task) {
         return `Recurring task not found: ${input.id}`;
       }
@@ -155021,8 +158261,8 @@ await __promiseAll([
   init_config(),
   init_runtime()
 ]);
-import { join as join44, dirname as dirname18 } from "path";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17 } from "fs";
+import { join as join46, dirname as dirname20 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync19 } from "fs";
 var MAX_KEY_LENGTH2 = 256;
 var MAX_VALUE_SIZE = 65536;
 var MAX_SUMMARY_LENGTH2 = 500;
@@ -155035,10 +158275,10 @@ class GlobalMemoryManager {
   config;
   constructor(options = {}) {
     const baseDir = getConfigDir();
-    const path2 = options.dbPath || join44(baseDir, "memory.db");
-    const dir = dirname18(path2);
-    if (!existsSync27(dir)) {
-      mkdirSync17(dir, { recursive: true });
+    const path2 = options.dbPath || join46(baseDir, "memory.db");
+    const dir = dirname20(path2);
+    if (!existsSync29(dir)) {
+      mkdirSync19(dir, { recursive: true });
     }
     const runtime = getRuntime();
     this.db = runtime.openDatabase(path2);
@@ -156104,6 +159344,7 @@ ${hookResult.additionalContext}` : hookResult.additionalContext
     return new Promise((resolve5) => {
       const timerId = setTimeout(() => {
         this.activeTimeouts.delete(subassistantId);
+        this.activeRunners.delete(subassistantId);
         runner.stop();
         resolve5({
           success: false,
@@ -156441,8 +159682,8 @@ function createCapabilityChain(scope, capabilities) {
   };
 }
 // ../core/src/capabilities/storage.ts
-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 { existsSync as existsSync30, mkdirSync as mkdirSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
+import { join as join47, dirname as dirname21 } from "path";
 import { homedir as homedir22 } from "os";
 var DEFAULT_STORAGE_CONFIG = {
   enabled: true,
@@ -156463,14 +159704,14 @@ class CapabilityStorage {
       return this.config.storagePath;
     }
     const home = process.env.HOME || process.env.USERPROFILE || homedir22();
-    return join45(home, ".assistants", "capabilities", "store.json");
+    return join47(home, ".assistants", "capabilities", "store.json");
   }
   load() {
     if (!this.config.enabled)
       return;
     try {
       const path2 = this.getStoragePath();
-      if (!existsSync28(path2))
+      if (!existsSync30(path2))
         return;
       const data = JSON.parse(readFileSync18(path2, "utf-8"));
       if (data.chains) {
@@ -156490,9 +159731,9 @@ class CapabilityStorage {
       return;
     try {
       const path2 = this.getStoragePath();
-      const dir = dirname19(path2);
-      if (!existsSync28(dir)) {
-        mkdirSync18(dir, { recursive: true });
+      const dir = dirname21(path2);
+      if (!existsSync30(dir)) {
+        mkdirSync20(dir, { recursive: true });
       }
       const data = {
         version: 1,
@@ -156877,6 +160118,8 @@ class AssistantLoop {
   jobManager = null;
   messagesManager = null;
   webhooksManager = null;
+  channelsManager = null;
+  telephonyManager = null;
   memoryManager = null;
   memoryInjector = null;
   contextInjector = null;
@@ -156885,6 +160128,8 @@ class AssistantLoop {
   depth = 0;
   pendingMessagesContext = null;
   pendingWebhooksContext = null;
+  pendingChannelsContext = null;
+  pendingTelephonyContext = null;
   pendingMemoryContext = null;
   identityContext = null;
   projectContext = null;
@@ -157107,6 +160352,20 @@ class AssistantLoop {
         }
       });
     }
+    if (this.config?.channels?.enabled) {
+      const assistant = this.assistantManager?.getActive();
+      const assistantId = assistant?.id || this.sessionId;
+      const assistantName = assistant?.name || "assistant";
+      this.channelsManager = createChannelsManager(assistantId, assistantName, this.config.channels);
+      registerChannelTools(this.toolRegistry, () => this.channelsManager);
+    }
+    if (this.config?.telephony?.enabled) {
+      const assistant = this.assistantManager?.getActive();
+      const assistantId = assistant?.id || this.sessionId;
+      const assistantName = assistant?.name || "assistant";
+      this.telephonyManager = createTelephonyManager(assistantId, assistantName, this.config.telephony);
+      registerTelephonyTools(this.toolRegistry, () => this.telephonyManager);
+    }
     const memoryConfig = this.config?.memory;
     if (memoryConfig?.enabled !== false) {
       const assistant = this.assistantManager?.getActive();
@@ -157437,6 +160696,8 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
     try {
       await this.injectPendingMessages();
       await this.injectPendingWebhookEvents();
+      await this.injectPendingChannelMessages();
+      await this.injectPendingTelephonyMessages();
       await this.injectMemoryContext(userMessage);
       await this.injectContextInfo();
     } catch (error2) {
@@ -157494,7 +160755,7 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
               this.emit({
                 type: "show_panel",
                 panel: commandResult.showPanel,
-                panelValue: commandResult.panelInitialValue
+                panelValue: commandResult.panelValue
               });
             }
             if (commandResult.sessionAction) {
@@ -157531,7 +160792,7 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
               this.emit({
                 type: "show_panel",
                 panel: commandResult.showPanel,
-                panelValue: commandResult.panelInitialValue
+                panelValue: commandResult.panelValue
               });
             }
             return { ok: true, summary: `Handled ${userMessage}` };
@@ -158154,6 +161415,8 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
       getSecretsManager: () => this.secretsManager,
       getMessagesManager: () => this.messagesManager,
       getWebhooksManager: () => this.webhooksManager,
+      getChannelsManager: () => this.channelsManager,
+      getTelephonyManager: () => this.telephonyManager,
       getMemoryManager: () => this.memoryManager,
       refreshIdentityContext: async () => {
         if (this.identityManager) {
@@ -158393,6 +161656,10 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
     this.voiceManager?.stopListening();
     this.messagesManager?.stopWatching();
     this.webhooksManager?.stopWatching();
+    this.channelsManager?.close();
+    this.channelsManager = null;
+    this.telephonyManager?.close();
+    this.telephonyManager = null;
     this.memoryManager?.close();
     this.memoryManager = null;
     this.memoryInjector = null;
@@ -158458,12 +161725,21 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
   getIdentityManager() {
     return this.identityManager;
   }
+  getMemoryManager() {
+    return this.memoryManager;
+  }
   getMessagesManager() {
     return this.messagesManager;
   }
   getWebhooksManager() {
     return this.webhooksManager;
   }
+  getChannelsManager() {
+    return this.channelsManager;
+  }
+  getTelephonyManager() {
+    return this.telephonyManager;
+  }
   getWalletManager() {
     return this.walletManager;
   }
@@ -158696,7 +161972,7 @@ ${content.trim()}`);
     if (!heartbeatConfig)
       return;
     this.heartbeatRuntimeConfig = heartbeatConfig;
-    const statePath = join46(getConfigDir(), "state", `${this.sessionId}.json`);
+    const statePath = join48(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, {
@@ -158817,7 +162093,7 @@ ${content.trim()}`);
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join46(getConfigDir(), "energy", "state.json");
+    const statePath = join48(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -158901,6 +162177,52 @@ ${effects.message}
       this.pendingWebhooksContext = null;
     }
   }
+  async injectPendingChannelMessages() {
+    if (!this.channelsManager)
+      return;
+    try {
+      if (this.pendingChannelsContext) {
+        const previous = this.pendingChannelsContext.trim();
+        this.context.removeSystemMessages((content) => content.trim() === previous);
+        this.pendingChannelsContext = null;
+      }
+      const pending = this.channelsManager.getUnreadForInjection();
+      if (pending.length === 0) {
+        return;
+      }
+      this.pendingChannelsContext = this.channelsManager.buildInjectionContext(pending);
+      if (this.pendingChannelsContext) {
+        this.context.addSystemMessage(this.pendingChannelsContext);
+      }
+      this.channelsManager.markInjected(pending);
+    } catch (error2) {
+      console.error("Failed to inject pending channel messages:", error2);
+      this.pendingChannelsContext = null;
+    }
+  }
+  async injectPendingTelephonyMessages() {
+    if (!this.telephonyManager)
+      return;
+    try {
+      if (this.pendingTelephonyContext) {
+        const previous = this.pendingTelephonyContext.trim();
+        this.context.removeSystemMessages((content) => content.trim() === previous);
+        this.pendingTelephonyContext = null;
+      }
+      const pending = this.telephonyManager.getUnreadForInjection();
+      if (pending.length === 0) {
+        return;
+      }
+      this.pendingTelephonyContext = this.telephonyManager.buildInjectionContext(pending);
+      if (this.pendingTelephonyContext) {
+        this.context.addSystemMessage(this.pendingTelephonyContext);
+      }
+      this.telephonyManager.markInjected(pending);
+    } catch (error2) {
+      console.error("Failed to inject pending telephony messages:", error2);
+      this.pendingTelephonyContext = null;
+    }
+  }
   async injectMemoryContext(userMessage) {
     if (!this.memoryInjector || !this.memoryInjector.isEnabled())
       return;
@@ -159170,8 +162492,8 @@ ${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 ?? join46(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
-    const historyPath = config.heartbeat?.historyPath ?? join46(getConfigDir(), "heartbeats", "runs", `${this.sessionId}.jsonl`);
+    const persistPath = config.heartbeat?.persistPath ?? join48(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const historyPath = config.heartbeat?.historyPath ?? join48(getConfigDir(), "heartbeats", "runs", `${this.sessionId}.jsonl`);
     return {
       intervalMs,
       staleThresholdMs,
@@ -159560,9 +162882,9 @@ class StatsTracker {
   }
 }
 // ../core/src/tools/connector-index.ts
-import { join as join47, dirname as dirname20 } from "path";
+import { join as join49, dirname as dirname22 } from "path";
 import { homedir as homedir23 } from "os";
-import { existsSync as existsSync29, mkdirSync as mkdirSync19, writeFileSync as writeFileSync16, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync21, 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"],
@@ -159599,13 +162921,13 @@ class ConnectorIndex {
     return envHome && envHome.trim().length > 0 ? envHome : homedir23();
   }
   getCachePath() {
-    return join47(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
+    return join49(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
   }
   loadDiskCache() {
     ConnectorIndex.indexLoaded = true;
     try {
       const cachePath = this.getCachePath();
-      if (!existsSync29(cachePath))
+      if (!existsSync31(cachePath))
         return;
       const data = JSON.parse(readFileSync19(cachePath, "utf-8"));
       if (data.version !== INDEX_VERSION)
@@ -159621,9 +162943,9 @@ class ConnectorIndex {
   saveDiskCache() {
     try {
       const cachePath = this.getCachePath();
-      const cacheDir = dirname20(cachePath);
-      if (!existsSync29(cacheDir)) {
-        mkdirSync19(cacheDir, { recursive: true });
+      const cacheDir = dirname22(cachePath);
+      if (!existsSync31(cacheDir)) {
+        mkdirSync21(cacheDir, { recursive: true });
       }
       const data = {
         version: INDEX_VERSION,