npm - volute - Versions diffs - 0.45.1 → 0.45.2 - Mend

volute 0.45.1 → 0.45.2

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

Files changed (108) hide show

package/dist/web-assets/index.html CHANGED Viewed

@@ -8,7 +8,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Averia+Serif+Libre:wght@300;400;700&family=Fira+Code:wght@300;400;500;600&family=Averia+Sans+Libre:ital,wght@0,300;0,400;0,500;0,600;1,400&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-Dac11sKB.js"></script>
+    <script type="module" crossorigin src="/assets/index-Bc2m8gRC.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-B1JBQv2m.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.45.1",
+  "version": "0.45.2",
   "description": "CLI for creating and managing self-modifying AI minds powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",

package/templates/_base/src/lib/file-handler.ts CHANGED Viewed

@@ -25,11 +25,11 @@ export function createFileHandlerResolver(cwd: string): HandlerResolver {
   const resolvedCwd = resolve(cwd);
   return (filePath: string): MessageHandler => ({
-    handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+    handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
       const resolved = resolve(resolvedCwd, filePath);
       if (!resolved.startsWith(`${resolvedCwd}/`) && resolved !== resolvedCwd) {
         log("file", `rejected path traversal: ${filePath}`);
-        queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+        queueMicrotask(() => listener?.({ type: "done", messageId: meta.messageId }));
         return () => {};
       }
@@ -44,7 +44,7 @@ export function createFileHandlerResolver(cwd: string): HandlerResolver {
         }
       }
       // Emit done asynchronously so unsubscribe is assigned before listener fires
-      queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId: meta.messageId }));
       return () => {};
     },
   });

package/templates/_base/src/lib/router.ts CHANGED Viewed

