mnemospark 0.9.2 → 1.0.1

package/dist/cli.js

@@ -1915,7 +1915,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud price-storage"
+            message: "Invalid JSON body for /mnemospark cloud price-storage"
           });
           return;
         }
@@ -1983,7 +1983,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud price-storage: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud price-storage: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2162,7 +2162,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud upload"
+            message: "Invalid JSON body for /mnemospark cloud upload"
           });
           return;
         }
@@ -2225,7 +2225,7 @@ async function startProxy(options) {
             error: "insufficient_balance",
             message: `Insufficient USDC balance. Current: ${sufficiency.info.balanceUSD}, Required: ${requiredUSD}`,
             wallet: requestPayload.wallet_address,
-            help: `Fund wallet ${requestPayload.wallet_address} on Base before running /mnemospark_cloud upload`
+            help: `Fund wallet ${requestPayload.wallet_address} on Base before running /mnemospark cloud upload`
           });
           return;
         }
@@ -2333,7 +2333,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud upload: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud upload: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2351,7 +2351,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud upload/confirm"
+            message: "Invalid JSON body for /mnemospark cloud upload/confirm"
           });
           return;
         }
@@ -2432,7 +2432,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud upload/confirm: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud upload/confirm: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2450,7 +2450,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud ls"
+            message: "Invalid JSON body for /mnemospark cloud ls"
           });
           return;
         }
@@ -2523,7 +2523,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud ls: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud ls: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2543,7 +2543,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud download"
+            message: "Invalid JSON body for /mnemospark cloud download"
           });
           return;
         }
@@ -2644,7 +2644,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud download: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud download: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2662,7 +2662,7 @@ async function startProxy(options) {
           emitProxyTerminalFromStatus(correlation, 400, { reason: "invalid_json" });
           sendJson(res, 400, {
             error: "Bad request",
-            message: "Invalid JSON body for /mnemospark_cloud delete"
+            message: "Invalid JSON body for /mnemospark cloud delete"
           });
           return;
         }
@@ -2739,7 +2739,7 @@ async function startProxy(options) {
         });
         sendJson(res, 502, {
           error: "proxy_error",
-          message: `Failed to forward /mnemospark_cloud delete: ${err instanceof Error ? err.message : String(err)}`
+          message: `Failed to forward /mnemospark cloud delete: ${err instanceof Error ? err.message : String(err)}`
         });
       }
       return;
@@ -2965,6 +2965,10 @@ var pkg = require2(join6(__dirname, "..", "package.json"));
 var VERSION = pkg.version;
 var USER_AGENT = `mnemospark/${VERSION}`;
 
+// src/mnemospark-handler.ts
+import { existsSync, readFileSync } from "fs";
+import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
+
 // src/cloud-command.ts
 import { spawn } from "child_process";
 import {
@@ -3761,6 +3765,425 @@ async function createCloudDatastore(homeDir) {
   };
 }
 
