volute 0.26.0 → 0.28.0

package/dist/chunk-KTLFDYPT.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/connectors/bridge-sdk.ts
+function loadBridgeEnv() {
+  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
+  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
+  const platform = process.env.VOLUTE_BRIDGE_PLATFORM;
+  if (!daemonUrl || !daemonToken || !platform) {
+    console.error(
+      "Missing required env vars: VOLUTE_DAEMON_URL, VOLUTE_DAEMON_TOKEN, VOLUTE_BRIDGE_PLATFORM"
+    );
+    process.exit(1);
+  }
+  return { daemonUrl, daemonToken, platform };
+}
+function getHeaders(env) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${env.daemonToken}`,
+    Origin: env.daemonUrl
+  };
+}
+async function sendToBridge(env, message) {
+  const url = `${env.daemonUrl}/api/bridges/${env.platform}/inbound`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(message)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`Bridge inbound returned ${res.status}: ${body}`);
+      return { ok: false, error: `Bridge returned ${res.status}` };
+    }
+    return await res.json();
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to send bridge message: ${detail}`);
+    return { ok: false, error: `Failed to reach daemon: ${detail}` };
+  }
+}
+function onShutdown(cleanup) {
+  const handler = () => {
+    Promise.resolve(cleanup()).then(
+      () => process.exit(0),
+      (err) => {
+        console.error(`Shutdown error: ${err}`);
+        process.exit(1);
+      }
+    );
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+
+export {
+  loadBridgeEnv,
+  sendToBridge,
+  onShutdown
+};

package/dist/{chunk-V63B7DX3.js → chunk-LAC664WU.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
   execInherit
-} from "./chunk-YJA7P64S.js";
+} from "./chunk-AW7PFDVN.js";
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/service-mode.ts
 import { execFileSync } from "child_process";
@@ -151,7 +152,9 @@ async function restartService(mode) {
   }
 }
 function readDaemonConfig() {
-  const configPath = resolve(voluteHome(), "daemon.json");
+  const newPath = resolve(voluteSystemDir(), "daemon.json");
+  const legacyPath = resolve(voluteHome(), "daemon.json");
+  const configPath = existsSync(newPath) ? newPath : legacyPath;
   if (!existsSync(configPath)) return { hostname: "127.0.0.1", port: 1618 };
   try {
     const config = JSON.parse(readFileSync(configPath, "utf-8"));

package/dist/chunk-MD4C26II.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import {
+  stateDir
+} from "./chunk-H7OZRFJB.js";
+
+// src/lib/file-sharing.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { basename, join, normalize, resolve } from "path";
+function validateFilePath(filePath) {
+  if (!filePath) return "File path is required";
+  const normalized = normalize(filePath);
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    return "Absolute paths are not allowed";
+  }
+  if (normalized.includes("..")) {
+    return "Path traversal (..) is not allowed";
+  }
+  return null;
+}
+function pendingDir(receiver) {
+  return resolve(stateDir(receiver), "pending-files");
+}
+function validateId(id) {
+  if (!id || id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error("Invalid pending file id");
+  }
+}
+function generateId(sender) {
+  const ts = Date.now();
+  const rand = randomBytes(2).toString("hex");
+  return `${sender}-${ts}-${rand}`;
+}
+function stageFile(receiver, sender, filename, content, originalPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const id = generateId(sender);
+  const dir = resolve(pendingDir(receiver), id);
+  mkdirSync(dir, { recursive: true });
+  const metadata = {
+    id,
+    sender,
+    filename: basename(filename),
+    originalPath,
+    size: content.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(resolve(dir, "metadata.json"), `${JSON.stringify(metadata, null, 2)}
+`);
+  writeFileSync(resolve(dir, "data"), content);
+  return { id };
+}
+function listPending(receiver) {
+  const dir = pendingDir(receiver);
+  if (!existsSync(dir)) return [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = resolve(dir, entry.name, "metadata.json");
+    if (!existsSync(metaPath)) continue;
+    try {
+      result.push(JSON.parse(readFileSync(metaPath, "utf-8")));
+    } catch (err) {
+      console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
+    }
+  }
+  return result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function getPending(receiver, id) {
+  validateId(id);
+  const metaPath = resolve(pendingDir(receiver), id, "metadata.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8"));
+  } catch (err) {
+    console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
+    return null;
+  }
+}
+function deliverFile(receiverDir, sender, filename, content, inboxPath) {
+  const err = validateFilePath(filename);
+  if (err) throw new Error(err);
+  const inbox = inboxPath ?? "inbox";
+  const inboxErr = validateFilePath(inbox);
+  if (inboxErr) throw new Error(`Invalid inboxPath: ${inboxErr}`);
+  if (sender.includes("/") || sender.includes("\\")) {
+    throw new Error("Invalid sender name");
+  }
+  const destDir = resolve(receiverDir, "home", inbox, sender);
+  mkdirSync(destDir, { recursive: true });
+  const destPath = resolve(destDir, basename(filename));
+  writeFileSync(destPath, content);
+  return join(inbox, sender, basename(filename));
+}
+function acceptPending(receiver, id, receiverDir, dest) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  const dataPath = resolve(pendingDir(receiver), id, "data");
+  const content = readFileSync(dataPath);
+  const inboxPath = dest ?? "inbox";
+  const destPath = deliverFile(receiverDir, meta.sender, meta.filename, content, inboxPath);
+  rmSync(resolve(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename, destPath };
+}
+function rejectPending(receiver, id) {
+  const meta = getPending(receiver, id);
+  if (!meta) throw new Error(`Pending file not found: ${id}`);
+  rmSync(resolve(pendingDir(receiver), id), { recursive: true });
+  return { sender: meta.sender, filename: meta.filename };
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export {
+  validateFilePath,
+  stageFile,
+  listPending,
+  acceptPending,
+  rejectPending,
+  formatFileSize
+};

package/dist/{chunk-USNBKHYG.js → chunk-NI5FFCCS.js}

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
-import {
-  getDb,
-  sharedSkills
-} from "./chunk-WBHMQ5OZ.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
   exec,
   gitExec
-} from "./chunk-YJA7P64S.js";
+} from "./chunk-AW7PFDVN.js";
 import {
+  getDb,
+  sharedSkills,
   voluteHome
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/skills.ts
 import { createHash } from "crypto";
@@ -30,7 +28,14 @@ import { basename, dirname, join, resolve } from "path";
 import { eq, sql } from "drizzle-orm";
 var VALID_SKILL_ID = /^[a-zA-Z0-9_-]+$/;
 var SEED_SKILLS = ["orientation", "memory"];
-var STANDARD_SKILLS = ["volute-mind", "memory", "sessions", "notes", "dreaming"];
+var STANDARD_SKILLS = [
+  "volute-mind",
+  "memory",
+  "sessions",
+  "notes",
+  "dreaming",
+  "shared-files"
+];
 function validateSkillId(id) {
   if (!id || !VALID_SKILL_ID.test(id)) {
     throw new Error(`Invalid skill ID: ${id}`);

package/dist/{chunk-3TV4GLFO.js → chunk-P72MVS4R.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-YUIHSKR6.js";
 import {
   gitExec
-} from "./chunk-YJA7P64S.js";
+} from "./chunk-AW7PFDVN.js";
 import {
   isIsolationEnabled,
   mindUserName
-} from "./chunk-XOXLRRR2.js";
+} from "./chunk-RKQEHRBB.js";
 import {
   voluteHome
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/shared.ts
 import { execFileSync } from "child_process";
@@ -178,50 +178,11 @@ async function sharedMerge(mindName, mindDir, message) {
     return { ok: true };
   });
 }
-async function sharedPull(mindName, mindDir) {
-  return withSharedLock(async () => {
-    const worktreePath = resolve(mindDir, "home", "shared");
-    const status = (await gitExec(["status", "--porcelain"], { cwd: worktreePath })).trim();
-    if (status) {
-      await gitExec(["add", "-A"], { cwd: worktreePath });
-      await gitExec(
-        ["commit", "--author", `${mindName} <${mindName}@volute>`, "-m", `wip: ${mindName}`],
-        { cwd: worktreePath }
-      );
-    }
-    try {
-      await gitExec(["rebase", "main"], { cwd: worktreePath });
-      rechownWorktree(worktreePath, mindName);
-      return { ok: true };
-    } catch {
-      try {
-        await gitExec(["rebase", "--abort"], { cwd: worktreePath });
-      } catch {
-        return {
-          ok: false,
-          message: "Rebase failed and abort failed \u2014 shared worktree may need manual repair"
-        };
-      }
-      return { ok: false, message: "Rebase failed \u2014 conflicts with main" };
-    }
-  });
-}
-async function sharedLog(limit = 20) {
-  const dir = sharedDir();
-  return gitExec(["log", "--oneline", "-n", String(limit), "main"], { cwd: dir });
-}
-async function sharedStatus(mindName) {
-  const dir = sharedDir();
-  return gitExec(["diff", `main...${mindName}`, "--stat"], { cwd: dir });
-}
 
 export {
   sharedDir,
   ensureSharedRepo,
   addSharedWorktree,
   removeSharedWorktree,
-  sharedMerge,
-  sharedPull,
-  sharedLog,
-  sharedStatus
+  sharedMerge
 };

package/dist/{chunk-2VO7453N.js → chunk-POSXWWTA.js}

@@ -2,32 +2,28 @@
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-UTL75LP6.js";
+} from "./chunk-J4IBNXGJ.js";
 import {
-  getDb,
-  mindHistory,
-  systemPrompts
-} from "./chunk-WBHMQ5OZ.js";
+  loadMergedEnv
+} from "./chunk-2WPW7OT6.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
-import {
-  loadMergedEnv
-} from "./chunk-PHU4DEAJ.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-XOXLRRR2.js";
+} from "./chunk-RKQEHRBB.js";
 import {
   findMind,
-  findVariant,
+  getDb,
   mindDir,
+  mindHistory,
   setMindRunning,
-  setVariantRunning,
   stateDir,
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  systemPrompts,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/daemon/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -144,7 +140,7 @@ Have a conversation with the human. Explore what kind of mind you want to be. Wh
     category: "mind"
   },
   reply_instructions: {
-    content: 'To reply to this message, use: volute send ${channel} "your message"',
+    content: 'To reply to this message, use: volute chat send ${channel} "your message"',
     description: "First-message reply hint injected via hook",
     variables: ["channel"],
     category: "mind"
@@ -160,7 +156,7 @@ Further messages will be saved to \${filePath}
 
 To accept, add to .config/routes.json:
   Rule: { "channel": "\${channel}", "session": "\${suggestedSession}" }
-\${batchRecommendation}To respond, use: volute send \${channel} "your message"
+\${batchRecommendation}To respond, use: volute chat send \${channel} "your message"
 To reject, delete \${filePath}`,
     description: "New channel notification template",
     variables: [
@@ -313,9 +309,6 @@ function revokeMindToken(mindName) {
 function resolveMindToken(token) {
   return tokenToMind.get(token) ?? null;
 }
-function getMindToken(mindName) {
-  return mindToToken.get(mindName) ?? null;
-}
 
 // src/lib/daemon/restart-tracker.ts
 var DEFAULT_MAX_ATTEMPTS = 5;
@@ -374,25 +367,23 @@ var MindManager = class {
   shuttingDown = false;
   restartTracker = new RestartTracker();
   pendingContext = /* @__PURE__ */ new Map();
-  resolveTarget(name) {
-    const [baseName, variantName] = name.split("@", 2);
-    const entry = findMind(baseName);
-    if (!entry) throw new Error(`Unknown mind: ${baseName}`);
-    if (variantName) {
-      const variant = findVariant(baseName, variantName);
-      if (!variant) throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
-      return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
+  async resolveTarget(name) {
+    const entry = await findMind(name);
+    if (!entry) throw new Error(`Unknown mind: ${name}`);
+    if (entry.parent) {
+      if (!entry.dir) throw new Error(`Variant ${name} has no directory`);
+      return { dir: entry.dir, port: entry.port, baseName: entry.parent };
     }
-    const dir = mindDir(baseName);
+    const dir = mindDir(name);
     if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
-    return { dir, port: entry.port, isVariant: false, baseName };
+    return { dir, port: entry.port, baseName: name };
   }
   async startMind(name) {
     if (this.minds.has(name)) {
       throw new Error(`Mind ${name} is already running`);
     }
-    const target = this.resolveTarget(name);
-    const { dir, isVariant, baseName, variantName } = target;
+    const target = await this.resolveTarget(name);
+    const { dir, baseName } = target;
     const port = target.port;
     const pidFile = mindPidPath(name);
     try {
@@ -463,7 +454,7 @@ var MindManager = class {
     let spawnCmd;
     let spawnArgs;
     if (isIsolationEnabled()) {
-      [spawnCmd, spawnArgs] = wrapForIsolation(tsxBin, tsxArgs, name);
+      [spawnCmd, spawnArgs] = await wrapForIsolation(tsxBin, tsxArgs, name);
     } else if (isSandboxEnabled()) {
       [spawnCmd, spawnArgs] = await wrapForSandbox(tsxBin, tsxArgs, dir, name);
     } else {
@@ -519,11 +510,7 @@ var MindManager = class {
     }
     if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     this.setupCrashRecovery(name, child);
-    if (isVariant) {
-      setVariantRunning(baseName, variantName, true);
-    } else {
-      setMindRunning(name, true);
-    }
+    await setMindRunning(name, true);
     mlog.info(`started mind ${name} on port ${port}`);
     await this.deliverPendingContext(name);
   }
@@ -581,7 +568,7 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady } = await import("./sleep-manager-EE4NRN2Q.js");
+        const { getSleepManagerIfReady } = await import("./sleep-manager-WMVG2VCL.js");
         const sleepState = getSleepManagerIfReady()?.getState(name);
         if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
@@ -590,20 +577,15 @@ var MindManager = class {
       } catch (err) {
         mlog.warn(`failed to check sleep state for ${name}`, logger_default.errorData(err));
       }
-      import("./mind-activity-tracker-4G6FURY2.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-ZMBAKLUF.js").then(
+      import("./mind-activity-tracker-EN6XNXPF.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-BBIEA2F4.js").then(
         ({ publish }) => publish({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
       const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
       this.saveCrashAttempts();
       if (!shouldRestart) {
         mlog.error(`${name} crashed ${attempt} times \u2014 giving up on restart`);
-        const [base, variant] = name.split("@", 2);
-        if (variant) {
-          setVariantRunning(base, variant, false);
-        } else {
-          setMindRunning(name, false);
-        }
+        await setMindRunning(name, false);
         return;
       }
       mlog.info(
@@ -643,12 +625,7 @@ var MindManager = class {
     if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     rmSync2(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
-      const [baseName, variantName] = name.split("@", 2);
-      if (variantName) {
-        setVariantRunning(baseName, variantName, false);
-      } else {
-        setMindRunning(name, false);
-      }
+      await setMindRunning(name, false);
     }
     mlog.info(`stopped mind ${name}`);
   }
@@ -668,7 +645,7 @@ var MindManager = class {
     return [...this.minds.keys()];
   }
   get crashAttemptsPath() {
-    return resolve(voluteHome(), "crash-attempts.json");
+    return resolve(voluteSystemDir(), "crash-attempts.json");
   }
   loadCrashAttempts() {
     this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
@@ -721,8 +698,6 @@ function getMindManager() {
 
 export {
   RotatingLog,
-  resolveMindToken,
-  getMindToken,
   RestartTracker,
   PROMPT_KEYS,
   PROMPT_DEFAULTS,
@@ -733,6 +708,7 @@ export {
   loadJsonMap,
   saveJsonMap,
   clearJsonMap,
+  resolveMindToken,
   MindManager,
   initMindManager,
   getMindManager

package/dist/{chunk-XOXLRRR2.js → chunk-RKQEHRBB.js}

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
+  getBaseName,
   validateMindName
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/isolation.ts
 import { execFileSync } from "child_process";
@@ -138,9 +139,9 @@ function deleteMindUser(name) {
   } catch {
   }
 }
-function wrapForIsolation(cmd, args, mindName) {
+async function wrapForIsolation(cmd, args, mindName) {
   if (!isIsolationEnabled()) return [cmd, args];
-  const baseName = mindName.split("@", 2)[0];
+  const baseName = await getBaseName(mindName);
   const user = mindUserName(baseName);
   if (process.platform === "darwin") {
     return ["sudo", ["-u", user, "--", cmd, ...args]];

package/dist/{chunk-LX22GRG7.js → chunk-SGVNFZHW.js}

@@ -4,16 +4,17 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-V63B7DX3.js";
+} from "./chunk-LAC664WU.js";
+import {
+  readGlobalConfig
+} from "./chunk-IKRVFPWU.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
-  readGlobalConfig
-} from "./chunk-TZKJLDQN.js";
-import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";
@@ -51,7 +52,8 @@ async function run(args) {
   const port = flags.port ?? config.port ?? 1618;
   const hostname = flags.host ?? config.hostname ?? "127.0.0.1";
   const home = voluteHome();
-  const pidPath = resolve(home, "daemon.pid");
+  const systemDir = voluteSystemDir();
+  const pidPath = resolve(systemDir, "daemon.pid");
   if (existsSync(pidPath)) {
     try {
       const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
@@ -103,7 +105,8 @@ async function run(args) {
     process.exit(1);
   }
   mkdirSync(home, { recursive: true });
-  const logFile = resolve(home, "daemon.log");
+  mkdirSync(systemDir, { recursive: true });
+  const logFile = resolve(systemDir, "daemon.log");
   const logFd = openSync(logFile, "a");
   const daemonArgs = [daemonModule, "--port", String(port), "--host", hostname];
   if (flags.tailscale) daemonArgs.push("--tailscale");

package/dist/chunk-T6HKBWXZ.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+// src/lib/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildVoluteSlug(opts) {
+  if (opts.convType === "channel" && opts.convName) {
+    return `volute:#${opts.convName}`;
+  }
+  const isDM = opts.participants.length === 2;
+  if (isDM) {
+    const other = opts.participants.find((p) => p.username !== opts.mindUsername);
+    const otherSlug = other ? slugify(other.username) : "";
+    return otherSlug ? `volute:@${otherSlug}` : `volute:${opts.conversationId}`;
+  }
+  return opts.convTitle ? `volute:${slugify(opts.convTitle)}` : `volute:${opts.conversationId}`;
+}
+
+export {
+  slugify,
+  buildVoluteSlug
+};

package/dist/{chunk-J2CO4WEV.js → chunk-VIVMW2H2.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import {
-  activity,
-  getDb
-} from "./chunk-WBHMQ5OZ.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
+import {
+  activity,
+  getDb
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/events/activity-events.ts
 var subscribers = /* @__PURE__ */ new Set();

package/dist/{chunk-KTJGZ7M7.js → chunk-XBLSAVJF.js}

@@ -2,7 +2,7 @@
 import {
   mindDir,
   stateDir
-} from "./chunk-B2CPS4QU.js";
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/archive.ts
 import { execFileSync } from "child_process";