@@ -191,7 +191,11 @@ export function createRouter(options: {
     instructions: string | undefined,
     sessionName: string,
   ): VoluteContentPart[] {
-    if (!instructions || instructedSessions.has(sessionName)) return content;
+    if (!instructions) return content;
+    // Ephemeral $new sessions get a unique name dispatched exactly once, so we
+    // always prepend and never track them — tracking would leak an entry per message.
+    if (sessionName.startsWith("new-")) return prependInstructions(content, instructions);
+    if (instructedSessions.has(sessionName)) return content;
     instructedSessions.add(sessionName);
     return prependInstructions(content, instructions);
   }
@@ -256,9 +260,9 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const handler = options.mindHandler(buffer.sessionName);
-    // Batch flushes are fire-and-forget — no HTTP response is waiting, so listener is a noop
+    // Batch flushes are fire-and-forget — no HTTP response is waiting, so no listener
     try {
-      handler.handle(content, { sessionName: buffer.sessionName, messageId }, () => {});
+      handler.handle(content, { sessionName: buffer.sessionName, messageId });
     } catch (err) {
       log("router", `error flushing batch for session ${buffer.sessionName}:`, err);
       return;
@@ -301,8 +305,6 @@ export function createRouter(options: {
     listener?: Listener,
   ): { messageId: string; unsubscribe: () => void } {
     const messageId = generateMessageId();
-    const noop = () => {};
-    const safeListener = listener ?? noop;
     // Expose session to child processes (daemon-client reads this for X-Volute-Session)
     process.env.VOLUTE_SESSION = session;
@@ -342,7 +344,7 @@ export function createRouter(options: {
         interrupt,
         replyInstructions: sessionConfig.replyInstructions,
       },
-      safeListener,
+      listener,
     );
     return { messageId, unsubscribe };
   }
@@ -368,7 +370,6 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const noop = () => {};
-    const safeListener = listener ?? noop;
     // Gate unmatched channels (default: gate unless explicitly disabled)
     if (!resolved.matched && config.gateUnmatched !== false) {
@@ -380,7 +381,7 @@ export function createRouter(options: {
       if (options.fileHandler) {
         const formatted = applyPrefix(content, meta);
         const fileHandler = options.fileHandler(filePath);
-        fileHandler.handle(formatted, { ...meta, messageId }, noop);
+        fileHandler.handle(formatted, { ...meta, messageId });
       }
       // First message from this channel — send invite notification
@@ -389,18 +390,14 @@ export function createRouter(options: {
         const notification = formatInviteNotification(meta, filePath, text);
         const notifContent: VoluteContentPart[] = [{ type: "text", text: notification }];
         const handler = options.mindHandler("main");
-        handler.handle(
-          notifContent,
-          {
-            sessionName: "main",
-            messageId: generateMessageId(),
-            interrupt: true,
-          },
-          noop,
-        );
+        handler.handle(notifContent, {
+          sessionName: "main",
+          messageId: generateMessageId(),
+          interrupt: true,
+        });
       }
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -411,7 +408,7 @@ export function createRouter(options: {
         const escaped = mindName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const pattern = new RegExp(`\\b${escaped}\\b`, "i");
         if (!pattern.test(text)) {
-          queueMicrotask(() => safeListener({ type: "done", messageId }));
+          queueMicrotask(() => listener?.({ type: "done", messageId }));
           return { messageId, unsubscribe: noop };
         }
       } else {
@@ -424,12 +421,12 @@ export function createRouter(options: {
       if (options.fileHandler) {
         const formatted = applyPrefix(content, meta);
         const handler = options.fileHandler(resolved.path);
-        const unsubscribe = handler.handle(formatted, { ...meta, messageId }, safeListener);
+        const unsubscribe = handler.handle(formatted, { ...meta, messageId }, listener);
         return { messageId, unsubscribe };
       }
       // No file handler configured — emit done and discard
       log("router", `no file handler configured — discarding file-destined message`);
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -473,7 +470,7 @@ export function createRouter(options: {
         scheduleBatchTimers(batchKey);
       }
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -495,7 +492,7 @@ export function createRouter(options: {
         interrupt: sessionConfig.interrupt,
         replyInstructions: sessionConfig.replyInstructions,
       },
-      safeListener,
+      listener,
     );
     return { messageId, unsubscribe };
   }
@@ -562,10 +559,9 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const handler = options.mindHandler(session);
-    const noop = () => {};
     try {
-      handler.handle(withInstructions, { sessionName: session, messageId }, noop);
+      handler.handle(withInstructions, { sessionName: session, messageId });
       log("router", `dispatched batch for session ${session}: ${allMessages.length} messages`);
     } catch (err) {
       log("router", `error dispatching batch for session ${session}:`, err);

package/templates/_base/src/lib/startup.ts CHANGED Viewed

@@ -28,6 +28,8 @@ export type MindConfig = {
   logLevel?: "error" | "warn" | "info" | "debug";
   compactionMessage?: string;
   compaction?: { maxContextTokens?: number };
+  /** Idle minutes before a session's SDK subprocess is reaped. 0 disables. Default 30. */
+  sessionIdleMinutes?: number;
   subagents?: Record<string, SubagentConfig>;
   // Template-specific config fields (claude, pi, codex)
   maxThinkingTokens?: number;

package/templates/_base/src/lib/types.ts CHANGED Viewed

@@ -50,9 +50,9 @@ export type VoluteEvent = { messageId?: string } & (
 export type Listener = (event: VoluteEvent) => void;
-/** A handler that processes a single routed message and emits events to a listener callback. */
+/** A handler that processes a single routed message and emits events to an optional listener callback. */
 export type MessageHandler = {
-  handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void; // returns unsubscribe
+  handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void; // returns unsubscribe
 };
 /** Resolves a key (session name, file path, etc.) to a MessageHandler. */

package/templates/claude/src/agent.ts CHANGED Viewed

@@ -21,6 +21,7 @@ import { createPreCompactHook } from "./lib/hooks/pre-compact.js";
 import { createReplyInstructionsHook } from "./lib/hooks/reply-instructions.js";
 import { log } from "./lib/logger.js";
 import { createMessageChannel } from "./lib/message-channel.js";
+import { isSessionReapable } from "./lib/session-reaper.js";
 import { createSessionStore } from "./lib/session-store.js";
 import { loadPrompts, type SubagentConfig } from "./lib/startup.js";
 import { consumeStream } from "./lib/stream-consumer.js";
@@ -45,6 +46,8 @@ type Session = {
   replyInstructionsFired: boolean;
   replyInstructionsMode: "once" | "always" | "never";
   contextTokens: number;
+  /** Last inbound message or completed turn — drives idle reaping. */
+  lastActivityAt: number;
 };
 export function createMind(options: {
@@ -58,6 +61,8 @@ export function createMind(options: {
   maxContextTokens?: number;
   subagents?: Record<string, SubagentConfig>;
   onIdentityReload?: () => Promise<void>;
+  /** Idle minutes before a session's SDK subprocess is reaped. 0 disables. Default 30. */
+  sessionIdleMinutes?: number;
 }): {
   resolve: HandlerResolver;
   waitForCommits: () => Promise<void>;
@@ -320,6 +325,7 @@ export function createMind(options: {
           // This turn's message is fully processed — drop it from the channel's
           // in-flight set so a later compaction abort won't re-feed it.
           session.channel.ack();
+          session.lastActivityAt = Date.now();
           await autoCommit.flushFileChanges();
           const wasCompacting = compactionTriggered.get(session.name);
           compactionTriggered.set(session.name, false);
@@ -478,16 +484,20 @@ export function createMind(options: {
             log("mind", `session "${session.name}": stream consumer error:`, retryErr);
             await emitError(retryErr);
             emitDone();
-            sessions.delete(session.name);
           }
         } else {
           log("mind", `session "${session.name}": stream consumer error:`, err);
           await emitError(err);
           emitDone();
-          sessions.delete(session.name);
         }
+      } finally {
+        // The stream consumer has ended (subprocess exit, error, or fresh-start
+        // abandonment) — drop the session so the sessions map doesn't retain dead
+        // entries. Matters most for ephemeral $new sessions once the idle reaper
+        // (#458) kills their subprocess, but also for any named session that ends.
+        sessions.delete(session.name);
+        log("mind", `session "${session.name}": stream consumer ended`);
       }
-      log("mind", `session "${session.name}": stream consumer ended`);
     })();
   }
@@ -504,6 +514,7 @@ export function createMind(options: {
       replyInstructionsFired: false,
       replyInstructionsMode: "once",
       contextTokens: 0,
+      lastActivityAt: Date.now(),
     };
     sessions.set(name, session);
@@ -526,18 +537,69 @@ export function createMind(options: {
     return session;
   }
+  // --- Idle session reaping ---
+  // Each session holds a resident SDK subprocess (~250MB) for its whole life.
+  // After the idle timeout, shut the subprocess down while keeping the session
+  // resumable: the session id is persisted, so the next inbound message
+  // transparently re-creates the session via getOrCreateSession's resume path.
+  const idleTimeoutMs = (options.sessionIdleMinutes ?? 30) * 60_000;
+  function reapSession(session: Session) {
+    log("mind", `session "${session.name}": idle — reaping SDK subprocess (resumable)`);
+    // Delete first so a racing inbound message spins up a fresh resumed session
+    // instead of reusing the one we're tearing down.
+    sessions.delete(session.name);
+    compactionTriggered.delete(session.name);
+    // Terminate the subprocess and end the input iterable so the stream consumer
+    // unwinds (its finally block also deletes from the map, now a no-op).
+    session.currentQuery?.close();
+    session.channel.close();
+    // Nothing should have raced in (isSessionReapable checked isEmpty), but if it
+    // did, re-dispatch into a fresh session so no input is dropped.
+    const pending = session.channel.recover();
+    if (pending.length > 0) {
+      const fresh = getOrCreateSession(session.name);
+      for (const msg of pending) fresh.channel.push(msg);
+    }
+  }
+  if (idleTimeoutMs > 0) {
+    log("mind", `idle session reaper: ${idleTimeoutMs / 60_000} min timeout`);
+    const checkMs = Math.min(60_000, idleTimeoutMs);
+    const reaper = setInterval(() => {
+      const now = Date.now();
+      const stale = [...sessions.values()].filter((s) =>
+        isSessionReapable(s, now, idleTimeoutMs, (name) => !!compactionTriggered.get(name)),
+      );
+      for (const session of stale) reapSession(session);
+    }, checkMs);
+    reaper.unref?.();
+  }
   // --- MessageHandler implementation ---
   function createSessionHandler(sessionName: string): MessageHandler {
     return {
-      handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+      handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
         const session = getOrCreateSession(sessionName);
-        // Filter listener to only receive events for this messageId
-        const filteredListener: Listener = (event) => {
-          if (event.messageId === meta.messageId) listener(event);
-        };
-        session.listeners.add(filteredListener);
+        // Only register a listener when a caller actually wants events. A per-message
+        // listener that's never removed would grow session.listeners without bound and
+        // make broadcastToSession O(messages-ever-received). The live dispatch path
+        // passes no listener, so this is usually a no-op.
+        let filteredListener: Listener | undefined;
+        if (listener) {
+          // Filter to only this messageId, and self-remove on the matching done so a
+          // caller that forgets to unsubscribe can't reintroduce the leak.
+          filteredListener = (event) => {
+            if (event.messageId !== meta.messageId) return;
+            listener(event);
+            if (event.type === "done" && filteredListener) {
+              session.listeners.delete(filteredListener);
+            }
+          };
+          session.listeners.add(filteredListener);
+        }
         // Track channel/sender for reply instructions
         if (meta.channel) {
@@ -559,6 +621,7 @@ export function createMind(options: {
         }
         // Push message into SDK
+        session.lastActivityAt = Date.now();
         session.messageIds.push(meta.messageId);
         session.channel.push({
           type: "user",
@@ -567,7 +630,9 @@ export function createMind(options: {
           parent_tool_use_id: null,
         });
-        return () => session.listeners.delete(filteredListener);
+        return () => {
+          if (filteredListener) session.listeners.delete(filteredListener);
+        };
       },
     };
   }

package/templates/claude/src/lib/message-channel.ts CHANGED Viewed

@@ -11,6 +11,14 @@ export type MessageChannel = {
    * compaction abort so in-flight input is never lost.
    */
   recover: () => SDKUserMessage[];
+  /**
+   * Terminate the input iterable: resolve any pending `next()` with `done: true`
+   * and make subsequent `next()` calls return done. The SDK sees end-of-input and
+   * shuts the query down. Used by the idle reaper to release the SDK subprocess.
+   */
+  close: () => void;
+  /** True when nothing is queued or in flight (no pending work). */
+  isEmpty: () => boolean;
   iterable: AsyncIterable<SDKUserMessage>;
 };
@@ -23,6 +31,7 @@ export function createMessageChannel(): MessageChannel {
   // re-feed the unprocessed ones instead of dropping them.
   const inFlight: SDKUserMessage[] = [];
   let resolve: ((value: IteratorResult<SDKUserMessage>) => void) | null = null;
+  let closed = false;
   function deliver(msg: SDKUserMessage): IteratorResult<SDKUserMessage> {
     inFlight.push(msg);
@@ -52,10 +61,24 @@ export function createMessageChannel(): MessageChannel {
       }
       return [...inFlight.splice(0), ...queue.splice(0)];
     },
+    close() {
+      closed = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined as any, done: true });
+      }
+    },
+    isEmpty() {
+      return queue.length === 0 && inFlight.length === 0;
+    },
     iterable: {
       [Symbol.asyncIterator]() {
         return {
           next(): Promise<IteratorResult<SDKUserMessage>> {
+            if (closed) {
+              return Promise.resolve({ value: undefined as any, done: true });
+            }
             if (queue.length > 0) {
               return Promise.resolve(deliver(queue.shift()!));
             }

package/templates/claude/src/lib/session-reaper.ts ADDED Viewed

@@ -0,0 +1,37 @@
+/**
+ * Idle-session reaping decision logic.
+ *
+ * Each mind session keeps a resident Claude SDK subprocess alive for as long as
+ * the session lives. When a session has been idle past the configured timeout it
+ * can be reaped — its subprocess shut down — while staying resumable, since the
+ * session id is persisted and the next inbound message re-creates it via resume.
+ */
+export interface ReapableSession {
+  name: string;
+  /** Timestamp (ms) of the last inbound message or completed turn. */
+  lastActivityAt: number;
+  /** Set while a turn is in progress; undefined between turns. */
+  currentMessageId?: string;
+  channel: { isEmpty(): boolean };
+}
+/**
+ * A session is reapable only when it has been idle longer than the timeout and
+ * has no work in progress: no turn running, no queued/in-flight input, and not
+ * mid-compaction (which owns its own abort/resume lifecycle).
+ */
+export function isSessionReapable(
+  session: ReapableSession,
+  now: number,
+  idleTimeoutMs: number,
+  isCompacting: (name: string) => boolean,
+): boolean {
+  if (idleTimeoutMs <= 0) return false;
+  return (
+    session.currentMessageId === undefined &&
+    session.channel.isEmpty() &&
+    !isCompacting(session.name) &&
+    now - session.lastActivityAt > idleTimeoutMs
+  );
+}

package/templates/claude/src/server.ts CHANGED Viewed

@@ -33,6 +33,7 @@ const mind = createMind({
   sessionsDir,
   compactionMessage: config.compactionMessage,
   maxContextTokens: config.compaction?.maxContextTokens,
+  sessionIdleMinutes: config.sessionIdleMinutes,
   subagents: config.subagents,
   onIdentityReload: async () => {
     log("server", "identity file changed — restarting to reload");

package/templates/codex/src/agent.ts CHANGED Viewed

@@ -558,13 +558,23 @@ export function createMind(options: {
   function createSessionHandler(sessionName: string): MessageHandler {
     return {
-      handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+      handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
         const session = getOrCreateSession(sessionName);
-        const filteredListener: Listener = (event) => {
-          if (event.messageId === meta.messageId) listener(event);
-        };
-        session.listeners.add(filteredListener);
+        // Only register a listener when a caller wants events. A per-message listener
+        // that's never removed grows session.listeners without bound and makes broadcast
+        // O(messages-ever-received). The live dispatch path passes no listener.
+        let filteredListener: Listener | undefined;
+        if (listener) {
+          filteredListener = (event) => {
+            if (event.messageId !== meta.messageId) return;
+            listener(event);
+            if (event.type === "done" && filteredListener) {
+              session.listeners.delete(filteredListener);
+            }
+          };
+          session.listeners.add(filteredListener);
+        }
         // Track channel for reply instructions
         if (meta.channel) {
@@ -586,7 +596,9 @@ export function createMind(options: {
           broadcast(session, { type: "done" });
         });
-        return () => session.listeners.delete(filteredListener);
+        return () => {
+          if (filteredListener) session.listeners.delete(filteredListener);
+        };
       },
     };
   }

package/templates/pi/src/agent.ts CHANGED Viewed

@@ -447,14 +447,23 @@ export function createMind(options: {
   function createSessionHandler(sessionName: string): MessageHandler {
     return {
-      handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+      handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
         const session = getOrCreateSession(sessionName);
-        // Filter listener to only receive events for this messageId
-        const filteredListener: Listener = (event) => {
-          if (event.messageId === meta.messageId) listener(event);
-        };
-        session.listeners.add(filteredListener);
+        // Only register a listener when a caller wants events. A per-message listener
+        // that's never removed grows session.listeners without bound and makes broadcast
+        // O(messages-ever-received). The live dispatch path passes no listener.
+        let filteredListener: Listener | undefined;
+        if (listener) {
+          filteredListener = (event) => {
+            if (event.messageId !== meta.messageId) return;
+            listener(event);
+            if (event.type === "done" && filteredListener) {
+              session.listeners.delete(filteredListener);
+            }
+          };
+          session.listeners.add(filteredListener);
+        }
         // Track channel for reply instructions
         if (meta.channel) {
@@ -500,7 +509,9 @@ export function createMind(options: {
           broadcast(session, { type: "done" });
         });
-        return () => session.listeners.delete(filteredListener);
+        return () => {
+          if (filteredListener) session.listeners.delete(filteredListener);
+        };
       },
     };
   }

package/dist/delivery-manager-R5STGLXB.js DELETED Viewed

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import {
-  DeliveryManager,
-  getDeliveryManager,
-  initDeliveryManager,
-  tryGetDeliveryManager
-} from "./chunk-U4FNXDEJ.js";
-import "./chunk-5GT7URXJ.js";
-import "./chunk-5AUKCNPE.js";
-import "./chunk-QLWG3C2Z.js";
-import "./chunk-Y6OPHHGM.js";
-import "./chunk-JSRMEY52.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-OXXTPILE.js";
-import "./chunk-HVU45COX.js";
-import "./chunk-ZIR7HSAX.js";
-import "./chunk-V4GYPD5L.js";
-import "./chunk-3ERIL673.js";
-import "./chunk-TSK5PI4L.js";
-import "./chunk-322KE457.js";
-import "./chunk-CYI534DJ.js";
-import "./chunk-ZMIMSIIT.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-H7IYFRAL.js";
-import "./chunk-ZV7MFISX.js";
-import "./chunk-K3NQKI34.js";
-export {
-  DeliveryManager,
-  getDeliveryManager,
-  initDeliveryManager,
-  tryGetDeliveryManager
-};

package/dist/echo-text-NQXYYYCU.js DELETED Viewed

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import {
-  clearEchoTextCache,
-  echoTextToChannel
-} from "./chunk-77BVGCTZ.js";
-import "./chunk-FHWUQZXE.js";
-import "./chunk-U4FNXDEJ.js";
-import "./chunk-5GT7URXJ.js";
-import "./chunk-5AUKCNPE.js";
-import "./chunk-QLWG3C2Z.js";
-import "./chunk-Y6OPHHGM.js";
-import "./chunk-JSRMEY52.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-OXXTPILE.js";
-import "./chunk-HVU45COX.js";
-import "./chunk-ZIR7HSAX.js";
-import "./chunk-V4GYPD5L.js";
-import "./chunk-Q2XBKQ2D.js";
-import "./chunk-3ERIL673.js";
-import "./chunk-TSK5PI4L.js";
-import "./chunk-322KE457.js";
-import "./chunk-CYI534DJ.js";
-import "./chunk-ZMIMSIIT.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-LGNUFVMR.js";
-import "./chunk-H7IYFRAL.js";
-import "./chunk-ZV7MFISX.js";
-import "./chunk-K3NQKI34.js";
-export {
-  clearEchoTextCache,
-  echoTextToChannel
-};

package/dist/message-delivery-IUAXRPFE.js DELETED Viewed

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-import {
-  deliverMessage,
-  linkToolResultToTurn,
-  recordInbound,
-  recordOutbound,
-  resolveSleepAction
-} from "./chunk-U4FNXDEJ.js";
-import "./chunk-5GT7URXJ.js";
-import "./chunk-5AUKCNPE.js";
-import "./chunk-QLWG3C2Z.js";
-import "./chunk-Y6OPHHGM.js";
-import "./chunk-JSRMEY52.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-OXXTPILE.js";
-import "./chunk-HVU45COX.js";
-import "./chunk-ZIR7HSAX.js";
-import "./chunk-V4GYPD5L.js";
-import "./chunk-3ERIL673.js";
-import "./chunk-TSK5PI4L.js";
-import "./chunk-322KE457.js";
-import "./chunk-CYI534DJ.js";
-import "./chunk-ZMIMSIIT.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-H7IYFRAL.js";
-import "./chunk-ZV7MFISX.js";
-import "./chunk-K3NQKI34.js";
-export {
-  deliverMessage,
-  linkToolResultToTurn,
-  recordInbound,
-  recordOutbound,
-  resolveSleepAction
-};