+// src/args/normalize.ts
+function normalizeSmartQuotes(input) {
+  return input.replace(/[\u201C\u201D]/g, '"').replace(/[\u2018\u2019]/g, "'");
+}
+function normalizeFlagPositionDashes(input) {
+  const warnings = [];
+  const pattern = /(^|\s)[\u2013\u2014](?=[A-Za-z_][A-Za-z0-9_-]*)/g;
+  let changed = false;
+  const text = input.replace(pattern, (m, prefix) => {
+    changed = true;
+    return `${prefix}--`;
+  });
+  if (changed) {
+    warnings.push("Normalized en/em dash in flag position to ASCII double hyphen.");
+  }
+  return { text, warnings };
+}
+function normalizeInputForParsing(input) {
+  const warnings = [];
+  let text = normalizeSmartQuotes(input);
+  const dashNorm = normalizeFlagPositionDashes(text);
+  text = dashNorm.text;
+  warnings.push(...dashNorm.warnings);
+  return { text, warnings };
+}
+
+// src/args/suggest.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+function suggestNearestKey(raw, candidates, maxDistance = 2) {
+  const lower = raw.toLowerCase();
+  let best = null;
+  let bestDist = maxDistance + 1;
+  for (const c of candidates) {
+    const d = levenshtein(lower, c.toLowerCase());
+    if (d < bestDist) {
+      bestDist = d;
+      best = c;
+    }
+  }
+  return bestDist <= maxDistance ? best : null;
+}
+
+// src/args/parser.ts
+function canonicalizeKey(rawKey) {
+  return rawKey.normalize("NFKC").replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/_/g, "-").toLowerCase().trim();
+}
+function buildAliasMap(schema) {
+  const map = /* @__PURE__ */ new Map();
+  for (const spec of schema.args) {
+    map.set(canonicalizeKey(spec.name), spec);
+    for (const alias of spec.aliases ?? []) {
+      map.set(canonicalizeKey(alias), spec);
+    }
+  }
+  return map;
+}
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    while (i < input.length && /\s/.test(input[i])) i++;
+    if (i >= input.length) break;
+    let raw = "";
+    let value = "";
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i++];
+      raw += quote;
+      while (i < input.length) {
+        const ch = input[i++];
+        raw += ch;
+        if (ch === "\\") {
+          if (i < input.length) {
+            const next = input[i++];
+            raw += next;
+            value += next;
+          }
+          continue;
+        }
+        if (ch === quote) {
+          break;
+        }
+        value += ch;
+      }
+      tokens.push({ raw, value });
+      continue;
+    }
+    while (i < input.length && !/\s/.test(input[i])) {
+      const ch = input[i++];
+      raw += ch;
+      value += ch;
+    }
+    tokens.push({ raw, value });
+  }
+  return tokens;
+}
+function resolveKey(rawKey, aliasMap, schema, allCanonicalNames) {
+  const canonical = canonicalizeKey(rawKey);
+  const spec = aliasMap.get(canonical);
+  if (!spec) {
+    if (schema.allowUnknown) return { key: canonical };
+    const suggestion = suggestNearestKey(rawKey, allCanonicalNames);
+    const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+    return { error: `Unknown argument "${rawKey}".${hint}` };
+  }
+  return { key: spec.name, spec };
+}
+function addValue(out, key, value, spec) {
+  const existing = out[key];
+  if (existing === void 0) {
+    out[key] = spec?.repeatable ? [value] : value;
+    return null;
+  }
+  if (!spec?.repeatable) {
+    return `Duplicate argument "${key}".`;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+  } else {
+    out[key] = [existing, value];
+  }
+  return null;
+}
+function collectCanonicalNames(schema) {
+  const names = /* @__PURE__ */ new Set();
+  for (const spec of schema.args) {
+    names.add(spec.name);
+    for (const a of spec.aliases ?? []) {
+      names.add(a);
+    }
+  }
+  return [...names];
+}
+function looksLikeDelimitedArgToken(token) {
+  return /^[A-Za-z_][A-Za-z0-9_-]*[:=]/.test(token);
+}
+function tryParseDelimitedToken(token, delimiter, aliasMap, schema, allCanonicalNames, out) {
+  const idx = token.indexOf(delimiter);
+  if (idx <= 0) return { handled: false };
+  const keyPart = token.slice(0, idx);
+  if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(keyPart)) return { handled: false };
+  const rawKey = keyPart;
+  const rawValue = token.slice(idx + 1);
+  if (rawValue === "") {
+    return { handled: true, error: `Empty value for argument "${rawKey}".` };
+  }
+  const resolved = resolveKey(rawKey, aliasMap, schema, allCanonicalNames);
+  if (resolved.error) {
+    return { handled: true, error: resolved.error };
+  }
+  const dupErr = addValue(out, resolved.key, rawValue, resolved.spec);
+  if (dupErr) {
+    return { handled: true, error: dupErr };
+  }
+  return { handled: true };
+}
+function parseCommandArgs(input, schema) {
+  const warnings = [];
+  const errors = [];
+  const norm = normalizeInputForParsing(input);
+  const normalized = norm.text;
+  warnings.push(...norm.warnings);
+  const tokens = tokenize(normalized);
+  const aliasMap = buildAliasMap(schema);
+  const allCanonicalNames = collectCanonicalNames(schema);
+  const values = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i].value;
+    {
+      const parsed = tryParseDelimitedToken(
+        token,
+        ":",
+        aliasMap,
+        schema,
+        allCanonicalNames,
+        values
+      );
+      if (parsed.handled) {
+        if (parsed.error) errors.push(parsed.error);
+        continue;
+      }
+    }
+    {
+      const parsed = tryParseDelimitedToken(
+        token,
+        "=",
+        aliasMap,
+        schema,
+        allCanonicalNames,
+        values
+      );
+      if (parsed.handled) {
+        if (parsed.error) errors.push(parsed.error);
+        continue;
+      }
+    }
+    if (token.startsWith("--")) {
+      const rawKey = token.slice(2);
+      if (!rawKey) {
+        errors.push('Encountered "--" without an argument name.');
+        continue;
+      }
+      const resolved = resolveKey(rawKey, aliasMap, schema, allCanonicalNames);
+      if (resolved.error) {
+        errors.push(resolved.error);
+        continue;
+      }
+      const next = tokens[i + 1];
+      if (!next) {
+        if (resolved.spec?.bareBoolean) {
+          const dupErr2 = addValue(values, resolved.key, "true", resolved.spec);
+          if (dupErr2) errors.push(dupErr2);
+          continue;
+        }
+        errors.push(`Missing value for argument "${resolved.key}".`);
+        continue;
+      }
+      if (next.value.startsWith("--")) {
+        if (resolved.spec?.bareBoolean) {
+          const dupErr2 = addValue(values, resolved.key, "true", resolved.spec);
+          if (dupErr2) errors.push(dupErr2);
+          continue;
+        }
+        errors.push(`Missing value for argument "${resolved.key}".`);
+        continue;
+      }
+      if (resolved.spec?.bareBoolean && looksLikeDelimitedArgToken(next.value)) {
+        const dupErr2 = addValue(values, resolved.key, "true", resolved.spec);
+        if (dupErr2) errors.push(dupErr2);
+        continue;
+      }
+      const dupErr = addValue(values, resolved.key, next.value, resolved.spec);
+      if (dupErr) errors.push(dupErr);
+      i += 1;
+      continue;
+    }
+    errors.push(`Unexpected token "${token}". Use key:value, key=value, or --key value.`);
+  }
+  for (const spec of schema.args) {
+    if (spec.required && values[spec.name] === void 0) {
+      errors.push(`Missing required argument "${spec.name}".`);
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      ok: false,
+      normalizedInput: normalized,
+      errors,
+      warnings
+    };
+  }
+  return {
+    ok: true,
+    normalizedInput: normalized,
+    values,
+    warnings
+  };
+}
+function valuesToStringRecord(values) {
+  const out = {};
+  for (const [k, v] of Object.entries(values)) {
+    out[k] = Array.isArray(v) ? v[v.length - 1] : v;
+  }
+  return out;
+}
+
+// src/mnemospark-route.ts
+function parseVerboseToken(token) {
+  const t = token.trim();
+  const idx = t.indexOf(":");
+  if (idx < 0) {
+    return { name: t.toLowerCase(), ok: true };
+  }
+  const key = t.slice(0, idx).trim();
+  const val = t.slice(idx + 1).trim().toLowerCase();
+  if (!key) return { name: "", ok: false };
+  if (val === "true") return { name: key.toLowerCase(), ok: true };
+  return { name: key.toLowerCase(), ok: false };
+}
+function firstTokenAndRest(input) {
+  const t = input.trim();
+  if (!t) return { first: "", rest: "" };
+  const spaceIdx = t.search(/\s/);
+  if (spaceIdx === -1) return { first: t, rest: "" };
+  return { first: t.slice(0, spaceIdx), rest: t.slice(spaceIdx + 1).trim() };
+}
+function routeMnemosparkArgs(args) {
+  const trimmed = args?.trim() ?? "";
+  if (!trimmed) {
+    return { kind: "root-help" };
+  }
+  const { first, rest } = firstTokenAndRest(trimmed);
+  const parsed = parseVerboseToken(first);
+  if (!parsed.ok) {
+    return {
+      kind: "error",
+      message: `Invalid token "${first}". Use name:true only with value true, or a bare name (e.g. cloud, wallet, help).`
+    };
+  }
+  const head = parsed.name;
+  if (head === "help") {
+    return { kind: "root-help" };
+  }
+  if (head === "cloud") {
+    return { kind: "cloud", rest };
+  }
+  if (head === "wallet") {
+    return { kind: "wallet", rest };
+  }
+  return {
+    kind: "error",
+    message: [
+      `Unknown command "${first}".`,
+      "",
+      "Try:",
+      "\u2022 `/mnemospark help` \u2014 overview",
+      "\u2022 `/mnemospark cloud help` \u2014 cloud commands",
+      "\u2022 `/mnemospark wallet` \u2014 wallet status",
+      "\u2022 `/mnemospark wallet help` \u2014 wallet commands"
+    ].join("\n")
+  };
+}
+
+// src/arg-schemas.ts
+var priceStorageSchema = {
+  args: [
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-id", aliases: ["object"], required: true },
+    { name: "object-id-hash", aliases: ["hash"], required: true },
+    { name: "gb", required: true },
+    { name: "provider", required: true },
+    { name: "region", required: true }
+  ]
+};
+var uploadSchema = {
+  args: [
+    { name: "quote-id", aliases: ["quote"], required: true },
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-id", aliases: ["object"], required: true },
+    { name: "object-id-hash", aliases: ["hash"], required: true },
+    { name: "name" },
+    { name: "async", bareBoolean: true },
+    { name: "orchestrator" },
+    { name: "timeout-seconds" }
+  ]
+};
+var backupFlagsSchema = {
+  args: [
+    { name: "name" },
+    { name: "async", bareBoolean: true },
+    { name: "orchestrator" },
+    { name: "timeout-seconds" }
+  ]
+};
+var paymentSettleSchema = {
+  args: [
+    { name: "quote-id", aliases: ["quote"] },
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-id", aliases: ["object"] },
+    { name: "object-key" },
+    { name: "storage-price" },
+    { name: "renewal", bareBoolean: true }
+  ]
+};
+var lsSchema = {
+  args: [
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-key" },
+    { name: "name" },
+    { name: "latest", bareBoolean: true },
+    { name: "at" },
+    { name: "location" },
+    { name: "region" }
+  ]
+};
+var downloadSchema = {
+  args: [
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-key" },
+    { name: "name" },
+    { name: "latest", bareBoolean: true },
+    { name: "at" },
+    { name: "location" },
+    { name: "region" },
+    { name: "async", bareBoolean: true },
+    { name: "orchestrator" },
+    { name: "timeout-seconds" }
+  ]
+};
+var deleteSchema = {
+  args: [
+    { name: "wallet-address", aliases: ["wallet"], required: true },
+    { name: "object-key" },
+    { name: "name" },
+    { name: "latest", bareBoolean: true },
+    { name: "at" },
+    { name: "location" },
+    { name: "region" }
+  ]
+};
+var opStatusSchema = {
+  args: [
+    { name: "operation-id", required: true },
+    { name: "cancel", bareBoolean: true }
+  ]
+};
+
 // src/cloud-command.ts
 var SUPPORTED_BACKUP_PLATFORMS = /* @__PURE__ */ new Set(["darwin", "linux"]);
 var BACKUP_DIR_SUBPATH = join8(".openclaw", "mnemospark", "backup");
