volute 0.38.0 → 0.40.0

package/templates/_base/src/lib/volute-server.ts

@@ -120,12 +120,17 @@ export type ContextInfo = {
   systemPrompt: number;
 };
 
+export type { ContextBlock, ContextMessage, ContextMessages } from "./context-breakdown.js";
+
+import type { ContextMessages } from "./context-breakdown.js";
+
 export function createVoluteServer(options: {
   router: Router;
   port: number;
   name: string;
   version: string;
   getContextInfo?: () => ContextInfo | Promise<ContextInfo>;
+  getContextMessages?: () => ContextMessages | Promise<ContextMessages>;
 }): Server {
   const { router, port, name, version } = options;
 
@@ -162,6 +167,24 @@ export function createVoluteServer(options: {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/context/messages") {
+      if (!options.getContextMessages) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      try {
+        const messages = await options.getContextMessages();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(messages));
+      } catch (err) {
+        log("server", "error in /context/messages:", err);
+        res.writeHead(500);
+        res.end("Internal Server Error");
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/message") {
       try {
         const body = JSON.parse(await readBody(req)) as VoluteRequest;

package/templates/claude/src/agent.ts

@@ -8,7 +8,9 @@ import {
   countSkillDescriptionTokens,
   countSystemPromptTokens,
   findClaudeSessionFile,
-  parseClaudeSessionJSONL,
+  processClaudeSession,
+  readSdkInstructions,
+  readSkillDescriptions,
 } from "./lib/context-breakdown.js";
 import { daemonEmit } from "./lib/daemon-client.js";
 import { runHooks } from "./lib/hook-loader.js";
@@ -30,7 +32,7 @@ import type {
   VoluteContentPart,
   VoluteEvent,
 } from "./lib/types.js";
-import type { ContextInfo } from "./lib/volute-server.js";
+import type { ContextInfo, ContextMessages } from "./lib/volute-server.js";
 
 type Session = {
   name: string;
@@ -60,6 +62,7 @@ export function createMind(options: {
   resolve: HandlerResolver;
   waitForCommits: () => Promise<void>;
   getContextInfo: () => ContextInfo;
+  getContextMessages: () => ContextMessages;
 } {
   const autoCommit = createAutoCommitHook(options.cwd);
   const identityReload = createIdentityReloadHook(options.cwd);
@@ -369,6 +372,17 @@ export function createMind(options: {
         });
       }
 
+      /**
+       * Tell the daemon this turn failed so it can record a notice for the mind's next
+       * successful turn. Awaited before emitDone so the daemon flags the session errored
+       * (and thus won't mark notices delivered) before the done arrives.
+       */
+      async function emitError(err: unknown) {
+        await daemonEmit({ type: "error", session: session.name, content: String(err) }).catch(
+          (e) => log("mind", `session "${session.name}": failed to emit error to daemon:`, e),
+        );
+      }
+
       async function runStream(resume?: string) {
         const q = createStream(session, streamAbort, preCompact.hook, resume);
         session.currentQuery = q;
@@ -428,11 +442,13 @@ export function createMind(options: {
             await runStream();
           } catch (retryErr) {
             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);
         }
@@ -543,26 +559,24 @@ export function createMind(options: {
   const claudeMdTokens = countSdkInstructionTokens(options.cwd);
   const skillDescTokens = countSkillDescriptionTokens([resolvePath(options.cwd, ".claude/skills")]);
 
+  function processSession(sessionName: string) {
+    const sessionId = sessionStore.load(sessionName);
+    const jsonlPath = sessionId ? findClaudeSessionFile(options.cwd, sessionId) : null;
+    return jsonlPath
+      ? processClaudeSession(jsonlPath, systemPromptTokens, claudeMdTokens, skillDescTokens)
+      : null;
+  }
+
   function getContextInfo(): ContextInfo {
     return {
       sessions: Array.from(sessions.values()).map((s) => {
         try {
-          const sessionId = sessionStore.load(s.name);
-          const jsonlPath = sessionId ? findClaudeSessionFile(options.cwd, sessionId) : null;
-          const parsed = jsonlPath
-            ? parseClaudeSessionJSONL(
-                jsonlPath,
-                systemPromptTokens,
-                claudeMdTokens,
-                skillDescTokens,
-              )
-            : null;
-
+          const result = processSession(s.name);
           return {
             name: s.name,
-            contextTokens: parsed?.contextTokens ?? s.contextTokens,
+            contextTokens: result?.parsed?.contextTokens ?? s.contextTokens,
             contextWindow: maxContextTokens,
-            breakdown: parsed?.breakdown,
+            breakdown: result?.parsed?.breakdown,
           };
         } catch (err) {
           log("mind", `failed to get context breakdown for session "${s.name}":`, err);
@@ -573,5 +587,29 @@ export function createMind(options: {
     };
   }
 
-  return { resolve, waitForCommits: autoCommit.waitForCommits, getContextInfo };
+  function getContextMessages(): ContextMessages {
+    const skillsDir = resolvePath(options.cwd, ".claude/skills");
+    return {
+      preamble: {
+        systemPrompt: options.systemPrompt,
+        sdkInstructions: readSdkInstructions(options.cwd),
+        skillDescriptions: readSkillDescriptions([skillsDir]),
+      },
+      sessions: Array.from(sessions.values()).map((s) => {
+        try {
+          const result = processSession(s.name);
+          return { name: s.name, messages: result?.messages ?? [] };
+        } catch (err) {
+          log("mind", `failed to extract messages for session "${s.name}":`, err);
+          return { name: s.name, messages: [] };
+        }
+      }),
+    };
+  }
+
+  // Pre-warm the main session so the SDK subprocess starts immediately
+  // instead of waiting for the first message (which adds minutes of latency).
+  getOrCreateSession("main");
+
+  return { resolve, waitForCommits: autoCommit.waitForCommits, getContextInfo, getContextMessages };
 }

package/templates/claude/src/server.ts

@@ -53,6 +53,7 @@ const server = createVoluteServer({
   name: pkg.name,
   version: pkg.version,
   getContextInfo: mind.getContextInfo,
+  getContextMessages: mind.getContextMessages,
 });
 
 server.listen(port, () => {

package/templates/codex/src/agent.ts

@@ -8,7 +8,9 @@ import {
   countSkillDescriptionTokens,
   countSystemPromptTokens,
   findCodexSessionFile,
-  parseCodexSessionJSONL,
+  processCodexSession,
+  readSdkInstructions,
+  readSkillDescriptions,
 } from "./lib/context-breakdown.js";
 import { daemonEmit, daemonRestart, type EventType } from "./lib/daemon-client.js";
 import { runHooks } from "./lib/hook-loader.js";
@@ -24,7 +26,7 @@ import type {
   VoluteContentPart,
   VoluteEvent,
 } from "./lib/types.js";
-import type { ContextInfo } from "./lib/volute-server.js";
+import type { ContextInfo, ContextMessages } from "./lib/volute-server.js";
 
 /** Minimal interface for a Codex SDK thread — typed to the methods we actually use */
 type CodexThread = {
@@ -73,7 +75,11 @@ export function createMind(options: {
   model?: string;
   reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
   maxContextTokens?: number;
-}): { resolve: HandlerResolver; getContextInfo: () => ContextInfo } {
+}): {
+  resolve: HandlerResolver;
+  getContextInfo: () => ContextInfo;
+  getContextMessages: () => ContextMessages;
+} {
   const sessions = new Map<string, CodexSession>();
   const prompts = loadPrompts();
   const maxContextTokens = options.maxContextTokens;
@@ -161,7 +167,11 @@ export function createMind(options: {
             model: options.model,
             modelReasoningEffort: options.reasoningEffort,
             skipGitRepoCheck: true,
+            // Codex's native seatbelt sandbox panics on macOS due to a bug in the
+            // system-configuration Rust crate (SCDynamicStore NULL object). Use full
+            // access until upstream ships a fix (mullvad/system-configuration-rs#59).
             sandboxMode: "danger-full-access",
+            networkAccessEnabled: true,
           });
           return;
         } catch (err) {
@@ -176,7 +186,9 @@ export function createMind(options: {
         model: options.model,
         modelReasoningEffort: options.reasoningEffort,
         skipGitRepoCheck: true,
+        // See comment in resumeThread above
         sandboxMode: "danger-full-access",
+        networkAccessEnabled: true,
       });
       log("mind", `session "${session.name}": new thread started`);
     } catch (err) {
@@ -593,21 +605,24 @@ export function createMind(options: {
   const claudeMdTokens = countSdkInstructionTokens(options.cwd);
   const skillDescTokens = countSkillDescriptionTokens([resolvePath(options.cwd, ".agents/skills")]);
 
+  function processSession(sessionName: string) {
+    const threadId = sessionStore.load(sessionName);
+    const jsonlPath = threadId ? findCodexSessionFile(threadId, options.mindDir) : null;
+    return jsonlPath
+      ? processCodexSession(jsonlPath, systemPromptTokens, claudeMdTokens, skillDescTokens)
+      : null;
+  }
+
   function getContextInfo(): ContextInfo {
     return {
       sessions: Array.from(sessions.values()).map((s) => {
         try {
-          const threadId = sessionStore.load(s.name);
-          const jsonlPath = threadId ? findCodexSessionFile(threadId) : null;
-          const parsed = jsonlPath
-            ? parseCodexSessionJSONL(jsonlPath, systemPromptTokens, claudeMdTokens, skillDescTokens)
-            : null;
-
+          const result = processSession(s.name);
           return {
             name: s.name,
-            contextTokens: parsed?.contextTokens ?? s.cumulativeInputTokens,
+            contextTokens: result?.parsed?.contextTokens ?? s.cumulativeInputTokens,
             contextWindow: maxContextTokens,
-            breakdown: parsed?.breakdown,
+            breakdown: result?.parsed?.breakdown,
           };
         } catch (err) {
           log("mind", `failed to get context breakdown for session "${s.name}":`, err);
@@ -622,5 +637,29 @@ export function createMind(options: {
     };
   }
 
-  return { resolve, getContextInfo };
+  function getContextMessages(): ContextMessages {
+    const skillsDir = resolvePath(options.cwd, ".agents/skills");
+    return {
+      preamble: {
+        systemPrompt: options.systemPrompt,
+        sdkInstructions: readSdkInstructions(options.cwd),
+        skillDescriptions: readSkillDescriptions([skillsDir]),
+      },
+      sessions: Array.from(sessions.values()).map((s) => {
+        try {
+          const result = processSession(s.name);
+          return { name: s.name, messages: result?.messages ?? [] };
+        } catch (err) {
+          log("mind", `failed to extract messages for session "${s.name}":`, err);
+          return { name: s.name, messages: [] };
+        }
+      }),
+    };
+  }
+
+  // Pre-warm the main session so the thread is created immediately
+  // instead of waiting for the first message.
+  getOrCreateSession("main");
+
+  return { resolve, getContextInfo, getContextMessages };
 }

package/templates/codex/src/server.ts

@@ -45,6 +45,7 @@ const server = createVoluteServer({
   name: pkg.name,
   version: pkg.version,
   getContextInfo: mind.getContextInfo,
+  getContextMessages: mind.getContextMessages,
 });
 
 server.listen(port, async () => {

package/templates/pi/src/agent.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, watchFile } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import {
   AuthStorage,
@@ -15,8 +15,11 @@ import {
   countSkillDescriptionTokens,
   countSystemPromptTokens,
   findPiSessionFile,
-  parsePiSessionJSONL,
+  processPiSession,
+  readSdkInstructions,
+  readSkillDescriptions,
 } from "./lib/context-breakdown.js";
+import { daemonEmit } from "./lib/daemon-client.js";
 import { createEventHandler, emit } from "./lib/event-handler.js";
 import { runHooks } from "./lib/hook-loader.js";
 import { log } from "./lib/logger.js";
@@ -32,7 +35,7 @@ import type {
   VoluteContentPart,
   VoluteEvent,
 } from "./lib/types.js";
-import type { ContextInfo } from "./lib/volute-server.js";
+import type { ContextInfo, ContextMessages } from "./lib/volute-server.js";
 
 type PiAgentSession = Awaited<ReturnType<typeof createAgentSession>>["session"];
 
@@ -57,7 +60,11 @@ export function createMind(options: {
   compactionMessage?: string;
   maxContextTokens?: number;
   subagents?: Record<string, SubagentConfig>;
-}): { resolve: HandlerResolver; getContextInfo: () => ContextInfo } {
+}): {
+  resolve: HandlerResolver;
+  getContextInfo: () => ContextInfo;
+  getContextMessages: () => ContextMessages;
+} {
   const sessions = new Map<string, PiSession>();
   const prompts = loadPrompts();
   const today = new Date().toLocaleDateString("en-CA");
@@ -77,6 +84,29 @@ export function createMind(options: {
   const authStorage = AuthStorage.create();
   const modelRegistry = ModelRegistry.create(authStorage);
 
+  // The daemon centrally refreshes the system OAuth token and rewrites auth.json
+  // with the fresh token. Watch the file and reload so a running mind adopts the
+  // new token without a restart (mirrors the Claude Agent SDK credential reload).
+  // This is why the mind itself does not refresh the rotating grant.
+  const piAuthPath = process.env.PI_CODING_AGENT_DIR
+    ? resolvePath(process.env.PI_CODING_AGENT_DIR, "auth.json")
+    : null;
+  if (piAuthPath) {
+    try {
+      watchFile(piAuthPath, { interval: 2000 }, (curr, prev) => {
+        if (curr.mtimeMs === prev.mtimeMs) return;
+        try {
+          authStorage.reload();
+          log("mind", "reloaded auth.json after credential refresh");
+        } catch (err) {
+          log("mind", "failed to reload auth.json:", err);
+        }
+      });
+    } catch (err) {
+      log("mind", "failed to watch auth.json for credential refresh:", err);
+    }
+  }
+
   // --- Subagents (config-driven) ---
 
   function loadSubagents(
@@ -457,8 +487,14 @@ export function createMind(options: {
           } else {
             session.agentSession.prompt(text, opts);
           }
-        })().catch((err) => {
+        })().catch(async (err) => {
           log("mind", `session "${sessionName}": prompt failed:`, err);
+          // Tell the daemon the turn failed (so it records a notice for the mind's next
+          // successful turn) before done, then complete the turn locally and on the daemon.
+          await daemonEmit({ type: "error", session: sessionName, content: String(err) }).catch(
+            () => {},
+          );
+          await daemonEmit({ type: "done", session: sessionName }).catch(() => {});
           broadcast(session, { type: "done" });
         });
 
@@ -489,20 +525,23 @@ export function createMind(options: {
   const claudeMdTokens = countSdkInstructionTokens(options.cwd);
   const skillDescTokens = countSkillDescriptionTokens([resolvePath(options.cwd, ".pi/skills")]);
 
+  function processSession(sessionName: string) {
+    const jsonlPath = findPiSessionFile(piSessionsDir, sessionName);
+    return jsonlPath
+      ? processPiSession(jsonlPath, systemPromptTokens, claudeMdTokens, skillDescTokens)
+      : null;
+  }
+
   function getContextInfo(): ContextInfo {
     return {
       sessions: Array.from(sessions.values()).map((s) => {
         try {
-          const jsonlPath = findPiSessionFile(piSessionsDir, s.name);
-          const parsed = jsonlPath
-            ? parsePiSessionJSONL(jsonlPath, systemPromptTokens, claudeMdTokens, skillDescTokens)
-            : null;
-
+          const result = processSession(s.name);
           return {
             name: s.name,
-            contextTokens: parsed?.contextTokens ?? s.contextTokens,
+            contextTokens: result?.parsed?.contextTokens ?? s.contextTokens,
             contextWindow: maxContextTokens,
-            breakdown: parsed?.breakdown,
+            breakdown: result?.parsed?.breakdown,
           };
         } catch (err) {
           log("mind", `failed to get context breakdown for session "${s.name}":`, err);
@@ -513,5 +552,25 @@ export function createMind(options: {
     };
   }
 
-  return { resolve, getContextInfo };
+  function getContextMessages(): ContextMessages {
+    const skillsDir = resolvePath(options.cwd, ".pi/skills");
+    return {
+      preamble: {
+        systemPrompt: options.systemPrompt,
+        sdkInstructions: readSdkInstructions(options.cwd),
+        skillDescriptions: readSkillDescriptions([skillsDir]),
+      },
+      sessions: Array.from(sessions.values()).map((s) => {
+        try {
+          const result = processSession(s.name);
+          return { name: s.name, messages: result?.messages ?? [] };
+        } catch (err) {
+          log("mind", `failed to extract messages for session "${s.name}":`, err);
+          return { name: s.name, messages: [] };
+        }
+      }),
+    };
+  }
+
+  return { resolve, getContextInfo, getContextMessages };
 }

package/templates/pi/src/server.ts

@@ -45,6 +45,7 @@ const server = createVoluteServer({
   name: pkg.name,
   version: pkg.version,
   getContextInfo: mind.getContextInfo,
+  getContextMessages: mind.getContextMessages,
 });
 
 server.listen(port, () => {

package/dist/chunk-KXXJYY62.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-import {
-  readGlobalConfig
-} from "./chunk-A6FLW5XD.js";
-import {
-  logger_default
-} from "./chunk-T2TP6ZC6.js";
-import {
-  getBaseName,
-  readRegistry,
-  voluteHome,
-  voluteSystemDir,
-  voluteUserHome
-} from "./chunk-2NHRJ3YO.js";
-
-// packages/daemon/src/lib/mind/sandbox.ts
-import { resolve } from "path";
-var slog = logger_default.child("sandbox");
-var sandboxManager = null;
-function isSandboxEnabled() {
-  if (process.env.VOLUTE_SANDBOX === "0") return false;
-  return readGlobalConfig().setup?.isolation === "sandbox";
-}
-async function initSandbox() {
-  if (!isSandboxEnabled()) return;
-  try {
-    const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
-    const config = {
-      network: {
-        allowedDomains: ["*"],
-        deniedDomains: [],
-        allowLocalBinding: true,
-        allowAllUnixSockets: true
-      },
-      filesystem: {
-        denyRead: [],
-        allowWrite: [],
-        denyWrite: []
-      }
-    };
-    await SandboxManager.initialize(config);
-    sandboxManager = SandboxManager;
-  } catch (err) {
-    slog.error(
-      "sandbox runtime not available \u2014 minds will run without sandbox isolation",
-      logger_default.errorData(err)
-    );
-  }
-}
-async function buildDenyRead(mindName, mindDir) {
-  const home = voluteHome();
-  const userHome = process.env.HOME || "";
-  const mindsDir = process.env.VOLUTE_MINDS_DIR || resolve(home, "minds");
-  const deny = [];
-  deny.push(voluteSystemDir());
-  const userVoluteHome = voluteUserHome();
-  if (userVoluteHome !== home) {
-    deny.push(userVoluteHome);
-  }
-  try {
-    const entries = await readRegistry();
-    for (const entry of entries) {
-      if (entry.name === await getBaseName(mindName)) continue;
-      const otherDir = resolve(mindsDir, entry.name);
-      if (otherDir !== mindDir) {
-        deny.push(otherDir);
-      }
-    }
-  } catch (err) {
-    slog.warn("failed to read minds registry for deny-read list", logger_default.errorData(err));
-  }
-  if (userHome) {
-    deny.push(resolve(userHome, ".ssh"));
-    deny.push(resolve(userHome, ".aws"));
-    deny.push(resolve(userHome, ".gnupg"));
-    deny.push(resolve(userHome, ".config"));
-  }
-  return deny;
-}
-function shellEscape(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-async function wrapForSandbox(cmd, args, mindDir, mindName, allowWrite) {
-  if (!sandboxManager) return [cmd, args];
-  const denyRead = await buildDenyRead(mindName, mindDir);
-  const customConfig = {
-    filesystem: {
-      denyRead,
-      allowWrite: allowWrite ?? [mindDir],
-      denyWrite: []
-    }
-  };
-  try {
-    const shellCmd = [cmd, ...args].map(shellEscape).join(" ");
-    const wrapped = await sandboxManager.wrapWithSandbox(shellCmd, void 0, customConfig);
-    return ["bash", ["-c", wrapped]];
-  } catch (err) {
-    slog.error(
-      `failed to sandbox mind ${mindName} \u2014 running without isolation`,
-      logger_default.errorData(err)
-    );
-    return [cmd, args];
-  }
-}
-
-export {
-  isSandboxEnabled,
-  initSandbox,
-  buildDenyRead,
-  shellEscape,
-  wrapForSandbox
-};

package/dist/delivery-manager-IMCRV6A3.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import {
-  DeliveryManager,
-  getDeliveryManager,
-  initDeliveryManager
-} from "./chunk-TEZRVSSB.js";
-import "./chunk-PMMHVSCR.js";
-import "./chunk-2TR2OPVA.js";
-import "./chunk-46DYYHN6.js";
-import "./chunk-VUM2K6EN.js";
-import "./chunk-5DPRTREW.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-KXXJYY62.js";
-import "./chunk-7AZQFSOV.js";
-import "./chunk-GVVVMZ4J.js";
-import "./chunk-3F7XK5Q7.js";
-import "./chunk-SNW2NPP4.js";
-import "./chunk-UIM5NHPP.js";
-import "./chunk-N42QMDID.js";
-import "./chunk-ORNY3MZR.js";
-import "./chunk-A6FLW5XD.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-2NHRJ3YO.js";
-import "./chunk-CJ26DXZL.js";
-import "./chunk-K3NQKI34.js";
-export {
-  DeliveryManager,
-  getDeliveryManager,
-  initDeliveryManager
-};

package/dist/down-5XZWH4ZP.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import {
-  run,
-  stopDaemon
-} from "./chunk-LN67VPZJ.js";
-import "./chunk-TXSA4Q3V.js";
-import "./chunk-O7IGP7ZW.js";
-import "./chunk-TNZ5XQA4.js";
-import "./chunk-3F7XK5Q7.js";
-import "./chunk-SNW2NPP4.js";
-import "./chunk-2NHRJ3YO.js";
-import "./chunk-CJ26DXZL.js";
-import "./chunk-K3NQKI34.js";
-export {
-  run,
-  stopDaemon
-};

package/dist/echo-text-ADKLNTIA.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import {
-  clearEchoTextCache,
-  echoTextToChannel
-} from "./chunk-PLL2FM7A.js";
-import "./chunk-LQ6Z4FXN.js";
-import "./chunk-TEZRVSSB.js";
-import "./chunk-PMMHVSCR.js";
-import "./chunk-2TR2OPVA.js";
-import "./chunk-46DYYHN6.js";
-import "./chunk-VUM2K6EN.js";
-import "./chunk-5DPRTREW.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-KXXJYY62.js";
-import "./chunk-7AZQFSOV.js";
-import "./chunk-GVVVMZ4J.js";
-import "./chunk-3F7XK5Q7.js";
-import "./chunk-SNW2NPP4.js";
-import "./chunk-UIM5NHPP.js";
-import "./chunk-N42QMDID.js";
-import "./chunk-ORNY3MZR.js";
-import "./chunk-A6FLW5XD.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-LGNUFVMR.js";
-import "./chunk-2NHRJ3YO.js";
-import "./chunk-CJ26DXZL.js";
-import "./chunk-K3NQKI34.js";
-export {
-  clearEchoTextCache,
-  echoTextToChannel
-};

package/dist/mind-manager-5G6P2EAT.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import {
-  MindManager,
-  getMindManager,
-  initMindManager
-} from "./chunk-TEZRVSSB.js";
-import "./chunk-PMMHVSCR.js";
-import "./chunk-2TR2OPVA.js";
-import "./chunk-46DYYHN6.js";
-import "./chunk-VUM2K6EN.js";
-import "./chunk-5DPRTREW.js";
-import "./chunk-CU6OFXMM.js";
-import "./chunk-KXXJYY62.js";
-import "./chunk-7AZQFSOV.js";
-import "./chunk-GVVVMZ4J.js";
-import "./chunk-3F7XK5Q7.js";
-import "./chunk-SNW2NPP4.js";
-import "./chunk-UIM5NHPP.js";
-import "./chunk-N42QMDID.js";
-import "./chunk-ORNY3MZR.js";
-import "./chunk-A6FLW5XD.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-2NHRJ3YO.js";
-import "./chunk-CJ26DXZL.js";
-import "./chunk-K3NQKI34.js";
-export {
-  MindManager,
-  getMindManager,
-  initMindManager
-};