volute 0.54.0 → 0.56.0

package/dist/{db-BONH4SUG.js → db-BQFYIONA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getDb
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{db-I4EH5SLF.js → db-JH3NTERX.js}

@@ -1,22 +1,36 @@
 #!/usr/bin/env node
 import {
+  areCommentsClosed,
+  citationsOf,
   getAllSites,
+  getLivePageFiles,
   getMindsWithSites,
+  getPage,
   getPublishedPages,
   getRecentPages,
   getSystemPages,
   initDb,
+  isSiteHome,
+  knownPageFiles,
   syncPublishedPages,
-  syncSystemPages
-} from "./chunk-AAPNU7GA.js";
+  syncSystemPages,
+  upsertPageWithTimestamps
+} from "./chunk-2GATCSZK.js";
 import "./chunk-K3NQKI34.js";
 export {
+  areCommentsClosed,
+  citationsOf,
   getAllSites,
+  getLivePageFiles,
   getMindsWithSites,
+  getPage,
   getPublishedPages,
   getRecentPages,
   getSystemPages,
   initDb,
+  isSiteHome,
+  knownPageFiles,
   syncPublishedPages,
-  syncSystemPages
+  syncSystemPages,
+  upsertPageWithTimestamps
 };

package/dist/delivery-manager-5EGCFN4K.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import {
+  DeliveryManager,
+  MAX_DELIVERY_ATTEMPTS,
+  UnknownChannelError,
+  formatSuggestions,
+  getDeliveryManager,
+  initDeliveryManager,
+  tryGetDeliveryManager
+} from "./chunk-IOMBP2T5.js";
+import "./chunk-PAO7JZNW.js";
+import "./chunk-TGYKFUCF.js";
+import "./chunk-CLH357FI.js";
+import "./chunk-Q5M5QFKY.js";
+import "./chunk-UMQP5TC5.js";
+import "./chunk-WTZD6LFW.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-IQROTVBG.js";
+import "./chunk-I3OJ342S.js";
+import "./chunk-FYMIGUJ5.js";
+import "./chunk-6LICEQGP.js";
+import "./chunk-MNKPAAQF.js";
+import "./chunk-CVPCRWWC.js";
+import "./chunk-NA2NJXY4.js";
+import "./chunk-OHHS5PSI.js";
+import "./chunk-E2SN3ZOJ.js";
+import "./chunk-2674KIGI.js";
+import "./chunk-LGNUFVMR.js";
+import "./chunk-TAVIVN2I.js";
+import "./chunk-2RNMBXD2.js";
+import "./chunk-K3NQKI34.js";
+export {
+  DeliveryManager,
+  MAX_DELIVERY_ATTEMPTS,
+  UnknownChannelError,
+  formatSuggestions,
+  getDeliveryManager,
+  initDeliveryManager,
+  tryGetDeliveryManager
+};

package/dist/{delivery-notices-RZQ6GONP.js → delivery-notices-LZKZXWTX.js}

@@ -3,12 +3,12 @@ import {
   COALESCE_WINDOW_MINUTES,
   recordDeliveryFailure,
   recordSenderDeliveryFailure
-} from "./chunk-3LHUXY3E.js";
-import "./chunk-HKGYZVWN.js";
-import "./chunk-LNNI3MS4.js";
-import "./chunk-OAYY3WF3.js";
-import "./chunk-QUSMYGNQ.js";
-import "./chunk-H6X6CKDN.js";
+} from "./chunk-IABDYN4N.js";
+import "./chunk-6LICEQGP.js";
+import "./chunk-MNKPAAQF.js";
+import "./chunk-CVPCRWWC.js";
+import "./chunk-2674KIGI.js";
+import "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{delivery-router-QS4NLJR6.js → delivery-router-U6Q22ZYU.js}

