mnemospark 0.1.22 → 0.2.0

package/dist/index.js

@@ -1766,7 +1766,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;
         }
@@ -1834,7 +1834,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;
@@ -1980,7 +1980,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;
         }
@@ -2043,7 +2043,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;
         }
@@ -2151,7 +2151,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;
@@ -2169,7 +2169,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;
         }
@@ -2250,7 +2250,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;
@@ -2268,7 +2268,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;
         }
@@ -2341,7 +2341,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;
@@ -2361,7 +2361,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;
         }
@@ -2459,7 +2459,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;
@@ -2477,7 +2477,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;
         }
@@ -2554,7 +2554,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;
@@ -2806,7 +2806,7 @@ import { mkdir as mkdir4 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
 var DB_SUBPATH = join7(".openclaw", "mnemospark", "state.db");
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
 function resolveDbPath(homeDir) {
   return join7(homeDir ?? homedir5(), DB_SUBPATH);
 }
@@ -2912,6 +2912,21 @@ async function createCloudDatastore(homeDir) {
       CREATE INDEX IF NOT EXISTS idx_friendly_names_wallet ON friendly_names(wallet_address);
       CREATE INDEX IF NOT EXISTS idx_friendly_names_created_at ON friendly_names(created_at);
     `);
+    const addOperationsColumn = (columnName, sqlType) => {
+      try {
+        nextDb.exec(`ALTER TABLE operations ADD COLUMN ${columnName} ${sqlType}`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message.toLowerCase() : String(error);
+        if (!message.includes("duplicate column name")) {
+          throw error;
+        }
+      }
+    };
+    addOperationsColumn("trace_id", "TEXT");
+    addOperationsColumn("orchestrator", "TEXT");
+    addOperationsColumn("subagent_session_id", "TEXT");
+    addOperationsColumn("timeout_seconds", "INTEGER");
+    addOperationsColumn("cancel_requested_at", "TEXT");
     nextDb.prepare(
       `INSERT INTO schema_migrations(version, applied_at)
        VALUES(?, ?)
@@ -2923,7 +2938,10 @@ async function createCloudDatastore(homeDir) {
     try {
       await ensureReady();
       return fn();
-    } catch {
+    } catch (error) {
+      if (process.env.MNEMOSPARK_SQLITE_STRICT === "1") {
+        throw error;
+      }
       return fallback;
     }
   };
@@ -3048,13 +3066,19 @@ async function createCloudDatastore(homeDir) {
     upsertOperation: async (row) => {
       await safe(() => {
         const ts = nowIso();
+        const terminalStatuses = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
         db.prepare(
-          `INSERT INTO operations(operation_id, type, object_id, quote_id, status, error_code, error_message, started_at, finished_at, created_at, updated_at)
-           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `INSERT INTO operations(operation_id, type, object_id, quote_id, trace_id, orchestrator, subagent_session_id, timeout_seconds, cancel_requested_at, status, error_code, error_message, started_at, finished_at, created_at, updated_at)
+           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT(operation_id) DO UPDATE SET
              type=excluded.type,
              object_id=COALESCE(excluded.object_id, operations.object_id),
-             quote_id=excluded.quote_id,
+             quote_id=COALESCE(excluded.quote_id, operations.quote_id),
+             trace_id=COALESCE(excluded.trace_id, operations.trace_id),
+             orchestrator=COALESCE(excluded.orchestrator, operations.orchestrator),
+             subagent_session_id=COALESCE(excluded.subagent_session_id, operations.subagent_session_id),
+             timeout_seconds=COALESCE(excluded.timeout_seconds, operations.timeout_seconds),
+             cancel_requested_at=COALESCE(excluded.cancel_requested_at, operations.cancel_requested_at),
              status=excluded.status,
              error_code=excluded.error_code,
              error_message=excluded.error_message,
@@ -3066,11 +3090,16 @@ async function createCloudDatastore(homeDir) {
           row.type,
           row.object_id,
           row.quote_id,
+          row.trace_id ?? null,
+          row.orchestrator ?? null,
+          row.subagent_session_id ?? null,
+          row.timeout_seconds ?? null,
+          row.cancel_requested_at ?? null,
           row.status,
           row.error_code,
           row.error_message,
           row.status === "started" ? ts : null,
-          row.status === "succeeded" || row.status === "failed" ? ts : null,
+          terminalStatuses.has(row.status) ? ts : null,
           ts,
           ts
         );
@@ -3078,7 +3107,7 @@ async function createCloudDatastore(homeDir) {
     },
     findOperationById: async (operationId) => safe(() => {
       const row = db.prepare(
-        `SELECT operation_id, type, status, error_code, error_message, started_at, finished_at, updated_at
+        `SELECT operation_id, type, object_id, quote_id, trace_id, orchestrator, subagent_session_id, timeout_seconds, cancel_requested_at, status, error_code, error_message, started_at, finished_at, updated_at
              FROM operations
              WHERE operation_id = ?
              LIMIT 1`
@@ -3180,7 +3209,9 @@ var REQUIRED_UPLOAD = "--quote-id, --wallet-address, --object-id, --object-id-ha
 var REQUIRED_STORAGE_OBJECT = "--wallet-address and one of (--object-key | --name [--latest|--at])";
 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 ORCHESTRATOR_MODES = /* @__PURE__ */ new Set(["inline", "subagent"]);
 function expandTilde(path) {
   const trimmed = path.trim();
   if (trimmed === "~") {
@@ -3194,29 +3225,54 @@ function expandTilde(path) {
 var CLOUD_HELP_TEXT = [
   "\u2601\uFE0F **mnemospark Cloud Commands**",
   "",
-  "\u2022 `/mnemospark-cloud` or `/mnemospark-cloud help` \u2014 show this message",
+  "\u2022 `/mnemospark_cloud` or `/mnemospark_cloud help` \u2014 show this message",
   "",
-  "\u2022 `/mnemospark-cloud backup <file>` or `/mnemospark-cloud backup <directory> [--name <friendly-name>]`",
-  "  Required: <file> or <directory> (path to back up)",
+  "\u2022 `/mnemospark_cloud backup <file|directory> [--name <friendly-name>] [--async] [--orchestrator <inline|subagent>] [--timeout-seconds <n>]`",
+  "  Purpose: create a local tar+gzip backup object and index it for later upload.",
+  "  Required: <file|directory>",
   "",
-  "\u2022 `/mnemospark-cloud price-storage --wallet-address <addr> --object-id <id> --object-id-hash <hash> --gb <gb> --provider <provider> --region <region>`",
+  "\u2022 `/mnemospark_cloud price-storage --wallet-address <addr> --object-id <id> --object-id-hash <hash> --gb <gb> --provider <provider> --region <region>`",
+  "  Purpose: request a storage quote before upload.",
   "  Required: " + REQUIRED_PRICE_STORAGE,
   "",
-  "\u2022 `/mnemospark-cloud upload --quote-id <quote-id> --wallet-address <addr> --object-id <id> --object-id-hash <hash> [--name <friendly-name>] [--async]`",
+  "\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>]`",
+  "  Purpose: upload an encrypted object using a valid quote-id.",
   "  Required: " + REQUIRED_UPLOAD,
   "",
-  "\u2022 `/mnemospark-cloud ls --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>]`",
+  "\u2022 `/mnemospark_cloud ls --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>]`",
+  "  Purpose: look up remote object metadata.",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
-  "\u2022 `/mnemospark-cloud download --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>] [--async]`",
+  "\u2022 `/mnemospark_cloud download --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>] [--async] [--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|--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>`",
+  "\u2022 `/mnemospark_cloud op-status --operation-id <id> [--cancel]`",
+  "  Purpose: inspect async operation status, or request cancellation for subagent runs.",
   "  Required: --operation-id",
   "",
+  "Async orchestration flags (`backup`, `upload`, `download` only):",
+  "\u2022 `--async`",
+  "  Start operation in background and return quickly with operation-id.",
+  "\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`.",
+  "  `n` must be a positive integer (seconds).",
+  "\u2022 `op-status --cancel`",
+  "  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`",
+  "",
   "Backup creates a tar+gzip object in ~/.openclaw/mnemospark/backup and appends object metadata to ~/.openclaw/mnemospark/object.log. Upload appends storage rows and cron-tracking rows to object.log, and keeps job entries in ~/.openclaw/mnemospark/crontab.txt. All storage commands (price-storage, upload, ls, download, delete) require --wallet-address."
 ].join("\n");
 var UnsupportedBackupPlatformError = class extends Error {
@@ -3306,9 +3362,73 @@ function parseStorageObjectRequestInput(flags, selector) {
     location
   });
 }
-function stripAsyncFlag(args) {
+function parseOrchestratorMode(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (!ORCHESTRATOR_MODES.has(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function parseTimeoutSeconds(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return null;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+}
+function parseAsyncOperationArgs(flags) {
+  const asyncRequested = flags.async === "true";
+  const hasOrchestratorFlag = typeof flags.orchestrator === "string";
+  const hasTimeoutFlag = typeof flags["timeout-seconds"] === "string";
+  if (!asyncRequested && (hasOrchestratorFlag || hasTimeoutFlag)) {
+    return null;
+  }
+  const parsedOrchestrator = parseOrchestratorMode(flags.orchestrator);
+  if (parsedOrchestrator === null) {
+    return null;
+  }
+  const parsedTimeoutSeconds = parseTimeoutSeconds(flags["timeout-seconds"]);
+  if (parsedTimeoutSeconds === null) {
+    return null;
+  }
+  if (typeof parsedTimeoutSeconds === "number" && (parsedOrchestrator ?? "inline") !== "subagent") {
+    return null;
+  }
+  return {
+    async: asyncRequested,
+    orchestrator: parsedOrchestrator === void 0 ? void 0 : parsedOrchestrator,
+    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`.";
+function stripAsyncControlFlags(args) {
   const tokens = tokenizeArgsRaw(args ?? "");
-  const filtered = tokens.filter((token) => token.toLowerCase() !== "--async");
+  const filtered = [];
+  for (let idx = 0; idx < tokens.length; idx += 1) {
+    const token = tokens[idx];
+    const lowerToken = token.toLowerCase();
+    if (lowerToken === "--async") {
+      continue;
+    }
+    if (lowerToken === "--orchestrator" || lowerToken === "--timeout-seconds") {
+      idx += 1;
+      continue;
+    }
+    filtered.push(token);
+  }
   return filtered.join(" ");
 }
 function parseCloudArgs(args) {
@@ -3331,8 +3451,21 @@ function parseCloudArgs(args) {
     if (!backupTarget) {
       return { mode: "unknown" };
     }
-    const flags = parseNamedFlagsTokens(tokens.slice(1));
-    return { mode: "backup", backupTarget, friendlyName: flags?.name?.trim() || void 0 };
+    const remainingTokens = tokens.slice(1);
+    const flags = remainingTokens.length === 0 ? {} : parseNamedFlagsTokens(remainingTokens, BOOLEAN_ASYNC_FLAGS);
+    if (!flags) {
+      return { mode: "backup-invalid" };
+    }
+    const asyncArgs = parseAsyncOperationArgs(flags);
+    if (!asyncArgs) {
+      return { mode: "backup-invalid-async" };
+    }
+    return {
+      mode: "backup",
+      backupTarget,
+      friendlyName: flags.name?.trim() || void 0,
+      ...asyncArgs
+    };
   }
   if (subcommand === "price-storage") {
     const flags = parseNamedFlags(rest);
@@ -3358,6 +3491,10 @@ function parseCloudArgs(args) {
     if (!flags) {
       return { mode: "upload-invalid" };
     }
+    const asyncArgs = parseAsyncOperationArgs(flags);
+    if (!asyncArgs) {
+      return { mode: "upload-invalid-async" };
+    }
     const quoteId = flags["quote-id"]?.trim();
     const walletAddress = flags["wallet-address"]?.trim();
     const objectId = flags["object-id"]?.trim();
@@ -3368,7 +3505,7 @@ function parseCloudArgs(args) {
     return {
       mode: "upload",
       friendlyName: flags.name?.trim() || void 0,
-      async: flags.async === "true",
+      ...asyncArgs,
       uploadRequest: {
         quote_id: quoteId,
         wallet_address: walletAddress,
@@ -3397,6 +3534,10 @@ function parseCloudArgs(args) {
     if (!flags) {
       return { mode: "download-invalid" };
     }
+    const asyncArgs = parseAsyncOperationArgs(flags);
+    if (!asyncArgs) {
+      return { mode: "download-invalid-async" };
+    }
     const selector = parseObjectSelector(flags);
     if (!selector) {
       return { mode: "download-invalid" };
@@ -3409,7 +3550,7 @@ function parseCloudArgs(args) {
       mode: "download",
       storageObjectRequest: request,
       nameSelector: selector.nameSelector,
-      async: flags.async === "true"
+      ...asyncArgs
     };
   }
   if (subcommand === "delete") {
@@ -3428,12 +3569,12 @@ function parseCloudArgs(args) {
     return { mode: "delete", storageObjectRequest: request, nameSelector: selector.nameSelector };
   }
   if (subcommand === "op-status") {
-    const flags = parseNamedFlags(rest);
+    const flags = parseNamedFlags(rest, BOOLEAN_OP_STATUS_FLAGS);
     const operationId = flags?.["operation-id"]?.trim();
     if (!operationId) {
       return { mode: "op-status-invalid" };
     }
-    return { mode: "op-status", operationId };
+    return { mode: "op-status", operationId, cancel: flags?.cancel === "true" };
   }
   return { mode: "unknown" };
 }
@@ -3924,17 +4065,37 @@ async function uploadPresignedObjectIfNeeded(uploadResponse, uploadMode, encrypt
   if (!headers.has("content-type")) {
     headers.set("content-type", "application/octet-stream");
   }
-  const response = await fetchImpl(uploadResponse.upload_url, {
+  const putBody = new Uint8Array(encryptedContent);
+  const firstAttempt = await fetchImpl(uploadResponse.upload_url, {
     method: "PUT",
     headers,
-    body: new Uint8Array(encryptedContent)
+    body: putBody,
+    redirect: "manual"
   });
-  if (!response.ok) {
-    const details = (await response.text()).trim();
-    throw new Error(
-      `Presigned upload failed with status ${response.status}${details ? `: ${details}` : ""}`
-    );
+  if (firstAttempt.ok) {
+    return;
+  }
+  if ((firstAttempt.status === 307 || firstAttempt.status === 308) && firstAttempt.headers.has("location")) {
+    const location = firstAttempt.headers.get("location")?.trim();
+    if (location) {
+      const redirectedAttempt = await fetchImpl(location, {
+        method: "PUT",
+        headers,
+        body: putBody
+      });
+      if (redirectedAttempt.ok) {
+        return;
+      }
+      const redirectedDetails = (await redirectedAttempt.text()).trim();
+      throw new Error(
+        `Presigned upload failed after redirect with status ${redirectedAttempt.status}${redirectedDetails ? `: ${redirectedDetails}` : ""}`
+      );
+    }
   }
+  const details = (await firstAttempt.text()).trim();
+  throw new Error(
+    `Presigned upload failed with status ${firstAttempt.status}${details ? `: ${details}` : ""}`
+  );
 }
 async function appendStorageUploadLog(upload, homeDir, nowDateFn = () => /* @__PURE__ */ new Date()) {
   return appendObjectLogLine(
@@ -4005,16 +4166,118 @@ function extractUploadErrorMessage(error) {
 function formatPriceStorageUserMessage(quote) {
   return [
     `Your storage quote \`${quote.quote_id}\` is valid for 1 hour, the storage price is \`${quote.storage_price}\` for \`${quote.object_id}\` with file size of \`${quote.object_size_gb}\` in \`${quote.provider}\` \`${quote.location}\``,
-    `If you accept this quote run the command /mnemospark-cloud upload --quote-id \`${quote.quote_id}\` --wallet-address \`${quote.addr}\` --object-id \`${quote.object_id}\` --object-id-hash \`${quote.object_id_hash}\``
+    `If you accept this quote run the command /mnemospark_cloud upload --quote-id \`${quote.quote_id}\` --wallet-address \`${quote.addr}\` --object-id \`${quote.object_id}\` --object-id-hash \`${quote.object_id_hash}\``
   ].join("\n");
 }
 function formatStorageLsUserMessage(result, requestedObjectKey) {
   const objectId = result.object_id ?? result.key;
   return `${objectId} with ${requestedObjectKey} is ${result.size_bytes} in ${result.bucket}`;
 }
+function createInProcessSubagentOrchestrator() {
+  const sessions = /* @__PURE__ */ new Map();
+  const completeSession = async (sessionId, handler) => {
+    const session = sessions.get(sessionId);
+    if (!session || session.terminal) {
+      return false;
+    }
+    session.terminal = true;
+    if (session.timeoutHandle) {
+      clearTimeout(session.timeoutHandle);
+    }
+    sessions.delete(sessionId);
+    await handler(session.hooks);
+    return true;
+  };
+  return {
+    dispatch: async (input) => {
+      const sessionId = `agent:mnemospark:subagent:${randomUUID3()}`;
+      const state = {
+        terminal: false,
+        cancelRequested: false,
+        hooks: input.hooks
+      };
+      sessions.set(sessionId, state);
+      if (typeof input.timeoutSeconds === "number" && input.timeoutSeconds > 0) {
+        state.timeoutHandle = setTimeout(() => {
+          void completeSession(sessionId, async (hooks) => {
+            await hooks?.onTimedOut?.(sessionId);
+          });
+        }, input.timeoutSeconds * 1e3);
+      }
+      setTimeout(() => {
+        void (async () => {
+          try {
+            await input.hooks?.onRunning?.(sessionId);
+            await input.hooks?.onProgress?.(sessionId, "subagent execution started");
+            const result = await input.runTask();
+            const session = sessions.get(sessionId);
+            if (!session || session.terminal) {
+              return;
+            }
+            if (session.cancelRequested) {
+              await completeSession(sessionId, async (hooks) => {
+                await hooks?.onCancelled?.(sessionId, "cancel requested");
+              });
+              return;
+            }
+            if (result.isError) {
+              await completeSession(sessionId, async (hooks) => {
+                await hooks?.onFailed?.(sessionId, {
+                  code: "ASYNC_FAILED",
+                  message: result.text
+                });
+              });
+              return;
+            }
+            await completeSession(sessionId, async (hooks) => {
+              await hooks?.onCompleted?.(sessionId, result);
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const session = sessions.get(sessionId);
+            if (!session || session.terminal) {
+              return;
+            }
+            if (session.cancelRequested) {
+              await completeSession(sessionId, async (hooks) => {
+                await hooks?.onCancelled?.(sessionId, "cancel requested");
+              });
+              return;
+            }
+            await completeSession(sessionId, async (hooks) => {
+              await hooks?.onFailed?.(sessionId, {
+                code: "ASYNC_EXCEPTION",
+                message
+              });
+            });
+          }
+        })();
+      }, 0);
+      return { sessionId };
+    },
+    cancel: async (sessionId, reason) => {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        return { accepted: false };
+      }
+      if (session.terminal) {
+        return { accepted: false, alreadyTerminal: true };
+      }
+      session.cancelRequested = true;
+      await completeSession(sessionId, async (hooks) => {
+        await hooks?.onCancelled?.(sessionId, reason ?? "cancel requested");
+      });
+      return { accepted: true };
+    }
+  };
+}
 function createCloudCommand(options = {}) {
+  const subagentOrchestrator = options.subagentOrchestrator ?? createInProcessSubagentOrchestrator();
   return {
-    name: "mnemospark-cloud",
+    name: "mnemospark_cloud",
+    nativeNames: {
+      default: "mnemospark_cloud"
+    },
     description: "Manage mnemospark cloud storage workflow commands",
     acceptsArgs: true,
     requireAuth: true,
@@ -4038,6 +4301,7 @@ function createCloudCommand(options = {}) {
           proxyQuoteOptions: options.proxyQuoteOptions,
           proxyUploadOptions: options.proxyUploadOptions,
           proxyUploadConfirmOptions: options.proxyUploadConfirmOptions,
+          subagentOrchestrator,
           proxyStorageOptions: options.proxyStorageOptions
         });
       } catch (outerError) {
@@ -4047,7 +4311,42 @@ function createCloudCommand(options = {}) {
     }
   };
 }
-async function resolveNameSelectorIfNeeded(datastore, request, selector) {
+async function resolveFriendlyNameFromManifest(params, homeDir) {
+  const manifestPath = join8(homeDir ?? homedir6(), ".openclaw", "mnemospark", "manifest.jsonl");
+  let manifestRaw;
+  try {
+    manifestRaw = await readFile3(manifestPath, "utf-8");
+  } catch {
+    return { objectKey: null, matchCount: 0 };
+  }
+  const wallet = params.walletAddress.trim();
+  const name = params.friendlyName.trim();
+  const atMs = params.at ? Date.parse(params.at) : Number.NaN;
+  const hasAt = Number.isFinite(atMs);
+  const rows = manifestRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((row) => Boolean(row)).filter((row) => {
+    if (!row.object_key || !row.friendly_name || !row.wallet_address || !row.created_at)
+      return false;
+    if (row.friendly_name !== name) return false;
+    if (row.wallet_address.trim() !== wallet) return false;
+    if (params.latest || !hasAt) return true;
+    const createdAtMs = Date.parse(row.created_at);
+    return Number.isFinite(createdAtMs) && createdAtMs <= atMs;
+  }).sort((a, b) => Date.parse(b.created_at ?? "") - Date.parse(a.created_at ?? ""));
+  if (rows.length === 0) {
+    return { objectKey: null, matchCount: 0 };
+  }
+  if (!params.latest && !hasAt && rows.length > 1) {
+    return { objectKey: null, matchCount: rows.length };
+  }
+  return { objectKey: rows[0].object_key ?? null, matchCount: rows.length };
+}
+async function resolveNameSelectorIfNeeded(datastore, request, selector, homeDir) {
   if (!selector) {
     const parsedRequest2 = parseStorageObjectRequest(request);
     if (!parsedRequest2) {
@@ -4055,6 +4354,12 @@ async function resolveNameSelectorIfNeeded(datastore, request, selector) {
     }
     return { request: parsedRequest2 };
   }
+  let sqliteUnavailable = false;
+  try {
+    await datastore.ensureReady();
+  } catch {
+    sqliteUnavailable = true;
+  }
   const matches = await datastore.countFriendlyNameMatches(request.wallet_address, selector.name);
   if (matches > 1 && !selector.latest && !selector.at) {
     return {
@@ -4067,18 +4372,41 @@ async function resolveNameSelectorIfNeeded(datastore, request, selector) {
     latest: selector.latest,
     at: selector.at
   });
-  if (!resolved || !resolved.objectKey) {
+  let resolvedObjectKey = resolved?.objectKey ?? null;
+  let degradedWarning;
+  if (!resolvedObjectKey && sqliteUnavailable) {
+    const manifestResolved = await resolveFriendlyNameFromManifest(
+      {
+        walletAddress: request.wallet_address,
+        friendlyName: selector.name,
+        latest: selector.latest,
+        at: selector.at
+      },
+      homeDir
+    );
+    if (manifestResolved.matchCount > 1 && !selector.latest && !selector.at) {
+      return {
+        error: `Multiple objects match --name ${selector.name}. Add --latest or --at <timestamp>.`
+      };
+    }
+    resolvedObjectKey = manifestResolved.objectKey;
+    if (resolvedObjectKey) {
+      degradedWarning = "SQLite friendly-name index unavailable; resolved --name via manifest.jsonl fallback.";
+    }
+  }
+  if (!resolvedObjectKey) {
     return { error: `No object found for --name ${selector.name}.` };
   }
   const parsedRequest = parseStorageObjectRequest({
     ...request,
-    object_key: resolved.objectKey
+    object_key: resolvedObjectKey
   });
   if (!parsedRequest) {
     return { error: "Cannot resolve storage object request." };
   }
   return {
-    request: parsedRequest
+    request: parsedRequest,
+    degradedWarning
   };
 }
 async function emitCloudEvent(eventType, details, homeDir) {
@@ -4098,6 +4426,38 @@ async function emitCloudEventBestEffort(eventType, details, homeDir) {
   } catch {
   }
 }
+function toOperationEventPayload(eventType, context) {
+  return {
+    operation_id: context.operationId,
+    trace_id: context.traceId,
+    event_type: eventType,
+    status: context.status,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    wallet_address: context.walletAddress ?? void 0,
+    object_id: context.objectId ?? void 0,
+    object_key: context.objectKey ?? void 0,
+    quote_id: context.quoteId ?? void 0,
+    orchestrator: context.orchestrator ?? void 0,
+    "subagent-session-id": context.subagentSessionId ?? void 0,
+    "timeout-seconds": context.timeoutSeconds ?? void 0,
+    "error-code": context.errorCode ?? void 0,
+    "error-message": context.errorMessage ?? void 0,
+    progress: context.progressMessage ?? void 0
+  };
+}
+async function emitOperationEvent(eventType, context, homeDir) {
+  const payload = toOperationEventPayload(eventType, context);
+  await Promise.all([
+    appendJsonlEvent("events.jsonl", payload, homeDir),
+    appendJsonlEvent("proxy-events.jsonl", payload, homeDir)
+  ]);
+}
+async function emitOperationEventBestEffort(eventType, context, homeDir) {
+  try {
+    await emitOperationEvent(eventType, context, homeDir);
+  } catch {
+  }
+}
 function buildRequestCorrelation(forcedOperationId, forcedTraceId) {
   const operationId = forcedOperationId?.trim() || randomUUID3();
   const traceId = forcedTraceId?.trim() || randomUUID3();
@@ -4118,6 +4478,7 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
   const requestStorageLs = options.requestStorageLsFn;
   const requestStorageDownload = options.requestStorageDownloadFn;
   const requestStorageDelete = options.requestStorageDeleteFn;
+  const subagentOrchestrator = options.subagentOrchestrator;
   if (parsed.mode === "help" || parsed.mode === "unknown") {
     return {
       text: CLOUD_HELP_TEXT,
@@ -4130,12 +4491,30 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
       isError: true
     };
   }
+  if (parsed.mode === "backup-invalid") {
+    return {
+      text: "Cannot build storage object",
+      isError: true
+    };
+  }
+  if (parsed.mode === "backup-invalid-async") {
+    return {
+      text: `Cannot build storage object: ${INVALID_ASYNC_FLAGS_MESSAGE}`,
+      isError: true
+    };
+  }
   if (parsed.mode === "upload-invalid") {
     return {
       text: `Cannot upload storage object: required arguments are ${REQUIRED_UPLOAD}.`,
       isError: true
     };
   }
+  if (parsed.mode === "upload-invalid-async") {
+    return {
+      text: `Cannot upload storage object: ${INVALID_ASYNC_FLAGS_MESSAGE}`,
+      isError: true
+    };
+  }
   if (parsed.mode === "ls-invalid") {
     return {
       text: `Cannot list storage object: required arguments are ${REQUIRED_STORAGE_OBJECT}.`,
@@ -4148,6 +4527,12 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
       isError: true
     };
   }
+  if (parsed.mode === "download-invalid-async") {
+    return {
+      text: `Cannot download file: ${INVALID_ASYNC_FLAGS_MESSAGE}`,
+      isError: true
+    };
+  }
   if (parsed.mode === "delete-invalid") {
     return {
       text: `Cannot delete file: required arguments are ${REQUIRED_STORAGE_OBJECT}.`,
@@ -4161,70 +4546,450 @@ async function runCloudCommandHandler(ctx, options, executionContext = {}) {
     };
   }
   const datastore = await createCloudDatastore(objectLogHomeDir);
+  const terminalOperationStatuses = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
+  const isTerminalOperationStatus = (status) => terminalOperationStatuses.has(status);
+  const formatOperationStatus = (operation) => ({
+    text: [
+      `operation-id: ${operation.operation_id}`,
+      `type: ${operation.type}`,
+      `status: ${operation.status}`,
+      `started-at: ${operation.started_at ?? "n/a"}`,
+      `finished-at: ${operation.finished_at ?? "n/a"}`,
+      operation.orchestrator ? `orchestrator: ${operation.orchestrator}` : null,
+      operation.subagent_session_id ? `subagent-session-id: ${operation.subagent_session_id}` : null,
+      operation.timeout_seconds ? `timeout-seconds: ${operation.timeout_seconds}` : null,
+      operation.error_code ? `error-code: ${operation.error_code}` : null,
+      operation.error_message ? `error-message: ${operation.error_message}` : null
+    ].filter((v) => Boolean(v)).join("\n"),
+    isError: operation.status === "failed" || operation.status === "cancelled" || operation.status === "timed_out"
+  });
   if (parsed.mode === "op-status") {
-    const operation = await datastore.findOperationById(parsed.operationId);
+    let operation = await datastore.findOperationById(parsed.operationId);
     if (!operation) {
       return {
         text: `Operation not found: ${parsed.operationId}`,
         isError: true
       };
     }
-    return {
-      text: [
-        `operation-id: ${operation.operation_id}`,
-        `type: ${operation.type}`,
-        `status: ${operation.status}`,
-        `started-at: ${operation.started_at ?? "n/a"}`,
-        `finished-at: ${operation.finished_at ?? "n/a"}`,
-        operation.error_code ? `error-code: ${operation.error_code}` : null,
-        operation.error_message ? `error-message: ${operation.error_message}` : null
-      ].filter((v) => Boolean(v)).join("\n"),
-      isError: operation.status === "failed"
-    };
+    if (parsed.cancel) {
+      if (operation.orchestrator !== "subagent" || !operation.subagent_session_id) {
+        return {
+          text: "Cancellation is only supported for subagent-orchestrated operations.",
+          isError: true
+        };
+      }
+      if (!isTerminalOperationStatus(operation.status)) {
+        const traceId = operation.trace_id ?? randomUUID3();
+        const cancelRequestedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await datastore.upsertOperation({
+          operation_id: operation.operation_id,
+          type: operation.type,
+          object_id: operation.object_id,
+          quote_id: operation.quote_id,
+          trace_id: traceId,
+          orchestrator: "subagent",
+          subagent_session_id: operation.subagent_session_id,
+          timeout_seconds: operation.timeout_seconds,
+          cancel_requested_at: cancelRequestedAt,
+          status: "running",
+          error_code: null,
+          error_message: null
+        });
+        await emitOperationEventBestEffort(
+          "operation.cancel.requested",
+          {
+            operationId: operation.operation_id,
+            traceId,
+            status: "running",
+            objectId: operation.object_id,
+            quoteId: operation.quote_id,
+            orchestrator: "subagent",
+            subagentSessionId: operation.subagent_session_id,
+            timeoutSeconds: operation.timeout_seconds
+          },
+          objectLogHomeDir
+        );
+        const cancelResult = await subagentOrchestrator.cancel(
+          operation.subagent_session_id,
+          "cancel requested by op-status"
+        );
+        if (cancelResult.accepted || cancelResult.alreadyTerminal) {
+          const afterCancel = await datastore.findOperationById(parsed.operationId);
+          if (afterCancel && !isTerminalOperationStatus(afterCancel.status)) {
+            await datastore.upsertOperation({
+              operation_id: operation.operation_id,
+              type: operation.type,
+              object_id: operation.object_id,
+              quote_id: operation.quote_id,
+              trace_id: traceId,
+              orchestrator: "subagent",
+              subagent_session_id: operation.subagent_session_id,
+              timeout_seconds: operation.timeout_seconds,
+              cancel_requested_at: cancelRequestedAt,
+              status: "cancelled",
+              error_code: "ASYNC_CANCELLED",
+              error_message: "Operation cancelled by user request."
+            });
+            await emitOperationEventBestEffort(
+              "operation.cancelled",
+              {
+                operationId: operation.operation_id,
+                traceId,
+                status: "cancelled",
+                objectId: operation.object_id,
+                quoteId: operation.quote_id,
+                orchestrator: "subagent",
+                subagentSessionId: operation.subagent_session_id,
+                timeoutSeconds: operation.timeout_seconds,
+                errorCode: "ASYNC_CANCELLED",
+                errorMessage: "Operation cancelled by user request."
+              },
+              objectLogHomeDir
+            );
+          }
+        }
+      }
+      operation = await datastore.findOperationById(parsed.operationId);
+      if (!operation) {
+        return {
+          text: `Operation not found: ${parsed.operationId}`,
+          isError: true
+        };
+      }
+    }
+    return formatOperationStatus(operation);
   }
-  if ((parsed.mode === "upload" || parsed.mode === "download") && parsed.async) {
+  if ((parsed.mode === "backup" || parsed.mode === "upload" || parsed.mode === "download") && parsed.async) {
     const asyncCorrelation = buildRequestCorrelation();
     const operationId = asyncCorrelation.operationId;
     const opType = parsed.mode;
     const opObject = parsed.mode === "upload" ? parsed.uploadRequest.object_id : null;
     const opQuote = parsed.mode === "upload" ? parsed.uploadRequest.quote_id : null;
+    const orchestratorMode = parsed.orchestrator ?? "inline";
+    const timeoutSeconds = orchestratorMode === "subagent" ? parsed.timeoutSeconds ?? null : null;
+    const eventContextBase = {
+      operationId,
+      traceId: asyncCorrelation.traceId,
+      walletAddress: parsed.mode === "upload" ? parsed.uploadRequest.wallet_address : parsed.mode === "download" ? parsed.storageObjectRequest.wallet_address : null,
+      objectId: opObject,
+      objectKey: parsed.mode === "download" ? parsed.storageObjectRequest.object_key ?? null : null,
+      quoteId: opQuote,
+      orchestrator: orchestratorMode,
+      timeoutSeconds
+    };
     await datastore.upsertOperation({
       operation_id: operationId,
       type: opType,
       object_id: opObject,
       quote_id: opQuote,
+      trace_id: asyncCorrelation.traceId,
+      orchestrator: orchestratorMode,
+      timeout_seconds: timeoutSeconds,
       status: "started",
       error_code: null,
       error_message: null
     });
-    const syncArgs = stripAsyncFlag(ctx.args);
-    void runCloudCommandHandler({ args: syncArgs }, options, {
-      forcedOperationId: asyncCorrelation.operationId,
-      forcedTraceId: asyncCorrelation.traceId
-    }).then(async (result) => {
+    await emitOperationEventBestEffort(
+      "operation.dispatched",
+      { ...eventContextBase, status: "started" },
+      objectLogHomeDir
+    );
+    const syncArgs = stripAsyncControlFlags(ctx.args);
+    if (orchestratorMode === "subagent") {
+      const subagentTask = {
+        schema: "mnemospark.subagent-task.v1",
+        operationId,
+        traceId: asyncCorrelation.traceId,
+        command: parsed.mode,
+        args: syncArgs,
+        timeoutSeconds: parsed.timeoutSeconds,
+        requestedBy: {
+          pluginCommand: "mnemospark_cloud",
+          chatId: ctx.channel,
+          senderId: ctx.senderId
+        }
+      };
+      try {
+        const dispatchResult = await subagentOrchestrator.dispatch({
+          task: subagentTask,
+          timeoutSeconds: parsed.timeoutSeconds,
+          runTask: async () => runCloudCommandHandler(
+            { args: syncArgs, channel: ctx.channel, senderId: ctx.senderId },
+            options,
+            {
+              forcedOperationId: asyncCorrelation.operationId,
+              forcedTraceId: asyncCorrelation.traceId
+            }
+          ),
+          hooks: {
+            onRunning: async (sessionId) => {
+              await datastore.upsertOperation({
+                operation_id: operationId,
+                type: opType,
+                object_id: opObject,
+                quote_id: opQuote,
+                trace_id: asyncCorrelation.traceId,
+                orchestrator: "subagent",
+                subagent_session_id: sessionId,
+                timeout_seconds: timeoutSeconds,
+                status: "running",
+                error_code: null,
+                error_message: null
+              });
+              await emitOperationEventBestEffort(
+                "operation.progress",
+                {
+                  ...eventContextBase,
+                  status: "running",
+                  subagentSessionId: sessionId,
+                  progressMessage: "subagent running"
+                },
+                objectLogHomeDir
+              );
+            },
+            onProgress: async (sessionId, message) => {
+              await emitOperationEventBestEffort(
+                "operation.progress",
+                {
+                  ...eventContextBase,
+                  status: "running",
+                  subagentSessionId: sessionId,
+                  progressMessage: message
+                },
+                objectLogHomeDir
+              );
+            },
+            onCompleted: async (sessionId) => {
+              await datastore.upsertOperation({
+                operation_id: operationId,
+                type: opType,
+                object_id: opObject,
+                quote_id: opQuote,
+                trace_id: asyncCorrelation.traceId,
+                orchestrator: "subagent",
+                subagent_session_id: sessionId,
+                timeout_seconds: timeoutSeconds,
+                status: "succeeded",
+                error_code: null,
+                error_message: null
+              });
+              await emitOperationEventBestEffort(
+                "operation.completed",
+                {
+                  ...eventContextBase,
+                  status: "succeeded",
+                  subagentSessionId: sessionId
+                },
+                objectLogHomeDir
+              );
+            },
+            onFailed: async (sessionId, details) => {
+              await datastore.upsertOperation({
+                operation_id: operationId,
+                type: opType,
+                object_id: opObject,
+                quote_id: opQuote,
+                trace_id: asyncCorrelation.traceId,
+                orchestrator: "subagent",
+                subagent_session_id: sessionId,
+                timeout_seconds: timeoutSeconds,
+                status: "failed",
+                error_code: details.code,
+                error_message: details.message
+              });
+              await emitOperationEventBestEffort(
+                "operation.completed",
+                {
+                  ...eventContextBase,
+                  status: "failed",
+                  subagentSessionId: sessionId,
+                  errorCode: details.code,
+                  errorMessage: details.message
+                },
+                objectLogHomeDir
+              );
+            },
+            onCancelled: async (sessionId, reason) => {
+              await datastore.upsertOperation({
+                operation_id: operationId,
+                type: opType,
+                object_id: opObject,
+                quote_id: opQuote,
+                trace_id: asyncCorrelation.traceId,
+                orchestrator: "subagent",
+                subagent_session_id: sessionId,
+                timeout_seconds: timeoutSeconds,
+                cancel_requested_at: (/* @__PURE__ */ new Date()).toISOString(),
+                status: "cancelled",
+                error_code: "ASYNC_CANCELLED",
+                error_message: reason ?? "Operation cancelled."
+              });
+              await emitOperationEventBestEffort(
+                "operation.cancelled",
+                {
+                  ...eventContextBase,
+                  status: "cancelled",
+                  subagentSessionId: sessionId,
+                  errorCode: "ASYNC_CANCELLED",
+                  errorMessage: reason ?? "Operation cancelled."
+                },
+                objectLogHomeDir
+              );
+            },
+            onTimedOut: async (sessionId) => {
+              await datastore.upsertOperation({
+                operation_id: operationId,
+                type: opType,
+                object_id: opObject,
+                quote_id: opQuote,
+                trace_id: asyncCorrelation.traceId,
+                orchestrator: "subagent",
+                subagent_session_id: sessionId,
+                timeout_seconds: timeoutSeconds,
+                status: "timed_out",
+                error_code: "ASYNC_TIMEOUT",
+                error_message: "Operation timed out."
+              });
+              await emitOperationEventBestEffort(
+                "operation.timed_out",
+                {
+                  ...eventContextBase,
+                  status: "timed_out",
+                  subagentSessionId: sessionId,
+                  errorCode: "ASYNC_TIMEOUT",
+                  errorMessage: "Operation timed out."
+                },
+                objectLogHomeDir
+              );
+            }
+          }
+        });
+        const operationAfterDispatch = await datastore.findOperationById(operationId);
+        if (operationAfterDispatch?.subagent_session_id !== dispatchResult.sessionId) {
+          await datastore.upsertOperation({
+            operation_id: operationId,
+            type: opType,
+            object_id: opObject,
+            quote_id: opQuote,
+            trace_id: asyncCorrelation.traceId,
+            orchestrator: "subagent",
+            subagent_session_id: dispatchResult.sessionId,
+            timeout_seconds: timeoutSeconds,
+            status: operationAfterDispatch?.status ?? "started",
+            error_code: operationAfterDispatch?.error_code ?? null,
+            error_message: operationAfterDispatch?.error_message ?? null
+          });
+        }
+        return {
+          text: [
+            `Operation started in background. operation-id: ${operationId}`,
+            `orchestrator: subagent`,
+            `subagent-session-id: ${dispatchResult.sessionId}`,
+            timeoutSeconds ? `timeout-seconds: ${timeoutSeconds}` : null,
+            `Use /mnemospark_cloud op-status --operation-id ${operationId}`
+          ].filter((line) => Boolean(line)).join("\n")
+        };
+      } catch (dispatchError) {
+        const dispatchMessage = dispatchError instanceof Error ? dispatchError.message : String(dispatchError);
+        await datastore.upsertOperation({
+          operation_id: operationId,
+          type: opType,
+          object_id: opObject,
+          quote_id: opQuote,
+          trace_id: asyncCorrelation.traceId,
+          orchestrator: "subagent",
+          timeout_seconds: timeoutSeconds,
+          status: "failed",
+          error_code: "ASYNC_DISPATCH_FAILED",
+          error_message: dispatchMessage
+        });
+        await emitOperationEventBestEffort(
+          "operation.completed",
+          {
+            ...eventContextBase,
+            status: "failed",
+            errorCode: "ASYNC_DISPATCH_FAILED",
+            errorMessage: dispatchMessage
+          },
+          objectLogHomeDir
+        );
+        return {
+          text: `Cannot dispatch subagent operation: ${dispatchMessage}
+operation-id: ${operationId}`,
+          isError: true
+        };
+      }
+    }
+    await datastore.upsertOperation({
+      operation_id: operationId,
+      type: opType,
+      object_id: opObject,
+      quote_id: opQuote,
+      trace_id: asyncCorrelation.traceId,
+      orchestrator: "inline",
+      status: "running",
+      error_code: null,
+      error_message: null
+    });
+    void runCloudCommandHandler(
+      { args: syncArgs, channel: ctx.channel, senderId: ctx.senderId },
+      options,
+      {
+        forcedOperationId: asyncCorrelation.operationId,
+        forcedTraceId: asyncCorrelation.traceId
+      }
+    ).then(async (result) => {
       await datastore.upsertOperation({
         operation_id: operationId,
         type: opType,
         object_id: opObject,
         quote_id: opQuote,
+        trace_id: asyncCorrelation.traceId,
+        orchestrator: "inline",
         status: result.isError ? "failed" : "succeeded",
         error_code: result.isError ? "ASYNC_FAILED" : null,
         error_message: result.isError ? result.text : null
       });
+      await emitOperationEventBestEffort(
+        "operation.completed",
+        {
+          ...eventContextBase,
+          status: result.isError ? "failed" : "succeeded",
+          errorCode: result.isError ? "ASYNC_FAILED" : null,
+          errorMessage: result.isError ? result.text : null
+        },
+        objectLogHomeDir
+      );
     }).catch(async (err) => {
+      const errorMessage = err instanceof Error ? err.message : String(err);
       await datastore.upsertOperation({
         operation_id: operationId,
         type: opType,
         object_id: opObject,
         quote_id: opQuote,
+        trace_id: asyncCorrelation.traceId,
+        orchestrator: "inline",
         status: "failed",
         error_code: "ASYNC_EXCEPTION",
-        error_message: err instanceof Error ? err.message : String(err)
+        error_message: errorMessage
       });
+      await emitOperationEventBestEffort(
+        "operation.completed",
+        {
+          ...eventContextBase,
+          status: "failed",
+          errorCode: "ASYNC_EXCEPTION",
+          errorMessage
+        },
+        objectLogHomeDir
+      );
     });
     return {
-      text: `Operation started in background. operation-id: ${operationId}
-Use /mnemospark-cloud op-status --operation-id ${operationId}`
+      text: [
+        `Operation started in background. operation-id: ${operationId}`,
+        `orchestrator: inline`,
+        `Use /mnemospark_cloud op-status --operation-id ${operationId}`
+      ].join("\n")
     };
   }
   if (parsed.mode === "backup") {
@@ -4351,7 +5116,7 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
       const loggedQuote = await datastore.findQuoteById(parsed.uploadRequest.quote_id) ?? await findLoggedPriceStorageQuote(parsed.uploadRequest.quote_id, objectLogHomeDir);
       if (!loggedQuote) {
         return {
-          text: "Cannot upload storage object: quote-id not found in object.log. Run /mnemospark-cloud price-storage first.",
+          text: "Cannot upload storage object: quote-id not found in object.log. Run /mnemospark_cloud price-storage first.",
           isError: true
         };
       }
@@ -4370,7 +5135,7 @@ Use /mnemospark-cloud op-status --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
         };
       }
@@ -4503,18 +5268,50 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
         status: "active"
       });
       if (parsed.friendlyName?.trim()) {
+        const normalizedFriendlyName = parsed.friendlyName.trim();
         await datastore.upsertFriendlyName({
-          friendly_name: parsed.friendlyName.trim(),
+          friendly_name: normalizedFriendlyName,
           object_id: finalizedUploadResponse.object_id,
           object_key: finalizedUploadResponse.object_key,
           quote_id: finalizedUploadResponse.quote_id,
           wallet_address: finalizedUploadResponse.addr
         });
+        let friendlyNameVerified = false;
+        try {
+          const readBack = await datastore.resolveFriendlyName({
+            walletAddress: finalizedUploadResponse.addr,
+            friendlyName: normalizedFriendlyName,
+            latest: true
+          });
+          friendlyNameVerified = Boolean(readBack?.objectKey) && readBack?.objectKey === finalizedUploadResponse.object_key;
+        } catch {
+          friendlyNameVerified = false;
+        }
+        if (!friendlyNameVerified) {
+          const warning = "SQLite friendly-name write verification failed; manifest fallback may be required for --name lookups.";
+          await emitCloudEventBestEffort(
+            "friendly_name.write_verification_failed",
+            {
+              operation_id: uploadCorrelation.operationId,
+              trace_id: uploadCorrelation.traceId,
+              wallet_address: finalizedUploadResponse.addr,
+              object_id: finalizedUploadResponse.object_id,
+              object_key: finalizedUploadResponse.object_key,
+              quote_id: finalizedUploadResponse.quote_id,
+              friendly_name: normalizedFriendlyName,
+              warning
+            },
+            objectLogHomeDir
+          );
+          if (process.env.MNEMOSPARK_SQLITE_STRICT === "1") {
+            throw new Error(warning);
+          }
+        }
         try {
           await appendJsonlEvent(
             "manifest.jsonl",
             {
-              friendly_name: parsed.friendlyName.trim(),
+              friendly_name: normalizedFriendlyName,
               object_id: finalizedUploadResponse.object_id,
               object_key: finalizedUploadResponse.object_key,
               quote_id: finalizedUploadResponse.quote_id,
@@ -4567,12 +5364,24 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
     const resolved = await resolveNameSelectorIfNeeded(
       datastore,
       parsed.storageObjectRequest,
-      parsed.nameSelector
+      parsed.nameSelector,
+      objectLogHomeDir
     );
     if (resolved.error || !resolved.request) {
       return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
     }
     const resolvedRequest = resolved.request;
+    if (resolved.degradedWarning) {
+      await emitCloudEventBestEffort(
+        "name_resolution.degraded",
+        {
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          warning: resolved.degradedWarning
+        },
+        objectLogHomeDir
+      );
+    }
     const correlation = buildRequestCorrelation();
     const operationId = correlation.operationId;
     const knownObject = await datastore.findObjectByObjectKey(resolvedRequest.object_key);
@@ -4614,8 +5423,10 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
         },
         objectLogHomeDir
       );
+      const lsText = formatStorageLsUserMessage(lsResult, resolvedRequest.object_key);
       return {
-        text: formatStorageLsUserMessage(lsResult, resolvedRequest.object_key)
+        text: resolved.degradedWarning ? `${resolved.degradedWarning}
+${lsText}` : lsText
       };
     } catch {
       await datastore.upsertOperation({
@@ -4648,12 +5459,24 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
     const resolved = await resolveNameSelectorIfNeeded(
       datastore,
       parsed.storageObjectRequest,
-      parsed.nameSelector
+      parsed.nameSelector,
+      objectLogHomeDir
     );
     if (resolved.error || !resolved.request) {
       return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
     }
     const resolvedRequest = resolved.request;
+    if (resolved.degradedWarning) {
+      await emitCloudEventBestEffort(
+        "name_resolution.degraded",
+        {
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          warning: resolved.degradedWarning
+        },
+        objectLogHomeDir
+      );
+    }
     const correlation = buildRequestCorrelation(
       executionContext.forcedOperationId,
       executionContext.forcedTraceId
@@ -4698,8 +5521,10 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
         },
         objectLogHomeDir
       );
+      const downloadText = `File ${resolvedRequest.object_key} downloaded to ${downloadResult.file_path}`;
       return {
-        text: `File ${resolvedRequest.object_key} downloaded to ${downloadResult.file_path}`
+        text: resolved.degradedWarning ? `${resolved.degradedWarning}
+${downloadText}` : downloadText
       };
     } catch {
       await datastore.upsertOperation({
@@ -4732,12 +5557,24 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
     const resolved = await resolveNameSelectorIfNeeded(
       datastore,
       parsed.storageObjectRequest,
-      parsed.nameSelector
+      parsed.nameSelector,
+      objectLogHomeDir
     );
     if (resolved.error || !resolved.request) {
       return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
     }
     const resolvedRequest = resolved.request;
+    if (resolved.degradedWarning) {
+      await emitCloudEventBestEffort(
+        "name_resolution.degraded",
+        {
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          warning: resolved.degradedWarning
+        },
+        objectLogHomeDir
+      );
+    }
     const correlation = buildRequestCorrelation();
     const operationId = correlation.operationId;
     const existingObjectByKey = await datastore.findObjectByObjectKey(resolvedRequest.object_key);
@@ -4819,12 +5656,14 @@ Use /mnemospark-cloud op-status --operation-id ${operationId}`
       },
       objectLogHomeDir
     );
+    const deleteText = formatStorageDeleteUserMessage(
+      resolvedRequest.object_key,
+      cronEntry?.cronId ?? null,
+      cronDeleted
+    );
     return {
-      text: formatStorageDeleteUserMessage(
-        resolvedRequest.object_key,
-        cronEntry?.cronId ?? null,
-        cronDeleted
-      )
+      text: resolved.degradedWarning ? `${resolved.degradedWarning}
+${deleteText}` : deleteText
     };
   }
   return {
@@ -4942,7 +5781,10 @@ async function startProxyInBackground(api) {
 }
 async function createWalletCommand() {
   return {
-    name: "mnemospark-wallet",
+    name: "mnemospark_wallet",
+    nativeNames: {
+      default: "mnemospark_wallet"
+    },
     description: "Show mnemospark wallet info or export private key for backup",
     acceptsArgs: true,
     requireAuth: true,
@@ -5006,8 +5848,8 @@ async function createWalletCommand() {
           `**Key File:** \`${WALLET_FILE}\``,
           "",
           "**Commands:**",
-          "\u2022 `/mnemospark-wallet` - Show this status",
-          "\u2022 `/mnemospark-wallet export` - Export private key for backup",
+          "\u2022 `/mnemospark_wallet` - Show this status",
+          "\u2022 `/mnemospark_wallet export` - Export private key for backup",
           "",
           `**Fund with USDC on Base:** https://basescan.org/address/${address}`
         ].join("\n")
@@ -5033,14 +5875,14 @@ var plugin = {
       api.registerCommand(walletCommand);
     }).catch((err) => {
       api.logger.warn(
-        `Failed to register /mnemospark-wallet command: ${err instanceof Error ? err.message : String(err)}`
+        `Failed to register /mnemospark_wallet command: ${err instanceof Error ? err.message : String(err)}`
       );
     });
     try {
       api.registerCommand(createCloudCommand());
     } catch (err) {
       api.logger.warn(
-        `Failed to register /mnemospark-cloud command: ${err instanceof Error ? err.message : String(err)}`
+        `Failed to register /mnemospark_cloud command: ${err instanceof Error ? err.message : String(err)}`
       );
     }
     api.registerService({