volute 0.19.0 → 0.21.0

package/dist/{register-VSPCMHKX.js → register-U2UO6TC4.js}

@@ -8,11 +8,11 @@ import {
 import {
   readSystemsConfig,
   writeSystemsConfig
-} from "./chunk-FCDU5BFX.js";
+} from "./chunk-HFCBO2GL.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import "./chunk-EBGCNDMM.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/pages/register.ts
@@ -23,13 +23,13 @@ async function run(args) {
   });
   const existing = readSystemsConfig();
   if (existing) {
-    console.error(`Already registered as "${existing.system}". Run "volute logout" first.`);
+    console.error(`Already registered as "${existing.system}". Run "volute auth logout" first.`);
     process.exit(1);
   }
   let name = flags.name;
   if (!name) {
     if (!process.stdin.isTTY) {
-      console.error("Usage: volute pages register --name <system-name>");
+      console.error("Usage: volute auth register --name <system-name>");
       process.exit(1);
     }
     name = await promptLine("Choose a system name: ");
@@ -55,7 +55,7 @@ async function run(args) {
   } catch (err) {
     console.error(`Failed to save credentials: ${err.message}`);
     console.error(`Your API key is: ${apiKey}`);
-    console.error(`Save it and run: volute pages login --key ${apiKey}`);
+    console.error(`Save it and run: volute auth login --key ${apiKey}`);
     process.exit(1);
   }
   console.log(`Registered as "${system}". Credentials saved.`);

package/dist/registry-D2BSQ2X5.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import {
+  addMind,
+  daemonLoopback,
+  ensureVoluteHome,
+  findMind,
+  getRegistryCache,
+  initRegistryCache,
+  mindDir,
+  nextPort,
+  readRegistry,
+  removeMind,
+  resolveMind,
+  setMindRunning,
+  setMindStage,
+  setMindTemplateHash,
+  stateDir,
+  validateMindName,
+  voluteHome,
+  writeRegistry
+} from "./chunk-B2CPS4QU.js";
+import "./chunk-K3NQKI34.js";
+export {
+  addMind,
+  daemonLoopback,
+  ensureVoluteHome,
+  findMind,
+  getRegistryCache,
+  initRegistryCache,
+  mindDir,
+  nextPort,
+  readRegistry,
+  removeMind,
+  resolveMind,
+  setMindRunning,
+  setMindStage,
+  setMindTemplateHash,
+  stateDir,
+  validateMindName,
+  voluteHome,
+  writeRegistry
+};

package/dist/{restart-IQKMCK5M.js → restart-CIDAKGG2.js}

@@ -8,16 +8,13 @@ import {
 } from "./chunk-NAOW2CLO.js";
 import {
   daemonFetch
-} from "./chunk-WC6ZHVRL.js";
-import {
-  resolveMind
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-KFI7TQJ6.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/restart.ts
 async function run(args) {
   const name = resolveMindName({ mind: args[0] });
-  const { entry } = resolveMind(name);
   const client = getClient();
   const res = await daemonFetch(
     urlOf(client.api.minds[":name"].restart.$url({ param: { name } })),
@@ -28,7 +25,7 @@ async function run(args) {
     console.error(data.error || "Failed to restart mind");
     process.exit(1);
   }
-  console.log(`${name} restarted on port ${entry.port}`);
+  console.log(`${name} restarted on port ${data.port}`);
 }
 export {
   run

package/dist/{schedule-LMX7GAQZ.js → schedule-NLR3LZLY.js}

@@ -11,11 +11,12 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-WC6ZHVRL.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-KFI7TQJ6.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/schedule.ts
+import { CronExpressionParser } from "cron-parser";
 async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -42,6 +43,7 @@ function printUsage() {
   console.log(`Usage:
   volute schedule list [--mind <name>]
   volute schedule add [--mind <name>] --cron "..." --message "..." [--id name]
+  volute schedule add [--mind <name>] --cron "..." --script "..." [--id name]
   volute schedule remove [--mind <name>] --id <id>`);
 }
 async function listSchedules(args) {
@@ -65,10 +67,11 @@ async function listSchedules(args) {
   }
   const idW = Math.max(2, ...schedules.map((s) => s.id.length));
   const cronW = Math.max(4, ...schedules.map((s) => s.cron.length));
-  console.log(`${"ID".padEnd(idW)}  ${"CRON".padEnd(cronW)}  ENABLED  MESSAGE`);
+  const actionLabel = (s) => s.script ? `[script] ${s.script}` : s.message ?? "";
+  console.log(`${"ID".padEnd(idW)}  ${"CRON".padEnd(cronW)}  ENABLED  ACTION`);
   for (const s of schedules) {
     console.log(
-      `${s.id.padEnd(idW)}  ${s.cron.padEnd(cronW)}  ${String(s.enabled).padEnd(7)}  ${s.message}`
+      `${s.id.padEnd(idW)}  ${s.cron.padEnd(cronW)}  ${String(s.enabled).padEnd(7)}  ${actionLabel(s)}`
     );
   }
 }
@@ -77,14 +80,31 @@ async function addSchedule(args) {
     mind: { type: "string" },
     cron: { type: "string" },
     message: { type: "string" },
+    script: { type: "string" },
     id: { type: "string" }
   });
   const mind = resolveMindName(flags);
-  if (!flags.cron || !flags.message) {
-    console.error("--cron and --message are required");
+  if (!flags.cron) {
+    console.error("--cron is required");
     process.exit(1);
   }
-  const body = { cron: flags.cron, message: flags.message };
+  if (!flags.message && !flags.script) {
+    console.error("--message or --script is required");
+    process.exit(1);
+  }
+  if (flags.message && flags.script) {
+    console.error("--message and --script are mutually exclusive");
+    process.exit(1);
+  }
+  try {
+    CronExpressionParser.parse(flags.cron);
+  } catch {
+    console.error(`Invalid cron expression: ${flags.cron}`);
+    process.exit(1);
+  }
+  const body = { cron: flags.cron };
+  if (flags.message) body.message = flags.message;
+  if (flags.script) body.script = flags.script;
   if (flags.id) body.id = flags.id;
   const client = getClient();
   const res = await daemonFetch(

package/dist/{seed-J43YDKXG.js → seed-3H2MRREW.js}

@@ -15,13 +15,13 @@ async function run(args) {
   const name = positional[0];
   if (!name) {
     console.error(
-      "Usage: volute seed <name> [--template <name>] [--model <model>] [--description <text>] [--skills <list|none>]"
+      "Usage: volute mind seed <name> [--template <name>] [--model <model>] [--description <text>] [--skills <list|none>]"
     );
     process.exit(1);
   }
   const template = flags.template ?? "claude";
   const skills = flags.skills === "none" ? [] : flags.skills ? flags.skills.split(",") : void 0;
-  const { daemonFetch } = await import("./daemon-client-ITWUCNFO.js");
+  const { daemonFetch } = await import("./daemon-client-ZHCDL4RS.js");
   const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
   const client = getClient();
   const createRes = await daemonFetch(urlOf(client.api.minds.$url()), {

package/dist/{send-KVIZIGCE.js → send-RP2TA7SG.js}

@@ -6,19 +6,15 @@ import {
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
-import {
-  getChannelDriver
-} from "./chunk-UJ6GHNR7.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import "./chunk-RHEGSQFJ.js";
 import {
   daemonFetch
-} from "./chunk-WC6ZHVRL.js";
+} from "./chunk-KFI7TQJ6.js";
 import {
   findMind
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/send.ts
@@ -94,16 +90,88 @@ function loadImage(imagePath) {
   const data = readFileSync(imagePath).toString("base64");
   return { media_type: mediaType, data };
 }
+async function waitForResponse(mindName, conversationId, timeoutMs) {
+  const client = getClient();
+  const eventPath = urlOf(
+    client.api.minds[":name"].conversations[":id"].events.$url({
+      param: { name: mindName, id: conversationId }
+    })
+  );
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await daemonFetch(eventPath, {
+      signal: controller.signal
+    });
+  } catch {
+    clearTimeout(timeout);
+    console.error("Could not connect to event stream. Is the mind running?");
+    process.exit(1);
+  }
+  if (!response.body) {
+    clearTimeout(timeout);
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const chunks = buffer.split("\n\n");
+      buffer = chunks.pop();
+      for (const chunk of chunks) {
+        for (const line of chunk.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data) continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event.type === "message" && event.senderName === mindName && event.content) {
+            const text = event.content.filter((b) => b.type === "text" && !!b.text).map((b) => b.text).join("");
+            if (text) {
+              process.stdout.write(`${text}
+`);
+            }
+            return;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (err.name === "AbortError") {
+      console.error(`(timed out after ${timeoutMs / 1e3}s)`);
+    } else {
+      throw err;
+    }
+  } finally {
+    clearTimeout(timeout);
+    reader.cancel().catch(() => {
+    });
+  }
+}
 async function run(args) {
   const { positional, flags } = parseArgs(args, {
     mind: { type: "string" },
-    image: { type: "string" }
+    image: { type: "string" },
+    wait: { type: "boolean" },
+    timeout: { type: "number" },
+    sender: { type: "string" }
   });
   const target = positional[0];
   const message = positional[1] ?? await readStdin();
   const images = flags.image ? [loadImage(flags.image)] : void 0;
   if (!target || !message && !images) {
-    console.error('Usage: volute send <target> "<message>" [--mind <name>] [--image <path>]');
+    console.error(
+      'Usage: volute send <target> "<message>" [--mind <name>] [--image <path>] [--wait]'
+    );
     console.error('       echo "message" | volute send <target> [--mind <name>]');
     console.error("");
     console.error("Examples:");
@@ -112,6 +180,7 @@ async function run(args) {
     console.error('  volute send discord:server/channel "hello"');
     console.error('  volute send @mind "check this out" --image photo.png');
     console.error("  volute send @mind --image photo.png");
+    console.error('  volute send @mind "hello" --wait');
     process.exit(1);
   }
   if (target === "system" || target === "@system") {
@@ -130,44 +199,55 @@ To reply to a person, use their username from the message prefix (e.g. volute se
       isDM: true
     };
   }
-  const driver = getChannelDriver(parsed.platform);
-  if (!driver) {
-    console.error(`No driver for platform: ${parsed.platform}`);
-    process.exit(1);
-  }
+  const client = getClient();
+  let waitMindName;
   let channelUri = parsed.uri;
   if (parsed.isDM && parsed.platform === "volute") {
     const targetName = parsed.identifier.slice(1);
     const mindSelf = process.env.VOLUTE_MIND;
-    const sender = mindSelf || userInfo().username;
-    if (!driver.createConversation) {
-      console.error("Volute driver does not support creating conversations");
-      process.exit(1);
-    }
+    const sender = flags.sender || mindSelf || userInfo().username;
+    waitMindName = findMind(targetName) ? targetName : void 0;
     const targetIsMind = !!findMind(targetName);
     const contextMind = mindSelf && !targetIsMind ? mindSelf : targetName;
     const participants = mindSelf && !targetIsMind ? [targetName] : [sender];
-    const env = {
-      VOLUTE_MIND: contextMind,
-      VOLUTE_SENDER: sender
-    };
-    try {
-      channelUri = await driver.createConversation(env, participants);
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err));
+    const createRes = await daemonFetch(
+      urlOf(client.api.minds[":name"].channels.create.$url({ param: { name: contextMind } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ platform: "volute", participants, sender })
+      }
+    );
+    if (!createRes.ok) {
+      const data = await createRes.json().catch(() => ({ error: "Unknown error" }));
+      console.error(data.error);
       process.exit(1);
     }
-    try {
-      await driver.send(env, channelUri, message ?? "", images);
-      console.log("Message sent.");
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err));
+    const { slug } = await createRes.json();
+    channelUri = slug;
+    const sendRes = await daemonFetch(
+      urlOf(client.api.minds[":name"].channels.send.$url({ param: { name: contextMind } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          platform: "volute",
+          uri: channelUri,
+          message: message ?? "",
+          images,
+          sender
+        })
+      }
+    );
+    if (!sendRes.ok) {
+      const data = await sendRes.json().catch(() => ({ error: "Unknown error" }));
+      console.error(data.error);
       process.exit(1);
     }
+    if (!flags.wait) console.log("Message sent.");
     if (mindSelf) {
       try {
-        const client = getClient();
-        await daemonFetch(
+        const histRes = await daemonFetch(
           urlOf(client.api.minds[":name"].history.$url({ param: { name: mindSelf } })),
           {
             method: "POST",
@@ -175,13 +255,15 @@ To reply to a person, use their username from the message prefix (e.g. volute se
             body: JSON.stringify({ channel: parsed.uri, content: message ?? "" })
           }
         );
+        if (!histRes.ok) {
+          console.error(`Failed to persist to history: HTTP ${histRes.status}`);
+        }
       } catch (err) {
         console.error(`Failed to persist to history: ${err instanceof Error ? err.message : err}`);
       }
     }
   } else {
     const mindName = resolveMindName(flags);
-    const client = getClient();
     const res = await daemonFetch(
       urlOf(client.api.minds[":name"].channels.send.$url({ param: { name: mindName } })),
       {
@@ -200,10 +282,10 @@ To reply to a person, use their username from the message prefix (e.g. volute se
       console.error(body.error);
       process.exit(1);
     }
-    console.log("Message sent.");
+    if (!flags.wait) console.log("Message sent.");
     if (process.env.VOLUTE_MIND) {
       try {
-        await daemonFetch(
+        const histRes = await daemonFetch(
           urlOf(client.api.minds[":name"].history.$url({ param: { name: mindName } })),
           {
             method: "POST",
@@ -211,11 +293,25 @@ To reply to a person, use their username from the message prefix (e.g. volute se
             body: JSON.stringify({ channel: channelUri, content: message ?? "" })
           }
         );
+        if (!histRes.ok) {
+          console.error(`Failed to persist to history: HTTP ${histRes.status}`);
+        }
       } catch (err) {
         console.error(`Failed to persist to history: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
+  if (flags.wait && waitMindName) {
+    const conversationId = channelUri.startsWith("volute:") ? channelUri.slice(7) : void 0;
+    if (!conversationId) {
+      console.error("--wait requires a volute conversation (DM to a mind)");
+      process.exit(1);
+    }
+    await waitForResponse(waitMindName, conversationId, flags.timeout ?? 12e4);
+  } else if (flags.wait && !waitMindName) {
+    console.error("--wait is only supported when sending to a mind");
+    process.exit(1);
+  }
 }
 export {
   run

package/dist/{service-LUR7WDO7.js → service-TVNEORO7.js}

@@ -4,15 +4,15 @@ import {
   LAUNCHD_PLIST_PATH,
   SYSTEM_SERVICE_PATH,
   USER_SYSTEMD_UNIT
-} from "./chunk-32VR2EOH.js";
+} from "./chunk-QUJUKM4U.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   resolveVoluteBin
-} from "./chunk-DYZGP3EW.js";
-import "./chunk-OGXOMR65.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-IPJXU366.js";
+import "./chunk-NWPT4ASZ.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/service.ts
@@ -87,16 +87,20 @@ async function install(port, host) {
     console.log("Service installed and loaded. Volute daemon will start on login.");
   } else if (platform === "linux") {
     if (existsSync(SYSTEM_SERVICE_PATH)) {
-      console.error("A system-level Volute service is already installed (via `volute setup`).");
+      console.error(
+        "A system-level Volute service is already installed (via `volute service install --system`)."
+      );
       console.error("Use `systemctl status volute` to check its status.");
-      console.error("To remove it first: sudo volute setup uninstall");
+      console.error("To remove it first: sudo volute service uninstall --system");
       process.exit(1);
     }
     if (process.getuid?.() === 0) {
       console.error(
         "Error: `volute service install` uses systemd user services, which don't work as root."
       );
-      console.error("Use `volute setup` instead to install a system-level service.");
+      console.error(
+        "Use `volute service install --system` instead to install a system-level service."
+      );
       process.exit(1);
     }
     const path = USER_SYSTEMD_UNIT;
@@ -199,24 +203,38 @@ async function status() {
 async function run(args) {
   const { positional, flags } = parseArgs(args, {
     port: { type: "number" },
-    host: { type: "string" }
+    host: { type: "string" },
+    system: { type: "boolean" },
+    force: { type: "boolean" }
   });
   const subcommand = positional[0];
   switch (subcommand) {
     case "install":
-      await install(flags.port, flags.host);
+      if (flags.system) {
+        const setup = await import("./setup-OZDYCKDI.js");
+        setup.install(flags.port, flags.host);
+      } else {
+        await install(flags.port, flags.host);
+      }
       break;
     case "uninstall":
-      await uninstall();
+      if (flags.system) {
+        const setup = await import("./setup-OZDYCKDI.js");
+        setup.uninstall(!!flags.force);
+      } else {
+        await uninstall();
+      }
       break;
     case "status":
       await status();
       break;
     default:
       console.log(`Usage:
-  volute service install [--port N] [--host H]   Install as system service
-  volute service uninstall                        Remove system service
-  volute service status                           Check service status`);
+  volute service install [--port N] [--host H]          Install as user-level service
+  volute service install --system [--port N] [--host H] Install system service with user isolation
+  volute service uninstall                               Remove user-level service
+  volute service uninstall --system [--force]            Remove system service (--force removes data + users)
+  volute service status                                  Check service status`);
       if (subcommand) {
         console.error(`
 Unknown subcommand: ${subcommand}`);

package/dist/{setup-OH3PJUJO.js → setup-OZDYCKDI.js}

@@ -1,17 +1,14 @@
 #!/usr/bin/env node
 import {
   SYSTEM_SERVICE_PATH
-} from "./chunk-32VR2EOH.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
+} from "./chunk-QUJUKM4U.js";
 import {
   resolveVoluteBin
-} from "./chunk-DYZGP3EW.js";
+} from "./chunk-IPJXU366.js";
 import {
   ensureVoluteGroup
-} from "./chunk-OGXOMR65.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-NWPT4ASZ.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/setup.ts
@@ -80,11 +77,11 @@ function generateUnit(voluteBin, port, host) {
 function install(port, host) {
   if (host) validateHost(host);
   if (process.getuid?.() !== 0) {
-    console.error("Error: volute setup must be run as root (use sudo).");
+    console.error("Error: volute service install --system must be run as root (use sudo).");
     process.exit(1);
   }
   if (process.platform !== "linux") {
-    console.error("Error: volute setup is only supported on Linux.");
+    console.error("Error: volute service install --system is only supported on Linux.");
     console.error("On macOS, use `volute service install` for user-level service management.");
     process.exit(1);
   }
@@ -95,6 +92,22 @@ function install(port, host) {
   console.log(`Created ${MINDS_DIR}`);
   ensureVoluteGroup({ force: true });
   console.log("Ensured volute group exists");
+  try {
+    execFileSync("git", ["config", "--system", "user.name"]);
+    console.log("System git identity already configured, skipping");
+  } catch {
+    try {
+      execFileSync("git", ["config", "--system", "user.name", "Volute"]);
+      execFileSync("git", ["config", "--system", "user.email", "volute@localhost"]);
+      console.log("Configured system git identity");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`Warning: failed to set system git config: ${msg}`);
+      console.warn("Git commits by the daemon may fail. You can set this manually with:");
+      console.warn('  git config --system user.name "Volute"');
+      console.warn('  git config --system user.email "volute@localhost"');
+    }
+  }
   execFileSync("chmod", ["755", DATA_DIR]);
   execFileSync("chmod", ["755", MINDS_DIR]);
   console.log("Set permissions on directories");
@@ -148,7 +161,7 @@ Volute daemon is running. Data directory: ${DATA_DIR}`);
 }
 function uninstall(force) {
   if (process.getuid?.() !== 0) {
-    console.error("Error: volute setup uninstall must be run as root (use sudo).");
+    console.error("Error: volute service uninstall --system must be run as root (use sudo).");
     process.exit(1);
   }
   if (!existsSync(SYSTEM_SERVICE_PATH)) {
@@ -211,29 +224,7 @@ function uninstall(force) {
     console.log("Use --force to also remove data and system users.");
   }
 }
-async function run(args) {
-  const { positional, flags } = parseArgs(args, {
-    port: { type: "number" },
-    host: { type: "string" },
-    force: { type: "boolean" }
-  });
-  const subcommand = positional[0];
-  switch (subcommand) {
-    case "uninstall":
-      uninstall(!!flags.force);
-      break;
-    case void 0:
-      install(flags.port, flags.host);
-      break;
-    default:
-      console.log(`Usage:
-  volute setup [--port N] [--host H]     Install system-level service with user isolation
-  volute setup uninstall [--force]        Remove service (--force removes data + users)`);
-      console.error(`
-Unknown subcommand: ${subcommand}`);
-      process.exit(1);
-  }
-}
 export {
-  run
+  install,
+  uninstall
 };

package/dist/{shared-KO35ZM44.js → shared-DCQ2UXOM.js}

@@ -6,16 +6,16 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "merge":
-      await import("./merge-33C237A4.js").then((m) => m.run(args.slice(1)));
+      await import("./merge-B6SYTGI7.js").then((m) => m.run(args.slice(1)));
       break;
     case "pull":
-      await import("./pull-XAEWQJ47.js").then((m) => m.run(args.slice(1)));
+      await import("./pull-GRQAXM2E.js").then((m) => m.run(args.slice(1)));
       break;
     case "log":
-      await import("./log-PPPZDVEF.js").then((m) => m.run(args.slice(1)));
+      await import("./log-SRO5Q6AD.js").then((m) => m.run(args.slice(1)));
       break;
     case "status":
-      await import("./status-D7E5HHBV.js").then((m) => m.run(args.slice(1)));
+      await import("./status-5XDGYHKP.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":

package/dist/{skill-BCVNI6TV.js → skill-Q2Y6PQ3L.js}

@@ -11,8 +11,8 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-WC6ZHVRL.js";
-import "./chunk-EBGCNDMM.js";
+} from "./chunk-KFI7TQJ6.js";
+import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/skill.ts