@@ -3774,25 +4197,12 @@ var TAR_OVERHEAD_BYTES = 10 * 1024 * 1024;
 var QUOTE_VALIDITY_USER_NOTE = "Quotes are valid for one hour. Please run price-storage again if you need a new quote.";
 var MNEMOSPARK_SUPPORT_EMAIL = "pluggedin@mnemospark.ai";
 var CLOUD_HELP_FOOTER_STATE = "Local state: mnemospark records quotes, objects, payments, cron jobs, friendly names, and operation metadata in ~/.openclaw/mnemospark/state.db (SQLite). For troubleshooting and correlation, commands and the HTTP proxy append structured JSON lines to ~/.openclaw/mnemospark/events.jsonl. Monthly storage billing jobs are listed in ~/.openclaw/cron/jobs.json for OpenClaw scheduling.";
-var REQUIRED_PRICE_STORAGE = "--wallet-address, --object-id, --object-id-hash, --gb, --provider, --region";
-var REQUIRED_UPLOAD = "--quote-id, --wallet-address, --object-id, --object-id-hash";
-var REQUIRED_BACKUP = "<file|directory> and --name <friendly-name>";
-var REQUIRED_PAYMENT_SETTLE = "--wallet-address and (--quote-id | --renewal with --object-key)";
-var PAYMENT_SETTLE_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["renewal"]);
-var REQUIRED_STORAGE_OBJECT = "--wallet-address and one of (--object-key | --name [--latest|--at])";
-var REQUIRED_LS = "--wallet-address (for one object add --object-key or --name [--latest|--at]; omit both to list the bucket)";
-var PAYMENT_SETTLE_FLAG_NAMES = /* @__PURE__ */ new Set([
-  "quote-id",
-  "wallet-address",
-  "object-id",
-  "object-key",
-  "storage-price",
-  "renewal"
-]);
-var BOOLEAN_SELECTOR_FLAGS = /* @__PURE__ */ new Set(["latest"]);
-var BOOLEAN_ASYNC_FLAGS = /* @__PURE__ */ new Set(["async"]);
-var BOOLEAN_OP_STATUS_FLAGS = /* @__PURE__ */ new Set(["cancel"]);
-var BOOLEAN_SELECTOR_AND_ASYNC_FLAGS = /* @__PURE__ */ new Set(["latest", "async"]);
+var REQUIRED_PRICE_STORAGE = "wallet-address:, object-id:, object-id-hash:, gb:, provider:, region:";
+var REQUIRED_UPLOAD = "quote-id:, wallet-address:, object-id:, object-id-hash:";
+var REQUIRED_BACKUP = "<file|directory> and name:<friendly-name>";
+var REQUIRED_PAYMENT_SETTLE = "wallet-address: and (quote-id: | renewal:true with object-key:)";
+var REQUIRED_STORAGE_OBJECT = "wallet-address: and one of (object-key: | name: [latest:true|at:<timestamp>])";
+var REQUIRED_LS = "wallet-address: (for one object add object-key: or name: [latest:true|at:<timestamp>]; omit both to list the bucket)";
 var ORCHESTRATOR_MODES = /* @__PURE__ */ new Set(["inline", "subagent"]);
 function expandTilde(path) {
   const trimmed = path.trim();
@@ -3807,63 +4217,66 @@ function expandTilde(path) {
 var CLOUD_HELP_TEXT = [
   "\u2601\uFE0F **mnemospark - Wallet and go.** \u{1F499}",
   "",
+  "**Syntax:** use `/mnemospark cloud \u2026`. Prefer `key:value` for arguments; `key=value` and `--key value` are also accepted. Optional verbose markers: `cloud:true`, `price-storage:true`, etc. Aliases: `wallet:` \u2192 wallet-address, `object:` \u2192 object-id, `quote:` \u2192 quote-id, `hash:` \u2192 object-id-hash.",
+  "",
   "**Cloud Commands**",
   "",
-  "\u2022 `/mnemospark_cloud` or `/mnemospark_cloud help` \u2014 show this message",
+  "\u2022 `/mnemospark cloud` or `/mnemospark cloud help` \u2014 show this message (equivalent: `/mnemospark cloud:true help:true`)",
   "",
-  "\u2022 `/mnemospark_cloud backup <file|directory> --name <friendly-name> [--async] [--orchestrator <inline|subagent>] [--timeout-seconds <n>]`",
+  "\u2022 `/mnemospark cloud backup <file|directory> name:<friendly-name> [async:true] [orchestrator:<inline|subagent>] [timeout-seconds:<n>]`",
   "  Purpose: create a local tar+gzip archive under ~/.openclaw/mnemospark/backup (filename from sanitized friendly name) and record metadata in SQLite for later price-storage and upload.",
   "  Required: " + REQUIRED_BACKUP,
   "",
-  "\u2022 `/mnemospark_cloud price-storage --wallet-address <addr> --object-id <id> --object-id-hash <hash> --gb <gb> --provider aws --region us-east-1`",
-  "  Purpose: request a storage quote before upload (defaults shown; override `--provider` / `--region` for other regions).",
+  "\u2022 `/mnemospark cloud price-storage wallet-address:<addr> object-id:<id> object-id-hash:<hash> gb:<gb> provider:aws region:us-east-1`",
+  "  Purpose: request a storage quote before upload (defaults shown; override `provider:` / `region:` for other regions).",
   "  Required: " + REQUIRED_PRICE_STORAGE,
+  "  Shorter: `wallet:\u2026 object:\u2026 hash:\u2026 gb:\u2026 provider:\u2026 region:\u2026`",
   "",
-  "\u2022 `/mnemospark_cloud upload --quote-id <quote-id> --wallet-address <addr> --object-id <id> --object-id-hash <hash> [--name <friendly-name>] [--async] [--orchestrator <inline|subagent>] [--timeout-seconds <n>]`",
+  "\u2022 `/mnemospark cloud upload quote-id:<quote-id> wallet-address:<addr> object-id:<id> object-id-hash:<hash> [name:<friendly-name>] [async:true] [orchestrator:<inline|subagent>] [timeout-seconds:<n>]`",
   "  Purpose: upload an encrypted object using a valid quote-id.",
   "  Required: " + REQUIRED_UPLOAD,
   "",
-  "\u2022 `/mnemospark_cloud payment-settle (--quote-id <quote-id> | --renewal --object-key <key>) --wallet-address <addr> [--object-id <id>] [--storage-price <n>]`",
+  "\u2022 `/mnemospark cloud payment-settle (quote-id:<quote-id> | renewal:true object-key:<key>) wallet-address:<addr> [object-id:<id>] [storage-price:<n>]`",
   "  Purpose: settle storage payment before upload (quote) or on the monthly cron (renewal, no new quote). Uses the same proxy + x402 path as upload pre-settlement.",
   "  Required: " + REQUIRED_PAYMENT_SETTLE + " (wallet private key must match the address).",
   "",
-  "\u2022 `/mnemospark_cloud ls --wallet-address <addr> [--object-key <key> | --name <friendly-name> | omit both to list bucket] [--latest|--at <timestamp>]`",
+  "\u2022 `/mnemospark cloud ls wallet-address:<addr> [object-key:<key> | name:<friendly-name> | omit both to list bucket] [latest:true|at:<timestamp>]`",
   "  Purpose: stat one object or list all keys in the wallet bucket (S3).",
   "  Required: " + REQUIRED_LS,
   "",
-  "\u2022 `/mnemospark_cloud download --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>] [--async] [--orchestrator <inline|subagent>] [--timeout-seconds <n>]`",
+  "\u2022 `/mnemospark cloud download wallet-address:<addr> [object-key:<object-key> | name:<friendly-name>] [latest:true|at:<timestamp>] [async:true] [orchestrator:<inline|subagent>] [timeout-seconds:<n>]`",
   "  Purpose: fetch an object to local disk.",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
-  "\u2022 `/mnemospark_cloud delete --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>]`",
+  "\u2022 `/mnemospark cloud delete wallet-address:<addr> [object-key:<object-key> | name:<friendly-name>] [latest:true|at:<timestamp>]`",
   "  Purpose: remove a remote object and local cron tracking when present.",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
-  "\u2022 `/mnemospark_cloud op-status --operation-id <id> [--cancel]`",
+  "\u2022 `/mnemospark cloud op-status operation-id:<id> [cancel:true]`",
   "  Purpose: inspect async operation status, or request cancellation for subagent runs.",
-  "  Required: --operation-id",
+  "  Required: operation-id:<id>",
   "",
   "Async orchestration flags (`backup`, `upload`, `download` only):",
-  "\u2022 `--async`",
+  "\u2022 `async:true`",
   "  Start operation in background and return quickly with operation-id.",
-  "\u2022 `--orchestrator <inline|subagent>`",
+  "\u2022 `orchestrator:<inline|subagent>`",
   "  Choose async engine. Default when omitted is `inline`.",
   "  Use `subagent` for explicit subagent session tracking and cancellation.",
-  "\u2022 `--timeout-seconds <n>`",
-  "  Optional per-operation timeout. Valid only with `--async --orchestrator subagent`.",
+  "\u2022 `timeout-seconds:<n>`",
+  "  Optional per-operation timeout. Valid only with `async:true` and `orchestrator:subagent`.",
   "  `n` must be a positive integer (seconds).",
-  "\u2022 `op-status --cancel`",
+  "\u2022 `op-status` with `cancel:true`",
   "  Cancel a subagent-orchestrated operation by operation-id (idempotent).",
   "",
   "Examples:",
-  "\u2022 `/mnemospark_cloud upload ... --async --orchestrator subagent`",
-  "\u2022 `/mnemospark_cloud download ... --async --orchestrator subagent --timeout-seconds 900`",
-  "\u2022 `/mnemospark_cloud op-status --operation-id <id>`",
-  "\u2022 `/mnemospark_cloud op-status --operation-id <id> --cancel`",
+  "\u2022 `/mnemospark cloud upload ... async:true orchestrator:subagent`",
+  "\u2022 `/mnemospark cloud download ... async:true orchestrator:subagent timeout-seconds:900`",
+  "\u2022 `/mnemospark cloud op-status operation-id:<id>`",
+  "\u2022 `/mnemospark cloud op-status operation-id:<id> cancel:true`",
   "",
   CLOUD_HELP_FOOTER_STATE,
   "",
-  "Backup uses your configured mnemospark wallet key (no `--wallet-address` flag). Commands price-storage, upload, ls, download, delete, and payment-settle require `--wallet-address` on the command line (must match that wallet)."
+  "Backup uses your configured mnemospark wallet key (no `wallet-address:` argument). Commands price-storage, upload, ls, download, delete, and payment-settle require `wallet-address:<addr>` (or `wallet:<addr>`) on the command line (must match that wallet)."
 ].join("\n");
 var UnsupportedBackupPlatformError = class extends Error {
   constructor(platform) {
@@ -3892,37 +4305,6 @@ function tokenizeArgsRaw(input) {
   }
   return tokens;
 }
-function tokenizeArgs(input) {
-  return tokenizeArgsRaw(input).map((token) => stripWrappingQuotes(token));
-}
-function parseNamedFlagsTokens(tokens, booleanFlags = /* @__PURE__ */ new Set()) {
-  if (tokens.length === 0) {
-    return null;
-  }
-  const parsed = {};
-  for (let i = 0; i < tokens.length; i += 1) {
-    const keyToken = tokens[i];
-    if (!keyToken.startsWith("--")) {
-      return null;
-    }
-    const key = keyToken.slice(2).toLowerCase().replace(/_/g, "-");
-    const value = tokens[i + 1];
-    if (!value || value.startsWith("--")) {
-      if (booleanFlags.has(key)) {
-        parsed[key] = "true";
-        continue;
-      }
-      return null;
-    }
-    parsed[key] = value;
-    i += 1;
-  }
-  return parsed;
-}
-function parseNamedFlags(input, booleanFlags = /* @__PURE__ */ new Set()) {
-  const tokens = tokenizeArgs(input);
-  return parseNamedFlagsTokens(tokens, booleanFlags);
-}
 function parseObjectSelector(flags) {
   const objectKey = flags["object-key"]?.trim();
   const name = flags.name?.trim();
@@ -4015,10 +4397,18 @@ function parseAsyncOperationArgs(flags) {
     timeoutSeconds: parsedTimeoutSeconds === void 0 ? void 0 : parsedTimeoutSeconds
   };
 }
-var INVALID_ASYNC_FLAGS_MESSAGE = "invalid async flags. `--orchestrator`/`--timeout-seconds` require `--async`, and `--timeout-seconds` is only valid with `--orchestrator subagent`.";
+var INVALID_ASYNC_FLAGS_MESSAGE = "invalid async flags. `orchestrator:` and `timeout-seconds:` require `async:true`, and `timeout-seconds:` is only valid with `orchestrator:subagent`.";
 function stripAsyncControlFlags(args) {
   const tokens = tokenizeArgsRaw(args ?? "");
   const filtered = [];
+  const isAsyncControlKey = (rawKey) => {
+    const canonical = rawKey.trim().toLowerCase().replace(/_/g, "-");
+    return canonical === "async" || canonical === "orchestrator" || canonical === "timeout-seconds";
+  };
+  const isBareBooleanFlag = (rawToken) => {
+    const canonical = rawToken.trim().toLowerCase().replace(/^--/, "").replace(/_/g, "-");
+    return canonical === "async" || canonical === "latest";
+  };
   for (let idx = 0; idx < tokens.length; idx += 1) {
     const token = tokens[idx];
     const lowerToken = token.toLowerCase();
@@ -4029,35 +4419,71 @@ function stripAsyncControlFlags(args) {
       idx += 1;
       continue;
     }
+    const previousToken = tokens[idx - 1];
+    if (previousToken && previousToken.startsWith("--") && !isBareBooleanFlag(previousToken)) {
+      filtered.push(token);
+      continue;
+    }
+    const unwrapped = stripWrappingQuotes(token);
+    const colonIdx = unwrapped.indexOf(":");
+    const equalsIdx = unwrapped.indexOf("=");
+    const splitIdx = colonIdx > 0 && equalsIdx > 0 ? Math.min(colonIdx, equalsIdx) : Math.max(colonIdx, equalsIdx);
+    if (splitIdx > 0) {
+      const candidateKey = unwrapped.slice(0, splitIdx);
+      if (/^[A-Za-z_][A-Za-z0-9_-]*$/.test(candidateKey) && isAsyncControlKey(candidateKey)) {
+        continue;
+      }
+    }
     filtered.push(token);
   }
   return filtered.join(" ");
 }
+function mergeArgParseWarnings(a, b) {
+  return [...a, ...b];
+}
 function parseCloudArgs(args) {
   const trimmed = args?.trim() ?? "";
   if (!trimmed) {
     return { mode: "help" };
   }
-  const spaceIdx = trimmed.indexOf(" ");
-  const subcommand = (spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx)).toLowerCase();
-  const rest = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+  const norm = normalizeInputForParsing(trimmed);
+  const text = norm.text;
+  const normWarnings = norm.warnings;
+  const spaceIdx = text.search(/\s/);
+  const rawFirst = spaceIdx === -1 ? text : text.slice(0, spaceIdx);
+  const rest = spaceIdx === -1 ? "" : text.slice(spaceIdx + 1).trim();
+  const subParsed = parseVerboseToken(rawFirst);
+  if (!subParsed.ok) {
+    return {
+      mode: "arg-parse-failure",
+      errors: [`Invalid subcommand token "${rawFirst}". Use name:true only with value true.`],
+      warnings: normWarnings
+    };
+  }
+  const subcommand = subParsed.name;
   if (subcommand === "help") {
     return { mode: "help" };
   }
   if (subcommand === "backup") {
-    const tokens = tokenizeArgs(rest);
+    const tokens = tokenizeArgsRaw(rest);
     if (tokens.length === 0) {
       return { mode: "unknown" };
     }
-    const backupTarget = tokens[0] ?? "";
+    const backupTarget = stripWrappingQuotes(tokens[0] ?? "");
     if (!backupTarget) {
       return { mode: "unknown" };
     }
     const remainingTokens = tokens.slice(1);
-    const flags = remainingTokens.length === 0 ? {} : parseNamedFlagsTokens(remainingTokens, BOOLEAN_ASYNC_FLAGS);
-    if (!flags) {
-      return { mode: "backup-invalid" };
+    const flagsPart = remainingTokens.join(" ");
+    const parsed = parseCommandArgs(flagsPart, backupFlagsSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const asyncArgs = parseAsyncOperationArgs(flags);
     if (!asyncArgs) {
       return { mode: "backup-invalid-async" };
@@ -4074,10 +4500,15 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "price-storage") {
-    const flags = parseNamedFlags(rest);
-    if (!flags) {
-      return { mode: "price-storage-invalid" };
+    const parsed = parseCommandArgs(rest, priceStorageSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const gb = Number.parseFloat(flags.gb ?? "");
     const request = parsePriceStorageQuoteRequest({
       wallet_address: flags["wallet-address"],
@@ -4093,10 +4524,15 @@ function parseCloudArgs(args) {
     return { mode: "price-storage", priceStorageRequest: request };
   }
   if (subcommand === "upload") {
-    const flags = parseNamedFlags(rest, BOOLEAN_ASYNC_FLAGS);
-    if (!flags) {
-      return { mode: "upload-invalid" };
+    const parsed = parseCommandArgs(rest, uploadSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const asyncArgs = parseAsyncOperationArgs(flags);
     if (!asyncArgs) {
       return { mode: "upload-invalid-async" };
@@ -4121,15 +4557,15 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "payment-settle") {
-    const flags = parseNamedFlags(rest, PAYMENT_SETTLE_BOOLEAN_FLAGS);
-    if (!flags) {
-      return { mode: "payment-settle-invalid" };
-    }
-    for (const key of Object.keys(flags)) {
-      if (!PAYMENT_SETTLE_FLAG_NAMES.has(key)) {
-        return { mode: "payment-settle-invalid" };
-      }
+    const parsed = parseCommandArgs(rest, paymentSettleSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const walletAddress = flags["wallet-address"]?.trim();
     if (!walletAddress) {
       return { mode: "payment-settle-invalid" };
@@ -4169,11 +4605,16 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "ls") {
-    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_FLAGS);
-    if (!flags) {
-      return { mode: "ls-invalid" };
+    const parsed = parseCommandArgs(rest, lsSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
-    const walletAddress = flags["wallet-address"]?.trim() ?? flags["wallet_address"]?.trim() ?? "";
+    const flags = valuesToStringRecord(parsed.values);
+    const walletAddress = flags["wallet-address"]?.trim() ?? "";
     if (!walletAddress) {
       return { mode: "ls-invalid" };
     }
@@ -4205,10 +4646,15 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "download") {
-    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_AND_ASYNC_FLAGS);
-    if (!flags) {
-      return { mode: "download-invalid" };
+    const parsed = parseCommandArgs(rest, downloadSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const asyncArgs = parseAsyncOperationArgs(flags);
     if (!asyncArgs) {
       return { mode: "download-invalid-async" };
@@ -4229,10 +4675,15 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "delete") {
-    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_FLAGS);
-    if (!flags) {
-      return { mode: "delete-invalid" };
+    const parsed = parseCommandArgs(rest, deleteSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
     }
+    const flags = valuesToStringRecord(parsed.values);
     const selector = parseObjectSelector(flags);
     if (!selector) {
       return { mode: "delete-invalid" };
@@ -4244,12 +4695,20 @@ function parseCloudArgs(args) {
     return { mode: "delete", storageObjectRequest: request, nameSelector: selector.nameSelector };
   }
   if (subcommand === "op-status") {
-    const flags = parseNamedFlags(rest, BOOLEAN_OP_STATUS_FLAGS);
-    const operationId = flags?.["operation-id"]?.trim();
+    const parsed = parseCommandArgs(rest, opStatusSchema);
+    if (!parsed.ok) {
+      return {
+        mode: "arg-parse-failure",
+        errors: parsed.errors,
+        warnings: mergeArgParseWarnings(normWarnings, parsed.warnings)
+      };
+    }
+    const flags = valuesToStringRecord(parsed.values);
+    const operationId = flags["operation-id"]?.trim();
     if (!operationId) {
       return { mode: "op-status-invalid" };
     }
-    return { mode: "op-status", operationId, cancel: flags?.cancel === "true" };
+    return { mode: "op-status", operationId, cancel: flags.cancel === "true" };
   }
   return { mode: "unknown" };
 }
@@ -4334,7 +4793,7 @@ async function resolveLocalUploadArchivePath(backupDir, objectId, friendlyName)
   } catch {
     return {
       ok: false,
-      message: `Cannot upload storage object: local archive not found. Run /mnemospark_cloud backup with --name (canonical layout) or restore the legacy file at ${legacyPath}.`
+      message: `Cannot upload storage object: local archive not found. Run /mnemospark cloud backup with name:<friendly-name> (canonical layout) or restore the legacy file at ${legacyPath}.`
     };
   }
 }
@@ -4555,7 +5014,7 @@ function buildStoragePaymentRenewalArgs(job) {
   ].join(" ");
 }
 function buildStoragePaymentCronCommand(job) {
-  return `/mnemospark_cloud ${buildStoragePaymentRenewalArgs(job)}`;
+  return `/mnemospark cloud ${buildStoragePaymentRenewalArgs(job)}`;
 }
 function buildOpenClawRenewalAgentMessage(openClawHome, renewalArgs) {
   const cliPath = join8(openClawHome, ".openclaw/extensions/mnemospark/dist/cli.js");
@@ -4895,7 +5354,7 @@ async function maybeCleanupLocalBackupArchive(archivePath) {
   }
 }
 function formatStorageUploadUserMessage(upload, cronJobId) {
-  const lsLine = `/mnemospark_cloud ls --wallet-address \`${upload.addr}\``;
+  const lsLine = `/mnemospark cloud ls wallet-address:\`${upload.addr}\``;
   return [
     `Your file \`${upload.object_id}\` with key \`${upload.object_key}\` has been stored using \`${upload.provider}\` in folder \`${upload.bucket_name}\` in region \`${upload.location}\``,
     "",
@@ -4953,7 +5412,7 @@ function extractLsErrorMessage(error) {
   return null;
 }
 function formatPriceStorageUserMessage(quote, localArchiveHint) {
-  const uploadLine = `/mnemospark_cloud upload --quote-id \`${quote.quote_id}\` --wallet-address \`${quote.addr}\` --object-id \`${quote.object_id}\` --object-id-hash \`${quote.object_id_hash}\``;
+  const uploadLine = `/mnemospark cloud upload quote-id:\`${quote.quote_id}\` wallet-address:\`${quote.addr}\` object-id:\`${quote.object_id}\` object-id-hash:\`${quote.object_id_hash}\``;
   const lines = [
     `Your storage quote \`${quote.quote_id}\`: storage price \`$${quote.storage_price}\` for file \`${quote.object_id}\` with file size \`${quote.object_size_gb}\` in \`${quote.provider}\` \`${quote.location}\`.`,
     "",
@@ -4978,7 +5437,7 @@ var DEFAULT_BACKUP_QUOTE_PROVIDER = "aws";
 var DEFAULT_BACKUP_QUOTE_REGION = "us-east-1";
 function formatBackupSuccessUserMessage(result, walletAddress, friendlyName) {
   const hash = result.objectIdHash.replace(/\s/g, "");
-  const priceStorageLine = `/mnemospark_cloud price-storage --wallet-address \`${walletAddress}\` --object-id \`${result.objectId}\` --object-id-hash \`${hash}\` --gb \`${result.objectSizeGb}\` --provider ${DEFAULT_BACKUP_QUOTE_PROVIDER} --region ${DEFAULT_BACKUP_QUOTE_REGION}`;
+  const priceStorageLine = `/mnemospark cloud price-storage wallet-address:\`${walletAddress}\` object-id:\`${result.objectId}\` object-id-hash:\`${hash}\` gb:\`${result.objectSizeGb}\` provider:${DEFAULT_BACKUP_QUOTE_PROVIDER} region:${DEFAULT_BACKUP_QUOTE_REGION}`;
   return [
     `Backup archive: \`${result.archivePath}\``,
     "",
@@ -4994,10 +5453,10 @@ function formatBackupSuccessUserMessage(result, walletAddress, friendlyName) {
     `The default region is ${DEFAULT_BACKUP_QUOTE_REGION}. Change the command parameters to switch regions (not required).`,
     "",
     "Region examples (merge into the command above):",
-    "North America: `--provider aws --region us-east-1`",
-    "Europe: `--provider aws --region eu-north-1`",
-    "South America: `--provider aws --region sa-east-1`",
-    "Asia Pacific: `--provider aws --region ap-northeast-1`"
+    "North America: `provider:aws region:us-east-1`",
+    "Europe: `provider:aws region:eu-north-1`",
+    "South America: `provider:aws region:sa-east-1`",
+    "Asia Pacific: `provider:aws region:ap-northeast-1`"
   ].join("\n");
 }
 function createInProcessSubagentOrchestrator() {
@@ -5101,9 +5560,9 @@ function createInProcessSubagentOrchestrator() {
 function createCloudCommand(options = {}) {
   const subagentOrchestrator = options.subagentOrchestrator ?? createInProcessSubagentOrchestrator();
   return {
-    name: "mnemospark_cloud",
+    name: "mnemospark",
     nativeNames: {
-      default: "mnemospark_cloud"
+      default: "mnemospark"
     },
     description: "Manage mnemospark cloud storage workflow commands",
     acceptsArgs: true,
@@ -5431,15 +5890,24 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
       isError: parsed.mode === "unknown"
     };
   }
-  if (parsed.mode === "price-storage-invalid") {
+  if (parsed.mode === "arg-parse-failure") {
     return {
-      text: `Cannot price storage: required arguments are ${REQUIRED_PRICE_STORAGE}.`,
+      text: [
+        "Could not parse command arguments.",
+        ...parsed.errors.map((e) => `- ${e}`),
+        ...parsed.warnings.length > 0 ? ["", "Notes:", ...parsed.warnings.map((w) => `- ${w}`)] : [],
+        "",
+        "Accepted formats:",
+        "- key:value",
+        "- key=value",
+        "- --key value"
+      ].join("\n"),
       isError: true
     };
   }
-  if (parsed.mode === "backup-invalid") {
+  if (parsed.mode === "price-storage-invalid") {
     return {
-      text: "Cannot build storage object",
+      text: `Cannot price storage: required arguments are ${REQUIRED_PRICE_STORAGE}.`,
       isError: true
     };
   }
@@ -5469,7 +5937,7 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
   }
   if (parsed.mode === "payment-settle-invalid") {
     return {
-      text: `Cannot settle payment: required arguments are ${REQUIRED_PAYMENT_SETTLE}. Optional: --object-id, --storage-price.`,
+      text: `Cannot settle payment: required arguments are ${REQUIRED_PAYMENT_SETTLE}. Optional: object-id:, storage-price:.`,
       isError: true
     };
   }
@@ -5499,7 +5967,7 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
   }
   if (parsed.mode === "op-status-invalid") {
     return {
-      text: "Cannot get operation status: required arguments are --operation-id.",
+      text: "Cannot get operation status: required arguments are operation-id:<id>.",
       isError: true
     };
   }
@@ -5635,7 +6103,7 @@ ${operation.result_text}` : meta;
     const walletAccount = privateKeyToAccount5(walletKey);
     if (walletAccount.address.toLowerCase() !== req.wallet_address.toLowerCase()) {
       return {
-        text: `Cannot settle payment: wallet key address ${walletAccount.address} does not match --wallet-address ${req.wallet_address}.`,
+        text: `Cannot settle payment: wallet key address ${walletAccount.address} does not match wallet-address: ${req.wallet_address}.`,
         isError: true
       };
     }
@@ -5729,7 +6197,7 @@ ${operation.result_text}` : meta;
       });
       const label = req.renewal ? `object ${req.object_key}` : `quote ${req.quote_id}`;
       return {
-        text: transId ? `Payment settled for ${label} (trans_id: ${transId}).` : `Payment settled for ${label}.`
+        text: transId ? `Payment settled for ${label} (trans-id: ${transId}).` : `Payment settled for ${label}.`
       };
     }
     await datastore.upsertPayment({
@@ -5808,7 +6276,7 @@ ${operation.result_text}` : meta;
         args: syncArgs,
         timeoutSeconds: parsed.timeoutSeconds,
         requestedBy: {
-          pluginCommand: "mnemospark_cloud",
+          pluginCommand: "mnemospark",
           chatId: ctx.channel,
           senderId: ctx.senderId
         }
@@ -5991,7 +6459,7 @@ ${operation.result_text}` : meta;
             `orchestrator: subagent`,
             `subagent-session-id: ${dispatchResult.sessionId}`,
             timeoutSeconds ? `timeout-seconds: ${timeoutSeconds}` : null,
-            `Use /mnemospark_cloud op-status --operation-id ${operationId}`
+            `Use /mnemospark cloud op-status operation-id:${operationId}`
           ].filter((line) => Boolean(line)).join("\n")
         };
       } catch (dispatchError) {
@@ -6094,7 +6562,7 @@ operation-id: ${operationId}`,
       text: [
         `Operation started in background. operation-id: ${operationId}`,
         `orchestrator: inline`,
-        `Use /mnemospark_cloud op-status --operation-id ${operationId}`
+        `Use /mnemospark cloud op-status operation-id:${operationId}`
       ].join("\n")
     };
   }
@@ -6264,7 +6732,7 @@ operation-id: ${operationId}`,
       const loggedQuote = await datastore.findQuoteById(parsed.uploadRequest.quote_id);
       if (!loggedQuote) {
         return {
-          text: "Cannot upload storage object: quote-id not found in local SQLite. Run /mnemospark_cloud price-storage first (quotes expire after about one hour on the server).",
+          text: "Cannot upload storage object: quote-id not found in local SQLite. Run /mnemospark cloud price-storage first (quotes expire after about one hour on the server).",
           isError: true
         };
       }
@@ -6280,7 +6748,7 @@ operation-id: ${operationId}`,
       );
       if (!dbFriendly?.trim()) {
         return {
-          text: "Cannot upload storage object: no friendly name in local SQLite for this object-id. Run /mnemospark_cloud backup with --name first.",
+          text: "Cannot upload storage object: no friendly name in local SQLite for this object-id. Run /mnemospark cloud backup with --name first.",
           isError: true
         };
       }
@@ -6306,7 +6774,7 @@ operation-id: ${operationId}`,
         archiveStats = await stat2(archivePath);
       } catch {
         return {
-          text: `Cannot upload storage object: local archive not found at ${archivePath}. Run /mnemospark_cloud backup first.`,
+          text: `Cannot upload storage object: local archive not found at ${archivePath}. Run /mnemospark cloud backup first.`,
           isError: true
         };
       }
@@ -6327,7 +6795,7 @@ operation-id: ${operationId}`,
       const walletAccount = privateKeyToAccount5(walletKey);
       if (walletAccount.address.toLowerCase() !== parsed.uploadRequest.wallet_address.toLowerCase()) {
         return {
-          text: `Cannot upload storage object: wallet key address ${walletAccount.address} does not match --wallet-address ${parsed.uploadRequest.wallet_address}.`,
+          text: `Cannot upload storage object: wallet key address ${walletAccount.address} does not match wallet-address: ${parsed.uploadRequest.wallet_address}.`,
           isError: true
         };
       }
@@ -6833,12 +7301,192 @@ operation-id: ${operationId}`,
   };
 }
 
+// src/mnemospark-handler.ts
+var MNEMOSPARK_ROOT_HELP_TEXT = [
+  "\u2601\uFE0F **mnemospark - Wallet and go.** \u{1F499}",
+  "",
+  "**Syntax:** `/mnemospark cloud \u2026` or `/mnemospark wallet \u2026`",
+  "Arguments may use `key:value`, `key=value`, or `--key value`. Optional verbose markers: `cloud:true`, `price-storage:true`, etc. (same as bare words).",
+  "Aliases include `wallet:` \u2192 wallet-address, `object:` \u2192 object-id, `quote:` \u2192 quote-id (see `/mnemospark cloud help`).",
+  "",
+  "**Cloud storage** \u2014 full reference:",
+  "\u2022 `/mnemospark cloud help`",
+  "",
+  "**Wallet** \u2014 status:",
+  "\u2022 `/mnemospark wallet`",
+  "\u2022 `/mnemospark wallet help` \u2014 commands and funding link"
+].join("\n");
+var MNEMOSPARK_WALLET_HELP_TEXT = (address) => [
+  "\u2601\uFE0F **mnemospark Wallet**",
+  "",
+  "**Commands:**",
+  "\u2022 `/mnemospark wallet` \u2014 Show address, balance, and key file path",
+  "\u2022 `/mnemospark wallet help` \u2014 This message",
+  "\u2022 `/mnemospark wallet export` \u2014 Export private key for backup (sensitive)",
+  "",
+  `**Fund with USDC on Base:** https://basescan.org/address/${address}`
+].join("\n");
+var defaultCloudCommandHandler;
+function getDefaultCloudCommandHandler() {
+  defaultCloudCommandHandler ??= createCloudCommand().handler;
+  return defaultCloudCommandHandler;
+}
+var NO_WALLET_FOUND_TEXT = "No mnemospark wallet found. Run `openclaw plugins install mnemospark`.";
+function resolveWalletFileSync() {
+  try {
+    if (!existsSync(WALLET_FILE)) {
+      return null;
+    }
+    const walletKey = readFileSync(WALLET_FILE, "utf-8").trim();
+    if (!walletKey.startsWith("0x") || walletKey.length !== 66) {
+      return null;
+    }
+    const account = privateKeyToAccount6(walletKey);
+    const address = account.address.replace(/\s/g, "");
+    if (!address) {
+      return null;
+    }
+    return { walletKey, address };
+  } catch {
+    return null;
+  }
+}
+async function runMnemosparkSlashHandler(ctx, options) {
+  const route = routeMnemosparkArgs(ctx.args);
+  if (route.kind === "root-help") {
+    return { text: MNEMOSPARK_ROOT_HELP_TEXT };
+  }
+  if (route.kind === "error") {
+    return { text: route.message, isError: true };
+  }
+  if (route.kind === "cloud") {
+    const cloudCommandHandler = options?.cloudCommandHandler ?? getDefaultCloudCommandHandler();
+    return cloudCommandHandler({ ...ctx, args: route.rest });
+  }
+  return handleWalletSlash(route.rest);
+}
+async function handleWalletSlash(rest) {
+  const trimmed = rest.trim();
+  if (!trimmed) {
+    return buildWalletStatusResponse();
+  }
+  const { first, rest: afterFirst } = firstTokenAndRest(trimmed);
+  const parsed = parseVerboseToken(first);
+  if (!parsed.ok) {
+    return {
+      text: `Invalid token "${first}". Use name:true only with value true.`,
+      isError: true
+    };
+  }
+  if (parsed.name === "help") {
+    if (afterFirst.trim()) {
+      return {
+        text: "Unexpected extra arguments after `help`. Use `/mnemospark wallet help` alone.",
+        isError: true
+      };
+    }
+    return buildWalletHelpResponse();
+  }
+  if (parsed.name === "export") {
+    if (afterFirst.trim()) {
+      return {
+        text: "Unexpected extra arguments after `export`. Use `/mnemospark wallet export` alone.",
+        isError: true
+      };
+    }
+    return buildWalletExportResponse();
+  }
+  if (parsed.name === "status") {
+    return buildWalletStatusResponse();
+  }
+  return {
+    text: `Unknown wallet command "${parsed.name}". Try \`/mnemospark wallet help\`.`,
+    isError: true
+  };
+}
+async function buildWalletStatusResponse() {
+  const wallet = resolveWalletFileSync();
+  if (!wallet) {
+    return {
+      text: NO_WALLET_FOUND_TEXT,
+      isError: true
+    };
+  }
+  const { address } = wallet;
+  let balanceText = "Balance: (checking...)";
+  try {
+    const monitor = new BalanceMonitor(address);
+    const balance = await monitor.checkBalance();
+    balanceText = `Balance: ${balance.balanceUSD}`;
+  } catch {
+    balanceText = "Balance: (could not check)";
+  }
+  return {
+    text: [
+      "\u2601\uFE0F **mnemospark Wallet**",
+      "",
+      `**Address:** \`${address}\``,
+      `**${balanceText}**`,
+      `**Key File:** \`${WALLET_FILE}\``,
+      "",
+      "**Commands:**",
+      "\u2022 `/mnemospark wallet` \u2014 Show this status",
+      "\u2022 `/mnemospark wallet help` \u2014 Commands and funding link",
+      "\u2022 `/mnemospark wallet export` \u2014 Export private key for backup",
+      "",
+      `**Fund with USDC on Base:** https://basescan.org/address/${address}`
+    ].join("\n")
+  };
+}
+async function buildWalletHelpResponse() {
+  const wallet = resolveWalletFileSync();
+  if (!wallet) {
+    return {
+      text: NO_WALLET_FOUND_TEXT,
+      isError: true
+    };
+  }
+  const { address } = wallet;
+  return { text: MNEMOSPARK_WALLET_HELP_TEXT(address) };
+}
+async function buildWalletExportResponse() {
+  const wallet = resolveWalletFileSync();
+  if (!wallet) {
+    return {
+      text: NO_WALLET_FOUND_TEXT,
+      isError: true
+    };
+  }
+  const { walletKey, address } = wallet;
+  const addressDisplay = address.replace(/\s/g, "");
+  const keyDisplay = walletKey.replace(/\s/g, "");
+  return {
+    text: [
+      "\u2601\uFE0F **mnemospark Wallet Export**",
+      "",
+      "\u26A0\uFE0F **SECURITY WARNING**: Your private key controls your wallet funds.",
+      "Never share this key. Anyone with this key can spend your USDC.",
+      "",
+      `**Address:** \`${addressDisplay}\``,
+      "",
+      "**Private Key:**",
+      `\`${keyDisplay}\``,
+      "",
+      "**To restore on a new machine:**",
+      "1. Set the environment variable before running OpenClaw:",
+      `   \`export MNEMOSPARK_WALLET_KEY=${keyDisplay}\``,
+      "2. Or save to file:",
+      `   \`mkdir -p ~/.openclaw/mnemospark/wallet && echo "${keyDisplay}" > ~/.openclaw/mnemospark/wallet/wallet.key && chmod 600 ~/.openclaw/mnemospark/wallet/wallet.key\``
+    ].join("\n")
+  };
+}
+
 // src/cli.ts
 import { spawn as spawn2 } from "child_process";
 import { dirname as dirname6, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir7 } from "os";
 function isHexPrivateKey(value) {
   return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value.trim());
@@ -6900,6 +7548,7 @@ function parseArgs(args) {
     command: void 0,
     installMode: void 0,
     cloudArgs: void 0,
+    walletArgs: void 0,
     proxySubcommand: void 0
   };
   for (let i = 0; i < args.length; i++) {
@@ -6913,6 +7562,8 @@ function parseArgs(args) {
         result.command = "check-update";
       } else if (arg === "wallet") {
         result.command = "wallet";
+        result.walletArgs = args.slice(i + 1).join(" ");
+        return result;
       } else if (arg === "cloud") {
         result.command = "cloud";
         result.cloudArgs = args.slice(i + 1).join(" ");
@@ -6951,11 +7602,11 @@ async function ensureDir(path) {
 }
 async function deployExtensionFiles() {
   const scriptsSource = join9(PACKAGE_ROOT, "scripts");
-  if (!existsSync(scriptsSource)) return;
+  if (!existsSync2(scriptsSource)) return;
   const mnemoScriptsDir = join9(homedir7(), ".openclaw", "mnemospark", "scripts");
   await ensureDir(mnemoScriptsDir);
   const uninstallSrc = join9(scriptsSource, "uninstall.sh");
-  if (existsSync(uninstallSrc)) {
+  if (existsSync2(uninstallSrc)) {
     const content = await readFile4(uninstallSrc);
     await writeFile4(join9(mnemoScriptsDir, "uninstall.sh"), content, { mode: 493 });
   }
@@ -7159,28 +7810,15 @@ async function runInstall(mode) {
   );
   await promptOrRunOpenClawPluginInstall();
 }
-async function runWallet() {
-  const { address, source } = await resolveOrGenerateWalletKey();
-  console.log(`[mnemospark] Wallet address: ${address}`);
-  console.log(`[mnemospark] Key file: ${WALLET_FILE}`);
-  if (source === "generated") {
-    console.log("[mnemospark] New wallet generated and saved.");
-  } else if (source === "saved") {
-    console.log("[mnemospark] Loaded saved wallet.");
-  } else {
-    console.log("[mnemospark] Using wallet from MNEMOSPARK_WALLET_KEY.");
-  }
-}
-async function runCloud(cloudArgs) {
-  const cloudCmd = createCloudCommand();
+async function runMnemosparkCli(argsLine) {
   const ctx = {
     channel: "cli",
     isAuthorizedSender: true,
-    args: cloudArgs,
-    commandBody: `cloud ${cloudArgs}`,
+    args: argsLine.trim(),
+    commandBody: argsLine.trim(),
     config: {}
   };
-  const result = await cloudCmd.handler(ctx);
+  const result = await runMnemosparkSlashHandler(ctx);
   if (result.text) {
     console.log(result.text);
   }
@@ -7189,7 +7827,12 @@ async function runCloud(cloudArgs) {
   }
 }
 async function main() {
-  const args = parseArgs(process.argv.slice(2));
+  const argv = process.argv.slice(2);
+  if (argv.length === 1 && argv[0] === "help") {
+    await runMnemosparkCli("help");
+    return;
+  }
+  const args = parseArgs(argv);
   if (args.version) {
     console.log(VERSION);
     process.exit(0);
@@ -7212,11 +7855,13 @@ async function main() {
     return;
   }
   if (args.command === "wallet") {
-    await runWallet();
+    const line = `wallet ${args.walletArgs ?? ""}`.trim();
+    await runMnemosparkCli(line);
     return;
   }
   if (args.command === "cloud") {
-    await runCloud(args.cloudArgs ?? "");
+    const line = `cloud ${args.cloudArgs ?? ""}`.trim();
+    await runMnemosparkCli(line);
     return;
   }
   if (args.command === "proxy") {