volute 0.33.0 → 0.35.0

package/dist/{chunk-RVGLDGMI.js → chunk-WZRZFFCL.js}

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
 import {
   subscribe
-} from "./chunk-KVK2DLWI.js";
+} from "./chunk-CORXD635.js";
 import {
   logger_default
-} from "./chunk-YUIHSKR6.js";
+} from "./chunk-BKF4WQCY.js";
 import {
   getDb
-} from "./chunk-LRCG2JLP.js";
+} from "./chunk-BDYXIWA5.js";
 import {
   conversationParticipants,
   conversationReads,
   conversations,
   messages,
   users
-} from "./chunk-RPZZSXV3.js";
+} from "./chunk-5N7Y5WAM.js";
 
-// src/lib/events/conversations.ts
+// packages/daemon/src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
 import { and, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
 
-// src/lib/webhook.ts
+// packages/daemon/src/lib/webhook.ts
 var slog = logger_default.child("webhook");
 function getWebhookUrl() {
   return process.env.VOLUTE_WEBHOOK_URL;
@@ -82,7 +82,7 @@ function initWebhook() {
   });
 }
 
-// src/lib/events/conversation-events.ts
+// packages/daemon/src/lib/events/conversation-events.ts
 var subscribers = /* @__PURE__ */ new Map();
 function subscribe2(conversationId, callback) {
   let set = subscribers.get(conversationId);
@@ -110,32 +110,30 @@ function publish(conversationId, event) {
   }
 }
 