@@ -10,9 +10,9 @@ import {
   setRoutesChangeListener,
   shouldGate,
   warnUnknownRuleKeys
-} from "./chunk-YSRYCS3N.js";
-import "./chunk-QUSMYGNQ.js";
-import "./chunk-H6X6CKDN.js";
+} from "./chunk-IQROTVBG.js";
+import "./chunk-2674KIGI.js";
+import "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/doctor-225FYBAQ.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+import {
+  getAuthToken
+} from "./chunk-M74I3HHF.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-FNJCBRD3.js";
+import {
+  daemonLogSource,
+  getDaemonUrl,
+  getServiceMode,
+  modeLabel,
+  readDaemonConfig,
+  readLogTail
+} from "./chunk-OPTA3BJ4.js";
+import {
+  exec
+} from "./chunk-NA2NJXY4.js";
+import {
+  sharedEnvPath
+} from "./chunk-OHHS5PSI.js";
+import {
+  computeSetupStatus,
+  readGlobalConfig,
+  stateDir,
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-TAVIVN2I.js";
+import "./chunk-2RNMBXD2.js";
+import "./chunk-K3NQKI34.js";
+
+// packages/cli/src/commands/doctor.ts
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { statfs } from "fs/promises";
+import { arch, homedir, platform, release, tmpdir, type } from "os";
+import { delimiter, join, resolve } from "path";
+
+// packages/daemon/src/lib/doctor.ts
+import { sql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/libsql";
+var REDACTED = "[REDACTED]";
+var SECRET_KEY_RE = /(api[-_]?key|secret|token|password|passphrase|bearer|oauth|credential|private[-_]?key|client[-_]?secret|webhook|cookie|session|auth)/i;
+var SECRET_VALUE_RE = /(sk-[A-Za-z0-9]|sk_[A-Za-z0-9]|vmt_|vlt_|xox[baprs]-|gh[pousr]_|github_pat_|AKIA[0-9A-Z]{12}|-----BEGIN|eyJ[A-Za-z0-9_-]{10}|Bearer\s+\S)/;
+function looksLikeOpaqueToken(s) {
+  return s.length >= 40 && /^[A-Za-z0-9+/=_-]+$/.test(s);
+}
+function looksLikeSecretString(s) {
+  return SECRET_VALUE_RE.test(s) || looksLikeOpaqueToken(s);
+}
+function maskAllValues(obj) {
+  const out = {};
+  for (const k of Object.keys(obj)) out[k] = REDACTED;
+  return out;
+}
+function redactValue(value, key) {
+  if (key !== void 0 && SECRET_KEY_RE.test(key)) return REDACTED;
+  if (Array.isArray(value)) return value.map((v) => redactValue(v));
+  if (value !== null && typeof value === "object") {
+    if (key === "env") return maskAllValues(value);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = redactValue(v, k);
+    return out;
+  }
+  if (typeof value === "string" && looksLikeSecretString(value)) return REDACTED;
+  return value;
+}
+function redactConfigJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return "[config.json could not be parsed \u2014 omitted so no secret can leak]\n";
+  }
+  return `${JSON.stringify(redactValue(parsed), null, 2)}
+`;
+}
+function redactEnvJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return "[env.json could not be parsed \u2014 omitted so no secret can leak]\n";
+  }
+  return `${JSON.stringify(maskAllValues(parsed), null, 2)}
+`;
+}
+var LOG_SCRUBBERS = [
+  // key=value / key: value where the key names a credential — keep the key, mask the value.
+  [
+    /\b(api[_-]?key|secret|token|password|passwd|pwd|bearer|authorization|credential|access[_-]?key(?:[_-]?id)?|secret[_-]?access[_-]?key|refresh[_-]?token)\b(\s*[=:]\s*)"?([^\s"',}]+)/gi,
+    `$1$2${REDACTED}`
+  ],
+  // Authorization: Bearer <token>
+  [/\bBearer\s+[A-Za-z0-9._-]+/gi, `Bearer ${REDACTED}`],
+  // Standalone tokens by known prefix/shape, wherever they appear.
+  [
+    /\b(sk-[A-Za-z0-9-]{6,}|sk_[A-Za-z0-9-]{6,}|vmt_[A-Za-z0-9-]{6,}|vlt_[A-Za-z0-9-]{6,}|xox[baprs]-[A-Za-z0-9-]+|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]+|AKIA[0-9A-Z]{12,}|eyJ[A-Za-z0-9._-]{10,})\b/g,
+    REDACTED
+  ]
+];
+function redactLogText(text) {
+  let out = text;
+  for (const [re, replacement] of LOG_SCRUBBERS) out = out.replace(re, replacement);
+  return out;
+}
+async function readMigrationInfo(dbPath2) {
+  try {
+    const db = drizzle({ connection: { url: `file:${dbPath2}` } });
+    const rows = await db.all(
+      sql.raw("SELECT count(*) AS n, max(created_at) AS latest FROM __drizzle_migrations")
+    );
+    const row = rows[0];
+    return { ok: true, applied: Number(row?.n ?? 0), latestMillis: row?.latest ?? null };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function readMindsBasic(dbPath2) {
+  try {
+    const db = drizzle({ connection: { url: `file:${dbPath2}` } });
+    const rows = await db.all(
+      sql.raw("SELECT name, running, parent FROM minds ORDER BY name")
+    );
+    return rows.map((r) => ({ name: r.name, running: r.running === 1, parent: r.parent }));
+  } catch {
+    return [];
+  }
+}
+
+// packages/cli/src/commands/doctor.ts
+var ICON = { pass: "\u2713", fail: "\u2717", warn: "\u26A0" };
+var MAC_CHROME_CANDIDATES = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+];
+var PATH_CHROME_CANDIDATES = [
+  "google-chrome",
+  "google-chrome-stable",
+  "chromium",
+  "chromium-browser",
+  "brave-browser",
+  "microsoft-edge"
+];
+function isExecutable(p) {
+  try {
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findChromeBrowser() {
+  const override = process.env.VOLUTE_CHROMIUM;
+  if (override) return override;
+  if (platform() === "darwin") {
+    for (const candidate of MAC_CHROME_CANDIDATES) {
+      if (isExecutable(candidate)) return candidate;
+    }
+    return null;
+  }
+  const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const name of PATH_CHROME_CANDIDATES) {
+    for (const dir of dirs) {
+      const full = join(dir, name);
+      if (isExecutable(full)) return full;
+    }
+  }
+  return null;
+}
+function dbPath() {
+  return process.env.VOLUTE_DB_PATH || resolve(voluteSystemDir(), "volute.db");
+}
+function humanBytes(n) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v >= 10 || i === 0 ? 0 : 1)}${units[i]}`;
+}
+function bundleStamp(d = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+function daemonBaseUrl() {
+  const { port, internalPort } = readDaemonConfig();
+  return getDaemonUrl("127.0.0.1", internalPort ?? port);
+}
+async function fetchDaemonJson(path) {
+  const base = daemonBaseUrl();
+  const headers = { Origin: base };
+  const token = getAuthToken();
+  if (token) headers.Authorization = `Bearer ${token}`;
+  try {
+    const res = await fetch(`${base}${path}`, { headers, signal: AbortSignal.timeout(3e3) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function runDiagnostics() {
+  const checks = [];
+  const config = readGlobalConfig();
+  const health = await fetchDaemonJson("/api/health");
+  const daemonUp = !!health?.ok;
+  if (health?.ok) {
+    checks.push({
+      label: "Daemon reachable",
+      state: "pass",
+      detail: `${daemonBaseUrl()}${health.version ? ` (v${health.version})` : ""}`
+    });
+  } else {
+    checks.push({
+      label: "Daemon reachable",
+      state: "fail",
+      detail: `no response at ${daemonBaseUrl()} \u2014 start it with \`volute up\``
+    });
+  }
+  const setupState = computeSetupStatus(config);
+  const providers = Object.keys(config.ai?.providers ?? {});
+  if (setupState === "complete" && providers.length > 0) {
+    checks.push({ label: "Setup complete", state: "pass" });
+  } else if (setupState === "complete") {
+    checks.push({
+      label: "Setup complete",
+      state: "warn",
+      detail: "setup finished but no AI provider is configured"
+    });
+  } else {
+    checks.push({
+      label: "Setup complete",
+      state: "fail",
+      detail: setupState === "in-progress" ? "setup started but not finished" : "run `volute setup`"
+    });
+  }
+  checks.push(
+    providers.length > 0 ? { label: "Provider config present", state: "pass", detail: providers.sort().join(", ") } : { label: "Provider config present", state: "fail", detail: "no providers configured" }
+  );
+  const path = dbPath();
+  if (!existsSync(path)) {
+    checks.push({ label: "Database", state: "warn", detail: "no volute.db yet (fresh install?)" });
+  } else {
+    const info = await readMigrationInfo(path);
+    if (info.ok) {
+      checks.push({
+        label: "Database",
+        state: "pass",
+        detail: `opens OK, ${info.applied} migration${info.applied === 1 ? "" : "s"} applied`
+      });
+    } else {
+      checks.push({ label: "Database", state: "fail", detail: info.error });
+    }
+  }
+  checks.push({ label: "Node version", state: "pass", detail: process.version });
+  const npmVersion = await exec("npm", ["--version"]).then((s) => s.trim()).catch(() => null);
+  checks.push(
+    npmVersion ? { label: "npm version", state: "pass", detail: npmVersion } : { label: "npm version", state: "warn", detail: "npm not found on PATH" }
+  );
+  checks.push({ label: "Install type", state: "pass", detail: modeLabel(getServiceMode()) });
+  const isolation = config.setup?.isolation;
+  checks.push(
+    isolation ? { label: "Isolation mode", state: "pass", detail: isolation } : { label: "Isolation mode", state: "warn", detail: "not configured (none)" }
+  );
+  const chromePath = findChromeBrowser();
+  checks.push(
+    chromePath ? { label: "Chrome (pages preview)", state: "pass", detail: chromePath } : {
+      label: "Chrome (pages preview)",
+      state: "warn",
+      detail: "no Chrome-family browser found \u2014 `volute pages preview` won't work"
+    }
+  );
+  try {
+    const home = voluteHome();
+    const st = await statfs(existsSync(home) ? home : homedir());
+    const free = Number(st.bavail) * Number(st.bsize);
+    const total = Number(st.blocks) * Number(st.bsize);
+    const pctFree = total > 0 ? free / total * 100 : 0;
+    checks.push({
+      label: "Disk space",
+      state: pctFree < 5 ? "warn" : "pass",
+      detail: `${humanBytes(free)} free of ${humanBytes(total)} (${pctFree.toFixed(0)}%)`
+    });
+  } catch (err) {
+    checks.push({
+      label: "Disk space",
+      state: "warn",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const daemonMinds = await fetchDaemonJson("/api/minds");
+  if (daemonMinds) {
+    if (daemonMinds.length === 0) {
+      checks.push({ label: "Minds", state: "pass", detail: "none configured" });
+    } else {
+      for (const m of daemonMinds) {
+        const status = m.status ?? (m.running ? "running" : "stopped");
+        const failed = m.lastError ? " (last turn failed)" : "";
+        const state = status === "running" || status === "sleeping" ? "pass" : m.lastError ? "fail" : "warn";
+        checks.push({ label: `Mind: ${m.name}`, state, detail: `${status}${failed}` });
+      }
+    }
+  } else {
+    const why = daemonUp ? "not authenticated \u2014 try `volute login`" : "daemon unreachable";
+    const rows = existsSync(path) ? await readMindsBasic(path) : [];
+    if (rows.length === 0) {
+      checks.push({ label: "Minds", state: "warn", detail: `${why}; none in registry` });
+    } else {
+      for (const m of rows) {
+        checks.push({
+          label: `Mind: ${m.name}`,
+          state: "warn",
+          detail: `${m.running ? "running?" : "stopped"} (${why} \u2014 registry value)`
+        });
+      }
+    }
+  }
+  return { checks, daemonMinds };
+}
+function renderReport(checks) {
+  const lines = ["volute doctor", "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550", ""];
+  const width = Math.max(...checks.map((c) => c.label.length));
+  for (const c of checks) {
+    const detail = c.detail ? `  ${c.detail}` : "";
+    lines.push(`${ICON[c.state]} ${c.label.padEnd(width)}${detail}`);
+  }
+  const failed = checks.filter((c) => c.state === "fail").length;
+  const warned = checks.filter((c) => c.state === "warn").length;
+  lines.push("");
+  lines.push(
+    failed === 0 && warned === 0 ? "All checks passed." : `${failed} failed, ${warned} warning${warned === 1 ? "" : "s"}.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function systemInfo() {
+  return [
+    `date:         ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `os:           ${type()} ${release()} (${platform()}/${arch()})`,
+    `node:         ${process.version}`,
+    `install type: ${modeLabel(getServiceMode())}`,
+    `isolation:    ${readGlobalConfig().setup?.isolation ?? "none"}`,
+    `volute home:  ${voluteHome()}`
+  ].join("\n");
+}
+async function captureStatus() {
+  const self = process.argv[1];
+  try {
+    return await exec(process.execPath, [...process.execArgv, self, "status"]);
+  } catch (err) {
+    const e = err;
+    return e.stdout || e.stderr || `(volute status failed: ${err instanceof Error ? err.message : err})`;
+  }
+}
+async function writeBundle(report, minds) {
+  const stamp = bundleStamp();
+  const stage = mkdtempSync(resolve(tmpdir(), "volute-doctor-"));
+  const root = resolve(stage, `volute-doctor-${stamp}`);
+  mkdirSync(root, { recursive: true });
+  const write = (rel, content) => {
+    const dest = resolve(root, rel);
+    mkdirSync(resolve(dest, ".."), { recursive: true });
+    writeFileSync(dest, content);
+  };
+  write("report.txt", report);
+  write("system.txt", `${systemInfo()}
+`);
+  write("status.txt", redactLogText(await captureStatus()));
+  const cfgPath = resolve(voluteSystemDir(), "config.json");
+  if (existsSync(cfgPath)) {
+    write("config.json", redactConfigJson(readFileSync(cfgPath, "utf-8")));
+  }
+  const envPath = sharedEnvPath();
+  if (existsSync(envPath)) {
+    write("env.json", redactEnvJson(readFileSync(envPath, "utf-8")));
+  }
+  const src = daemonLogSource(getServiceMode());
+  if (src.kind === "file") {
+    write("logs/daemon.log", redactLogText(`${readLogTail(src.path, 200).join("\n")}
+`));
+  } else {
+    const journal = await exec("sh", ["-c", src.command]).catch(
+      (err) => `(could not read journal: ${err instanceof Error ? err.message : err})`
+    );
+    write("logs/daemon.log", redactLogText(journal));
+  }
+  const path = dbPath();
+  const listed = minds ? minds.map((m) => m.name) : existsSync(path) ? (await readMindsBasic(path)).map((m) => m.name) : [];
+  const stateRoot = resolve(voluteSystemDir(), "state");
+  const fromState = existsSync(stateRoot) ? readdirSync(stateRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : [];
+  const mindNames = [.../* @__PURE__ */ new Set([...listed, ...fromState])].sort();
+  for (const name of mindNames) {
+    const mindEnv = resolve(stateDir(name), "env.json");
+    if (existsSync(mindEnv)) {
+      write(`minds/${name}/env.json`, redactEnvJson(readFileSync(mindEnv, "utf-8")));
+    }
+    const mindLog = resolve(stateDir(name), "logs", "mind.log");
+    const tail = readLogTail(mindLog, 200);
+    if (tail.length > 0) write(`minds/${name}/mind.log`, redactLogText(`${tail.join("\n")}
+`));
+  }
+  const outPath = resolve(process.cwd(), `volute-doctor-${stamp}.tar.gz`);
+  try {
+    await exec("tar", ["-czf", outPath, "-C", stage, `volute-doctor-${stamp}`]);
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+  return outPath;
+}
+var cmd = command({
+  name: "volute doctor",
+  description: "Diagnose the local Volute install; --bundle writes a sanitized report to attach to a bug report",
+  flags: {
+    bundle: {
+      type: "boolean",
+      description: "Write a redacted diagnostic tarball to the current directory"
+    }
+  },
+  examples: ["volute doctor", "volute doctor --bundle"],
+  async run({ flags }) {
+    const { checks, daemonMinds } = await runDiagnostics();
+    const report = renderReport(checks);
+    if (!flags.bundle) {
+      process.stdout.write(report);
+      return;
+    }
+    process.stdout.write(report);
+    const outPath = await writeBundle(report, daemonMinds);
+    console.log(`
+Bundle written: ${outPath}`);
+    console.log("It redacts secrets, but skim it before sharing.");
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{down-UN2EDX2Y.js → down-3BQSPUAZ.js}

@@ -2,12 +2,12 @@
 import {
   run,
   stopDaemon
-} from "./chunk-Z4Q6TQWL.js";
+} from "./chunk-LRRPKZBD.js";
 import "./chunk-TXSA4Q3V.js";
 import "./chunk-O7IGP7ZW.js";
-import "./chunk-CKPAVQNK.js";
-import "./chunk-OIOW3FPT.js";
-import "./chunk-H6X6CKDN.js";
+import "./chunk-OPTA3BJ4.js";
+import "./chunk-NA2NJXY4.js";
+import "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/echo-text-Y2DFTD7L.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  clearEchoTextCache,
+  echoTextToChannel
+} from "./chunk-EYFBT2KP.js";
+import "./chunk-2QLWAYIU.js";
+import "./chunk-ELQU2GBT.js";
+import "./chunk-GAAATVTM.js";
+import "./chunk-P3GXOT2X.js";
+import "./chunk-2B4E6SL7.js";
+import "./chunk-IABDYN4N.js";
+import "./chunk-IOMBP2T5.js";
+import "./chunk-PAO7JZNW.js";
+import "./chunk-TGYKFUCF.js";
+import "./chunk-CLH357FI.js";
+import "./chunk-Q5M5QFKY.js";
+import "./chunk-UMQP5TC5.js";
+import "./chunk-WTZD6LFW.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-IQROTVBG.js";
+import "./chunk-I3OJ342S.js";
+import "./chunk-FYMIGUJ5.js";
+import "./chunk-6LICEQGP.js";
+import "./chunk-MNKPAAQF.js";
+import "./chunk-CVPCRWWC.js";
+import "./chunk-IRNM4LSF.js";
+import "./chunk-OPTA3BJ4.js";
+import "./chunk-NA2NJXY4.js";
+import "./chunk-OHHS5PSI.js";
+import "./chunk-E2SN3ZOJ.js";
+import "./chunk-2674KIGI.js";
+import "./chunk-LGNUFVMR.js";
+import "./chunk-TAVIVN2I.js";
+import "./chunk-2RNMBXD2.js";
+import "./chunk-K3NQKI34.js";
+export {
+  clearEchoTextCache,
+  echoTextToChannel
+};

package/dist/{env-SQFCWW52.js → env-4YX5YNWZ.js}

@@ -5,8 +5,8 @@ import {
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-GLM7TVWP.js";
-import "./chunk-H6X6CKDN.js";
+} from "./chunk-OHHS5PSI.js";
+import "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{exec-Z34TTUO3.js → exec-Y5VMDAVA.js}

@@ -4,8 +4,8 @@ import {
   execInherit,
   gitExec,
   resolveVoluteBin
-} from "./chunk-OIOW3FPT.js";
-import "./chunk-H6X6CKDN.js";
+} from "./chunk-NA2NJXY4.js";
+import "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{export-VBNWM7I4.js → export-ASRHBMRG.js}

@@ -6,11 +6,11 @@ import "./chunk-O7IGP7ZW.js";
 import {
   addHistoryToArchive,
   createExportArchive
-} from "./chunk-FLIEXG2T.js";
+} from "./chunk-XZP3FJ7Q.js";
 import {
   findMind,
   mindDir
-} from "./chunk-H6X6CKDN.js";
+} from "./chunk-TAVIVN2I.js";
 import "./chunk-2RNMBXD2.js";
 import "./chunk-K3NQKI34.js";