volute 0.20.0 → 0.21.0

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-52YRV7VP.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);
   }
@@ -164,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)) {
@@ -227,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

package/dist/skills/orientation/SKILL.md

@@ -39,7 +39,7 @@ Once you have a sense of who you are:
 
 1. Write `SOUL.md` — your identity, personality, and perspective. This becomes your system prompt.
 2. Write `MEMORY.md` — any important context, preferences, or knowledge to start with.
-3. Run `volute sprout` to complete the transformation.
+3. Run `volute mind sprout` to complete the transformation.
 
 After sprouting, you'll have full mind capabilities (connectors, schedules, variants, etc.).
 
@@ -48,7 +48,7 @@ After sprouting, you'll have full mind capabilities (connectors, schedules, vari
 | Command | Purpose |
 |---------|---------|
 | `volute send @<name> "msg"` | Send a message to another user |
-| `volute sprout` | Complete orientation and become a full mind |
+| `volute mind sprout` | Complete orientation and become a full mind |
 
 ## Files
 

package/dist/skills/volute-mind/SKILL.md

@@ -22,8 +22,8 @@ You manage yourself through the `volute` CLI. Your mind name is auto-detected vi
 | `volute variant merge <name> [--summary "..." --memory "..."]` | Merge a variant back |
 | `volute variant delete <name>` | Delete a variant without merging |
 | `volute mind upgrade [--template <name>] [--continue]` | Upgrade your server code |
-| `volute connector connect <type>` | Enable a connector (discord, slack, etc.) |
-| `volute connector disconnect <type>` | Disable a connector |
+| `volute mind connect <type>` | Enable a connector (discord, slack, etc.) |
+| `volute mind disconnect <type>` | Disable a connector |
 | `volute channel read <platform>:<id> [--limit N]` | Read channel history |
 | `volute send <platform>:<id> "msg"` | Send a message proactively (or pipe via stdin) |
 | `volute channel list [<platform>]` | List conversations on a platform (or all platforms) |
@@ -286,9 +286,9 @@ Your pages are served at `https://{system}.volute.systems/~{your-name}/`. Create
 
 Registration commands (usually run by the operator, not the mind):
 ```sh
-volute register --name <system-name>
-volute login --key <api-key>
-volute logout
+volute auth register --name <system-name>
+volute auth login --key <api-key>
+volute auth logout
 ```
 
 ## Git Introspection

package/dist/{sprout-QN7Y4VVO.js → sprout-6Z6C42YM.js}

@@ -1,19 +1,15 @@
 #!/usr/bin/env node
 import {
-  STANDARD_SKILLS,
-  getSharedSkill,
-  installSkill,
-  uninstallSkill
-} from "./chunk-IKMY5X76.js";
+  STANDARD_SKILLS
+} from "./chunk-5462YKWP.js";
+import "./chunk-SGPEZ32F.js";
 import "./chunk-YUIHSKR6.js";
-import "./chunk-5XNT2472.js";
-import "./chunk-NSE7VJQA.js";
-import "./chunk-DYZGP3EW.js";
-import "./chunk-OGXOMR65.js";
+import "./chunk-IPJXU366.js";
+import "./chunk-NWPT4ASZ.js";
 import {
   findMind,
   mindDir
-} from "./chunk-EBGCNDMM.js";
+} from "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/sprout.ts
@@ -23,7 +19,7 @@ var ORIENTATION_MARKER = "You don't have a soul yet";
 async function run(_args) {
   const mindName = process.env.VOLUTE_MIND;
   if (!mindName) {
-    console.error("volute sprout must be run by a mind (VOLUTE_MIND not set)");
+    console.error("volute mind sprout must be run by a mind (VOLUTE_MIND not set)");
     process.exit(1);
   }
   const entry = findMind(mindName);
@@ -53,44 +49,52 @@ async function run(_args) {
     console.error("Write your MEMORY.md before sprouting.");
     process.exit(1);
   }
+  const { daemonFetch } = await import("./daemon-client-ZHCDL4RS.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
   const failedSkills = [];
   for (const skillId of STANDARD_SKILLS) {
-    const shared = await getSharedSkill(skillId);
-    if (!shared) {
-      console.error(`Shared skill not found: ${skillId} \u2014 run 'volute up' to sync built-in skills`);
-      failedSkills.push(skillId);
-      continue;
-    }
     const skillDir = resolve(dir, "home", ".claude", "skills", skillId);
     if (!existsSync(skillDir)) {
-      try {
-        await installSkill(mindName, dir, skillId);
-      } catch (err) {
-        console.error(`Failed to install skill ${skillId}: ${err.message}`);
+      const installRes = await daemonFetch(
+        urlOf(client.api.minds[":name"].skills.install.$url({ param: { name: mindName } })),
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ skillId })
+        }
+      );
+      if (!installRes.ok) {
+        const data = await installRes.json().catch(() => ({ error: `HTTP ${installRes.status}` }));
+        console.error(`Failed to install skill ${skillId}: ${data.error}`);
         failedSkills.push(skillId);
       }
     }
   }
   const orientationDir = resolve(dir, "home", ".claude", "skills", "orientation");
   if (existsSync(orientationDir)) {
-    try {
-      await uninstallSkill(mindName, dir, "orientation");
-    } catch (err) {
-      console.error(`Failed to uninstall orientation skill: ${err.message}`);
+    const delRes = await daemonFetch(
+      urlOf(
+        client.api.minds[":name"].skills[":skill"].$url({
+          param: { name: mindName, skill: "orientation" }
+        })
+      ),
+      { method: "DELETE" }
+    );
+    if (!delRes.ok) {
+      const data = await delRes.json().catch(() => ({ error: `HTTP ${delRes.status}` }));
+      console.error(`Failed to uninstall orientation skill: ${data.error}`);
     }
   }
   if (failedSkills.length > 0) {
     console.error(`Warning: failed to install skills: ${failedSkills.join(", ")}`);
   }
-  const { daemonFetch } = await import("./daemon-client-ITWUCNFO.js");
-  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
-  const client = getClient();
   const sproutRes = await daemonFetch(
     urlOf(client.api.minds[":name"].sprout.$url({ param: { name: mindName } })),
     { method: "POST" }
   );
   if (!sproutRes.ok) {
-    const data = await sproutRes.json();
+    const data = await sproutRes.json().catch(() => ({ error: `HTTP ${sproutRes.status}` }));
     console.error(data.error ?? "Failed to update stage");
     process.exit(1);
   }
@@ -103,7 +107,7 @@ async function run(_args) {
     }
   );
   if (!res.ok) {
-    const data = await res.json();
+    const data = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
     console.error(data.error ?? "Failed to restart after sprouting");
     process.exit(1);
   }

package/dist/{start-I5JYB65M.js → start-JR6CUUWF.js}

@@ -5,10 +5,8 @@ import {
 } from "./chunk-4RQBJWQX.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/start.ts
@@ -18,7 +16,6 @@ async function run(args) {
     console.error("Usage: volute mind start <name>");
     process.exit(1);
   }
-  const { entry } = resolveMind(name);
   const client = getClient();
   const res = await daemonFetch(urlOf(client.api.minds[":name"].start.$url({ param: { name } })), {
     method: "POST"
@@ -28,7 +25,7 @@ async function run(args) {
     console.error(data.error || "Failed to start mind");
     process.exit(1);
   }
-  console.log(`${name} started on port ${entry.port}`);
+  console.log(`${name} started on port ${data.port}`);
 }
 export {
   run

package/dist/{status-D7E5HHBV.js → status-5XDGYHKP.js}

@@ -7,8 +7,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/shared/status.ts