-// src/lib/events/conversations.ts
+// packages/daemon/src/lib/events/conversations.ts
 async function createConversation(mindName, channel, opts) {
   const db = await getDb();
   const id = randomUUID();
   const type = opts?.type ?? "dm";
   const name = opts?.name ?? null;
-  await db.transaction(async (tx) => {
-    await tx.insert(conversations).values({
-      id,
-      mind_name: mindName,
-      channel,
-      type,
-      name,
-      user_id: opts?.userId ?? null,
-      title: opts?.title ?? null
-    });
-    if (opts?.participantIds && opts.participantIds.length > 0) {
-      await tx.insert(conversationParticipants).values(
-        opts.participantIds.map((uid, i) => ({
-          conversation_id: id,
-          user_id: uid,
-          role: i === 0 ? "owner" : "member"
-        }))
-      );
-    }
+  await db.insert(conversations).values({
+    id,
+    mind_name: mindName,
+    channel,
+    type,
+    name,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null
   });
+  if (opts?.participantIds && opts.participantIds.length > 0) {
+    await db.insert(conversationParticipants).values(
+      opts.participantIds.map((uid, i) => ({
+        conversation_id: id,
+        user_id: uid,
+        role: i === 0 ? "owner" : "member"
+      }))
+    );
+  }
   fireWebhook({
     event: "conversation_created",
     mind: mindName ?? "",

package/dist/{chunk-JYVGHWEJ.js → chunk-XRQSAMX2.js}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import {
   broadcast
-} from "./chunk-KVK2DLWI.js";
+} from "./chunk-CORXD635.js";
 import {
   getDb
-} from "./chunk-LRCG2JLP.js";
+} from "./chunk-BDYXIWA5.js";
 import {
   users
-} from "./chunk-RPZZSXV3.js";
+} from "./chunk-5N7Y5WAM.js";
 
-// src/lib/auth.ts
+// packages/daemon/src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq, or } from "drizzle-orm";
 var userSelectFields = {

package/dist/{chunk-OYAKCAVY.js → chunk-ZSR72JB3.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/lib/volute-config.ts
+// packages/daemon/src/lib/volute-config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 function readJson(path) {

package/dist/{chunk-UKVWJRKN.js → chunk-ZX7EAV5J.js}

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
-import {
-  voluteSystemDir,
-  voluteUserHome
-} from "./chunk-LRCG2JLP.js";
 
-// src/lib/daemon-client.ts
+// packages/cli/src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
 import { resolve } from "path";
+function voluteUserHome() {
+  return process.env.VOLUTE_USER_HOME ?? resolve(homedir(), ".volute");
+}
+function voluteSystemDir() {
+  const home = process.env.VOLUTE_HOME ?? resolve(homedir(), ".volute");
+  return resolve(home, "system");
+}
 function readSessionFile(mindDir) {
   try {
     const p = resolve(mindDir, ".mind", "current-session");
@@ -70,9 +74,14 @@ function buildUrl(config) {
   }
   return url.origin;
 }
+function resolveDaemonUrl() {
+  if (process.env.VOLUTE_DAEMON_URL) return process.env.VOLUTE_DAEMON_URL;
+  const session = readCliSession();
+  if (session?.daemonUrl) return session.daemonUrl;
+  return buildUrl(readDaemonConfig());
+}
 async function daemonFetch(path, options) {
-  const config = readDaemonConfig();
-  const url = buildUrl(config);
+  const url = resolveDaemonUrl();
   const headers = new Headers(options?.headers);
   const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
   const cliSession = daemonToken ? null : readCliSession();
@@ -108,5 +117,6 @@ async function daemonFetch(path, options) {
 
 export {
   readSessionFile,
+  resolveDaemonUrl,
   daemonFetch
 };

package/dist/cli.js

@@ -10,7 +10,7 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-U3VFO273.js");
+  const { default: pkg } = await import("./package-D2FSVFAX.js");
   console.log(pkg.version);
   process.exit(0);
 }
@@ -31,7 +31,7 @@ var ungatedCommands = /* @__PURE__ */ new Set([
   void 0
 ]);
 if (!ungatedCommands.has(command)) {
-  const { isSetupComplete } = await import("./setup-TISPCO22.js");
+  const { isSetupComplete } = await import("./setup-RHJRFURI.js");
   if (!isSetupComplete()) {
     console.error("Volute is not set up. Run `volute setup` first.");
     process.exit(1);
@@ -39,58 +39,61 @@ if (!ungatedCommands.has(command)) {
 }
 switch (command) {
   case "setup":
-    await import("./setup-XMCBE3LF.js").then((m) => m.run(args));
+    await import("./setup-BJ4YAY26.js").then((m) => m.run(args));
     break;
   case "mind":
-    await import("./mind-IOJFLEM5.js").then((m) => m.run(args));
+    await import("./mind-5IEYKV7I.js").then((m) => m.run(args));
     break;
   case "seed":
-    await import("./seed-cmd-DKOUFEAU.js").then((m) => m.run(args));
+    await import("./seed-cmd-ZM2XGVU2.js").then((m) => m.run(args));
     break;
   case "chat":
-    await import("./chat-U5ZOME3O.js").then((m) => m.run(args));
+    await import("./chat-QXAJF3FU.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-7TGZHOU3.js").then((m) => m.run(args));
+    await import("./variant-QWL2WSRI.js").then((m) => m.run(args));
     break;
   case "clock":
-    await import("./clock-BVH3V6E3.js").then((m) => m.run(args));
+    await import("./clock-HSEKS5AR.js").then((m) => m.run(args));
     break;
   case "skill":
-    await import("./skill-PSQGRRJX.js").then((m) => m.run(args));
+    await import("./skill-TAAKEYBV.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-JCOF2222.js").then((m) => m.run(args));
+    await import("./env-E4XHO2BI.js").then((m) => m.run(args));
     break;
   case "config":
-    await import("./config-H2H4UIF7.js").then((m) => m.run(args));
+    await import("./config-UTS7QULS.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-M5AS6SBV.js").then((m) => m.run(args));
+    await import("./up-77ICEDEW.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-FWWTEKXM.js").then((m) => m.run(args));
+    await import("./down-74VXM45A.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-GOBUKLX7.js").then((m) => m.run(args));
+    await import("./daemon-restart-HSZ3BCX5.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-UD543CXX.js").then((m) => m.run(args));
+    await import("./update-ANE5ZM7F.js").then((m) => m.run(args));
     break;
   case "status":
-    await import("./status-3JBTFSMI.js").then((m) => m.run(args));
+    await import("./status-ZK34WYIM.js").then((m) => m.run(args));
     break;
   case "extension":
-    await import("./extension-OBTGKQQD.js").then((m) => m.run(args));
+    await import("./extension-D74CNM7G.js").then((m) => m.run(args));
     break;
   case "systems":
-    await import("./systems-XRI52VCH.js").then((m) => m.run(args));
+    await import("./systems-O43WGQY6.js").then((m) => m.run(args));
     break;
   case "login":
-    await import("./login-RIJF2F4G.js").then((m) => m.run(args));
+    await import("./login-7TE6CIZF.js").then((m) => m.run(args));
     break;
   case "logout":
-    await import("./logout-5MLHZALK.js").then((m) => m.run(args));
+    await import("./logout-T4XS6LRU.js").then((m) => m.run(args));
+    break;
+  case "service":
+    await import("./service-WNPCNHOX.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -133,7 +136,7 @@ System:
 
 Extensions:
   notes write/list/read/...        Manage notes
-  pages notify                     Notify page updates
+  pages publish/list/pull/log      Manage pages
 
 Options:
   --version, -v                    Show version number
@@ -147,22 +150,80 @@ use --mind <name> or VOLUTE_MIND env var to identify the mind.`);
   default: {
     let isExtensionCommand = false;
     try {
-      const { daemonFetch } = await import("./daemon-client-6QXHZ7US.js");
+      const { daemonFetch } = await import("./daemon-client-RVIKXGFQ.js");
       const res = await daemonFetch("/api/extensions/commands");
       if (res.ok) {
         const extCommands = await res.json();
         if (command && command in extCommands) {
           isExtensionCommand = true;
-          const subcommand = args[0];
           const ext = extCommands[command];
-          if (!subcommand || !(subcommand in ext.commands)) {
-            console.log(`volute ${command} \u2014 ${Object.keys(ext.commands).join(", ")}
+          const subcommand = args[0];
+          const wantsHelp = args.includes("--help") || args.includes("-h");
+          if (!subcommand || wantsHelp && !(subcommand in ext.commands)) {
+            console.log(`Manage ${command}
+`);
+            console.log(`Usage: volute ${command} <command> [options]
 `);
-            for (const [name, meta] of Object.entries(ext.commands)) {
-              console.log(`  ${name.padEnd(12)} ${meta.description}`);
+            console.log("Commands:");
+            const entries = Object.entries(ext.commands);
+            const nameWidth = Math.max(...entries.map(([k]) => k.length));
+            for (const [name, meta] of entries) {
+              console.log(`  ${name.padEnd(nameWidth + 2)}  ${meta.description}`);
+            }
+            console.log(`
+Use --mind <name> or VOLUTE_MIND to specify the mind.
+`);
+            process.exit(subcommand ? 0 : 1);
+          }
+          if (wantsHelp && subcommand in ext.commands) {
+            const meta = ext.commands[subcommand];
+            const argParts = (meta.args ?? []).map(
+              (a) => a.required ? `<${a.name}>` : `[${a.name}]`
+            );
+            const flagEntries = Object.entries(meta.flags ?? {});
+            const flagPart = flagEntries.length > 0 ? " [options]" : "";
+            const argStr = argParts.length > 0 ? ` ${argParts.join(" ")}` : "";
+            console.log(`${meta.description}
+`);
+            console.log(`Usage: volute ${command} ${subcommand}${argStr}${flagPart}
+`);
+            if (meta.args && meta.args.length > 0) {
+              console.log("Arguments:");
+              const w = Math.max(...meta.args.map((a) => a.name.length + 2));
+              for (const a of meta.args) {
+                const label = a.required ? `<${a.name}>` : `[${a.name}]`;
+                console.log(`  ${label.padEnd(w + 2)}  ${a.description}`);
+              }
+              console.log("");
+            }
+            if (flagEntries.length > 0) {
+              console.log("Options:");
+              const w = Math.max(
+                ...flagEntries.map(([k, v]) => {
+                  const hint = v.type === "boolean" ? "" : ` <${v.type === "string" ? "value" : "n"}>`;
+                  return `--${k}${hint}`.length;
+                })
+              );
+              for (const [key, val] of flagEntries) {
+                const hint = val.type === "boolean" ? "" : ` <${val.type === "string" ? "value" : "n"}>`;
+                const flag = `--${key}${hint}`;
+                console.log(`  ${flag.padEnd(w + 2)}  ${val.description}`);
+              }
+              console.log("");
+            }
+            if (meta.examples && meta.examples.length > 0) {
+              console.log("Examples:");
+              for (const ex of meta.examples) {
+                console.log(`  ${ex}`);
+              }
+              console.log("");
             }
             process.exit(0);
           }
+          if (!(subcommand in ext.commands)) {
+            console.error(`Unknown command: volute ${command} ${subcommand}`);
+            process.exit(1);
+          }
           const cmdArgs = args.slice(1);
           let mind = process.env.VOLUTE_MIND;
           const mindIdx = cmdArgs.indexOf("--mind");
@@ -170,7 +231,7 @@ use --mind <name> or VOLUTE_MIND env var to identify the mind.`);
             mind = cmdArgs[mindIdx + 1];
             cmdArgs.splice(mindIdx, 2);
           }
-          const { readStdin } = await import("./read-stdin-HQJ7774D.js");
+          const { readStdin } = await import("./read-stdin-3X5VYKNS.js");
           const stdin = await readStdin();
           const cmdRes = await daemonFetch(`/api/ext/${command}/commands/${subcommand}`, {
             method: "POST",
@@ -203,7 +264,7 @@ Run 'volute --help' for usage.`);
   }
 }
 if (command !== "update") {
-  import("./update-check-ZD6OOIYQ.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-UV55CBEP.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/clock-HSEKS5AR.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import {
+  compactDateTime,
+  isCompact
+} from "./chunk-5T5YMX6S.js";
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/clock.ts
+import { CronExpressionParser } from "cron-parser";
+function parseDuration(input) {
+  const parts = input.match(/^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/);
+  if (!parts || parts[0] !== input) return null;
+  const hours = parseInt(parts[1] || "0", 10);
+  const minutes = parseInt(parts[2] || "0", 10);
+  const seconds = parseInt(parts[3] || "0", 10);
+  const total = hours * 36e5 + minutes * 6e4 + seconds * 1e3;
+  return total > 0 ? total : null;
+}
+var clockStatusCmd = command({
+  name: "volute clock status",
+  description: "Show sleep state and upcoming events",
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ flags }) => {
+    const mind = resolveMindName(flags);
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].clock.status.$url({ param: { name: mind } }))
+    );
+    if (!res.ok) {
+      const data = await res.json();
+      console.error(data.error ?? `Failed to get clock status: ${res.status}`);
+      process.exit(1);
+    }
+    const status = await res.json();
+    const compact = isCompact();
+    const fmtTime = (s) => compact ? compactDateTime(s) : new Date(s).toLocaleString();
+    if (status.sleep?.sleeping) {
+      const since = status.sleep.sleepingSince ? fmtTime(status.sleep.sleepingSince) : "unknown";
+      console.log(`Sleep: sleeping since ${since}`);
+      if (status.sleep.scheduledWakeAt) {
+        console.log(`  Wake at: ${fmtTime(status.sleep.scheduledWakeAt)}`);
+      }
+      if (status.sleep.voluntaryWakeAt) {
+        console.log(`  Voluntary wake at: ${fmtTime(status.sleep.voluntaryWakeAt)}`);
+      }
+      if (status.sleep.queuedMessageCount > 0) {
+        console.log(`  Queued messages: ${status.sleep.queuedMessageCount}`);
+      }
+    } else {
+      console.log("Sleep: awake");
+    }
+    if (status.sleepConfig?.enabled && status.sleepConfig.schedule) {
+      console.log(
+        `  Schedule: sleep ${status.sleepConfig.schedule.sleep}, wake ${status.sleepConfig.schedule.wake}`
+      );
+    }
+    if (status.upcoming.length > 0) {
+      if (!compact) console.log("");
+      console.log("Upcoming (next 24h):");
+      for (const u of status.upcoming) {
+        const time = fmtTime(u.at);
+        const label = u.type === "timer" ? "[timer]" : "[cron]";
+        console.log(`  ${u.id.padEnd(20)} ${label}  ${time}`);
+      }
+    } else {
+      if (!compact) console.log("");
+      console.log("No upcoming events in next 24h.");
+    }
+    if (!compact) {
+      console.log(`
+${status.schedules.length} schedule(s) configured.`);
+    }
+  }
+});
+var listSchedulesCmd = command({
+  name: "volute clock list",
+  description: "List schedules and timers",
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ flags }) => {
+    const mind = resolveMindName(flags);
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].schedules.$url({ param: { name: mind } }))
+    );
+    if (!res.ok) {
+      const data = await res.json();
+      console.error(data.error ?? `Failed to list schedules: ${res.status}`);
+      process.exit(1);
+    }
+    const schedules = await res.json();
+    if (schedules.length === 0) {
+      console.log("No schedules configured.");
+      return;
+    }
+    const actionLabel = (s) => s.script ? `[script] ${s.script}` : s.message ?? "";
+    if (isCompact()) {
+      for (const s of schedules) {
+        const sched = s.cron ?? (s.fireAt ? `at ${s.fireAt}` : "");
+        console.log(`${s.id}  ${sched}  ${actionLabel(s)}`);
+      }
+    } else {
+      const idW = Math.max(2, ...schedules.map((s) => s.id.length));
+      const schedW = Math.max(8, ...schedules.map((s) => (s.cron ?? s.fireAt ?? "").length));
+      console.log(`${"ID".padEnd(idW)}  ${"SCHEDULE".padEnd(schedW)}  ENABLED  ACTION`);
+      for (const s of schedules) {
+        const sched = s.cron ?? (s.fireAt ? `at ${s.fireAt}` : "");
+        console.log(
+          `${s.id.padEnd(idW)}  ${sched.padEnd(schedW)}  ${String(s.enabled).padEnd(7)}  ${actionLabel(s)}`
+        );
+      }
+    }
+  }
+});
+var addScheduleCmd = command({
+  name: "volute clock add",
+  description: "Add a schedule or timer",
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    cron: { type: "string", description: "Cron expression" },
+    in: { type: "string", description: "Duration (e.g. 30s, 10m, 1h)" },
+    message: { type: "string", description: "Message to send" },
+    script: { type: "string", description: "Script to run" },
+    id: { type: "string", description: "Schedule ID (required)" },
+    session: { type: "string", description: "Session name" },
+    "while-sleeping": {
+      type: "string",
+      description: "Behavior during sleep (skip, queue, trigger-wake)"
+    }
+  },
+  run: async ({ flags }) => {
+    const mind = resolveMindName(flags);
+    if (!flags.id) {
+      console.error("--id is required (a descriptive name for this schedule)");
+      process.exit(1);
+    }
+    if (!flags.cron && !flags.in) {
+      console.error("--cron or --in is required");
+      process.exit(1);
+    }
+    if (flags.cron && flags.in) {
+      console.error("--cron and --in are mutually exclusive");
+      process.exit(1);
+    }
+    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);
+    }
+    const body = {};
+    if (flags.cron) {
+      try {
+        CronExpressionParser.parse(flags.cron);
+      } catch {
+        console.error(`Invalid cron expression: ${flags.cron}`);
+        process.exit(1);
+      }
+      body.cron = flags.cron;
+    }
+    if (flags.in) {
+      const durationMs = parseDuration(flags.in);
+      if (!durationMs) {
+        console.error(`Invalid duration: ${flags.in} (expected format: 30s, 10m, 1h, 2h30m)`);
+        process.exit(1);
+      }
+      body.fireAt = new Date(Date.now() + durationMs).toISOString();
+    }
+    if (flags.message) body.message = flags.message;
+    if (flags.script) body.script = flags.script;
+    if (flags.id) body.id = flags.id;
+    if (flags.session) body.session = flags.session;
+    if (flags["while-sleeping"]) {
+      const ws = flags["while-sleeping"];
+      if (!["skip", "queue", "trigger-wake"].includes(ws)) {
+        console.error(
+          `Invalid --while-sleeping value: ${ws} (must be skip, queue, or trigger-wake)`
+        );
+        process.exit(1);
+      }
+      body.whileSleeping = ws;
+    }
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].schedules.$url({ param: { name: mind } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const data2 = await res.json();
+      console.error(data2.error ?? `Failed to add schedule: ${res.status}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    if (flags.in) {
+      console.log(`Timer set: ${data.id} (fires in ${flags.in})`);
+    } else {
+      console.log(`Schedule added: ${data.id}`);
+    }
+  }
+});
+var removeScheduleCmd = command({
+  name: "volute clock remove",
+  description: "Remove a schedule or timer",
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    id: { type: "string", description: "Schedule ID (required)" }
+  },
+  run: async ({ flags }) => {
+    const mind = resolveMindName(flags);
+    if (!flags.id) {
+      console.error("--id is required");
+      process.exit(1);
+    }
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(
+        client.api.minds[":name"].schedules[":id"].$url({
+          param: { name: mind, id: flags.id }
+        })
+      ),
+      { method: "DELETE" }
+    );
+    if (!res.ok) {
+      const data = await res.json();
+      console.error(data.error ?? `Failed to remove schedule: ${res.status}`);
+      process.exit(1);
+    }
+    console.log(`Schedule removed: ${flags.id}`);
+  }
+});
+var cmd = subcommands({
+  name: "volute clock",
+  description: "Manage schedules, timers, and sleep/wake cycles",
+  commands: {
+    status: {
+      description: "Show sleep state and upcoming schedule fires",
+      run: clockStatusCmd.execute
+    },
+    list: {
+      description: "List schedules and timers",
+      run: listSchedulesCmd.execute
+    },
+    add: {
+      description: "Add a schedule or timer",
+      run: addScheduleCmd.execute
+    },
+    remove: {
+      description: "Remove a schedule or timer",
+      run: removeScheduleCmd.execute
+    },
+    sleep: {
+      description: "Put a mind to sleep",
+      run: (args) => import("./mind-sleep-ITCF6OQA.js").then((m) => m.run(args))
+    },
+    wake: {
+      description: "Wake a sleeping mind",
+      run: (args) => import("./mind-wake-KXMKMGWX.js").then((m) => m.run(args))
+    }
+  },
+  footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."
+});
+var run = cmd.execute;
+export {
+  run
+};