mnemospark 0.1.20 → 0.1.21

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
 // src/proxy.ts
+import { randomUUID } from "crypto";
 import { createServer } from "http";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 
 // src/balance.ts
@@ -1432,11 +1433,52 @@ async function downloadStorageToDisk(request, backendResponse, options = {}) {
   };
 }
 
+// src/cloud-jsonl.ts
+import { createGzip } from "zlib";
+import { createReadStream, createWriteStream } from "fs";
+import { appendFile, mkdir as mkdir2, readdir, rename, stat, unlink } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, dirname as dirname2, join as join3 } from "path";
+import { pipeline } from "stream/promises";
+var BASE_DIR = join3(homedir2(), ".openclaw", "mnemospark");
+var MAX_BYTES = 10 * 1024 * 1024;
+var KEEP_ROTATED = 10;
+function resolvePath(fileName, homeDir) {
+  const baseDir = homeDir ? join3(homeDir, ".openclaw", "mnemospark") : BASE_DIR;
+  return join3(baseDir, fileName);
+}
+async function rotateIfNeeded(path) {
+  let fileStat;
+  try {
+    fileStat = await stat(path);
+  } catch {
+    return;
+  }
+  if (fileStat.size < MAX_BYTES) return;
+  const rotated = `${path}.${Date.now()}.1`;
+  await rename(path, rotated);
+  const gzPath = `${rotated}.gz`;
+  await pipeline(createReadStream(rotated), createGzip(), createWriteStream(gzPath));
+  await unlink(rotated).catch(() => void 0);
+  const dir = dirname2(path);
+  const base2 = basename(path) || "events.jsonl";
+  const all = (await readdir(dir)).filter((name) => name.startsWith(`${base2}.`) && name.endsWith(".gz")).sort().reverse();
+  const stale = all.slice(KEEP_ROTATED);
+  await Promise.all(stale.map((name) => unlink(join3(dir, name)).catch(() => void 0)));
+}
+async function appendJsonlEvent(fileName, event, homeDir) {
+  const filePath = resolvePath(fileName, homeDir);
+  await mkdir2(dirname2(filePath), { recursive: true });
+  await appendFile(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+  await rotateIfNeeded(filePath);
+}
+
 // src/proxy.ts
 var HEALTH_CHECK_TIMEOUT_MS = 2e3;
 var PORT_RETRY_ATTEMPTS = 5;
 var PORT_RETRY_DELAY_MS = 1e3;
-var DEFAULT_DOWNLOAD_OUTPUT_DIR = join3(homedir2(), ".openclaw", "mnemospark", "downloads");
+var DEFAULT_DOWNLOAD_OUTPUT_DIR = join4(homedir3(), ".openclaw", "mnemospark", "downloads");
 function resolveDownloadOutputDir() {
   const configuredOutputDir = process.env.MNEMOSPARK_DOWNLOAD_DIR?.trim();
   if (configuredOutputDir && configuredOutputDir.length > 0) {
@@ -1490,6 +1532,20 @@ function logProxyEvent(level, event, fields = {}) {
   }
   console.info(message);
 }
+function emitProxyEvent(eventType, status, correlation, details = {}) {
+  void appendJsonlEvent("proxy-events.jsonl", {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event_type: eventType,
+    status,
+    trace_id: correlation.trace_id,
+    operation_id: correlation.operation_id,
+    quote_id: correlation.quote_id ?? null,
+    wallet_address: correlation.wallet_address ?? null,
+    object_id: correlation.object_id ?? null,
+    object_key: correlation.object_key ?? null,
+    details
+  }).catch(() => void 0);
+}
 function isAlreadySettledConflict(status, bodyText) {
   if (status !== 409) {
     return false;
@@ -1614,7 +1670,12 @@ async function startProxy(options) {
       console.error(`[mnemospark] Response stream error: ${err.message}`);
     });
     if (req.method === "POST" && matchesProxyPath(req.url, PRICE_STORAGE_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_price_storage_received");
+      emitProxyEvent("request.received", "start", correlation, { path: PRICE_STORAGE_PROXY_PATH });
       try {
         let payload;
         try {
@@ -1636,6 +1697,9 @@ async function startProxy(options) {
           });
           return;
         }
+        correlation.wallet_address = requestPayload.wallet_address;
+        correlation.object_id = requestPayload.object_id;
+        emitProxyEvent("storage.call", "start", correlation, { target: "price-storage" });
         const walletSignature = await createBackendWalletSignature(
           "POST",
           "/price-storage",
@@ -1654,6 +1718,7 @@ async function startProxy(options) {
         logProxyEvent("info", "proxy_price_storage_backend_response", {
           status: backendResponse.status
         });
+        emitProxyEvent("storage.call", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -1674,7 +1739,13 @@ async function startProxy(options) {
         const responseHeaders = createBackendForwardHeaders(backendResponse);
         res.writeHead(backendResponse.status, responseHeaders);
         res.end(backendResponse.bodyText);
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: backendResponse.status
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_price_storage_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -1686,7 +1757,12 @@ async function startProxy(options) {
       return;
     }
     if (req.method === "POST" && matchesProxyPath(req.url, PAYMENT_SETTLE_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_payment_settle_received");
+      emitProxyEvent("request.received", "start", correlation, { path: PAYMENT_SETTLE_PROXY_PATH });
       try {
         let payload;
         try {
@@ -1750,6 +1826,9 @@ async function startProxy(options) {
           res.end(createWalletRequiredBody());
           return;
         }
+        correlation.quote_id = quoteId;
+        correlation.wallet_address = walletAddress;
+        emitProxyEvent("payment.settle", "start", correlation);
         const paymentFetch = createPaymentFetch(walletPrivateKey).fetch;
         const backendResponse = await forwardPaymentSettleToBackend(quoteId, walletAddress, {
           backendBaseUrl: MNEMOSPARK_BACKEND_API_BASE_URL,
@@ -1763,6 +1842,7 @@ async function startProxy(options) {
         logProxyEvent("info", "proxy_payment_settle_backend_response", {
           status: backendResponse.status
         });
+        emitProxyEvent("payment.settle", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -1783,7 +1863,13 @@ async function startProxy(options) {
         const responseHeaders = createBackendForwardHeaders(backendResponse);
         res.writeHead(backendResponse.status, responseHeaders);
         res.end(backendResponse.bodyText);
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: backendResponse.status
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_payment_settle_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -1795,7 +1881,12 @@ async function startProxy(options) {
       return;
     }
     if (req.method === "POST" && matchesProxyPath(req.url, UPLOAD_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_upload_received");
+      emitProxyEvent("request.received", "start", correlation, { path: UPLOAD_PROXY_PATH });
       try {
         let payload;
         try {
@@ -1817,6 +1908,10 @@ async function startProxy(options) {
           });
           return;
         }
+        correlation.quote_id = requestPayload.quote_id;
+        correlation.wallet_address = requestPayload.wallet_address;
+        correlation.object_id = requestPayload.object_id;
+        emitProxyEvent("storage.call", "start", correlation, { target: "storage/upload" });
         if (requestPayload.wallet_address.toLowerCase() !== proxyWalletAddressLower) {
           logProxyEvent("warn", "proxy_upload_wallet_mismatch", {
             request_wallet: requestPayload.wallet_address,
@@ -1886,6 +1981,7 @@ async function startProxy(options) {
           return;
         }
         const uploadPaymentFetch = createPaymentFetch(walletPrivateKey).fetch;
+        emitProxyEvent("payment.settle", "start", correlation, { via: "upload" });
         const settleResponse = await forwardPaymentSettleToBackend(
           requestPayload.quote_id,
           requestPayload.wallet_address,
@@ -1895,6 +1991,7 @@ async function startProxy(options) {
             fetchImpl: uploadPaymentFetch
           }
         );
+        emitProxyEvent("payment.settle", "result", correlation, { status: settleResponse.status });
         const settledAlready = isAlreadySettledConflict(
           settleResponse.status,
           settleResponse.bodyText
@@ -1913,6 +2010,10 @@ async function startProxy(options) {
           return;
         }
         if (settledAlready) {
+          emitProxyEvent("retry.decision", "decision", correlation, {
+            reason: "payment_already_settled_conflict",
+            status: settleResponse.status
+          });
           logProxyEvent("info", "proxy_upload_settle_already_confirmed", {
             status: settleResponse.status
           });
@@ -1925,6 +2026,7 @@ async function startProxy(options) {
         logProxyEvent("info", "proxy_upload_backend_response", {
           status: backendResponse.status
         });
+        emitProxyEvent("storage.call", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -1945,7 +2047,13 @@ async function startProxy(options) {
         const responseHeaders = createBackendForwardHeaders(backendResponse);
         res.writeHead(backendResponse.status, responseHeaders);
         res.end(backendResponse.bodyText);
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: backendResponse.status
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_upload_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -2040,7 +2148,12 @@ async function startProxy(options) {
       return;
     }
     if (req.method === "POST" && matchesProxyPath(req.url, STORAGE_LS_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_ls_received");
+      emitProxyEvent("request.received", "start", correlation, { path: STORAGE_LS_PROXY_PATH });
       try {
         let payload;
         try {
@@ -2062,6 +2175,8 @@ async function startProxy(options) {
           });
           return;
         }
+        correlation.wallet_address = requestPayload.wallet_address;
+        correlation.object_key = requestPayload.object_key;
         if (requestPayload.wallet_address.toLowerCase() !== proxyWalletAddressLower) {
           logProxyEvent("warn", "proxy_ls_wallet_mismatch");
           sendJson(res, 403, {
@@ -2081,11 +2196,13 @@ async function startProxy(options) {
           res.end(createWalletRequiredBody());
           return;
         }
+        emitProxyEvent("storage.call", "start", correlation, { target: "storage/ls" });
         const backendResponse = await forwardStorageLsToBackend(requestPayload, {
           backendBaseUrl: MNEMOSPARK_BACKEND_API_BASE_URL,
           walletSignature
         });
         logProxyEvent("info", "proxy_ls_backend_response", { status: backendResponse.status });
+        emitProxyEvent("storage.call", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -2104,7 +2221,13 @@ async function startProxy(options) {
         const responseHeaders = createBackendForwardHeaders(backendResponse);
         res.writeHead(backendResponse.status, responseHeaders);
         res.end(backendResponse.bodyText);
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: backendResponse.status
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_ls_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -2116,7 +2239,14 @@ async function startProxy(options) {
       return;
     }
     if (req.method === "POST" && matchesProxyPath(req.url, STORAGE_DOWNLOAD_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_download_received");
+      emitProxyEvent("request.received", "start", correlation, {
+        path: STORAGE_DOWNLOAD_PROXY_PATH
+      });
       try {
         let payload;
         try {
@@ -2138,6 +2268,8 @@ async function startProxy(options) {
           });
           return;
         }
+        correlation.wallet_address = requestPayload.wallet_address;
+        correlation.object_key = requestPayload.object_key;
         if (requestPayload.wallet_address.toLowerCase() !== proxyWalletAddressLower) {
           logProxyEvent("warn", "proxy_download_wallet_mismatch");
           sendJson(res, 403, {
@@ -2157,6 +2289,7 @@ async function startProxy(options) {
           res.end(createWalletRequiredBody());
           return;
         }
+        emitProxyEvent("storage.call", "start", correlation, { target: "storage/download" });
         const backendResponse = await forwardStorageDownloadToBackend(requestPayload, {
           backendBaseUrl: MNEMOSPARK_BACKEND_API_BASE_URL,
           walletSignature
@@ -2164,6 +2297,7 @@ async function startProxy(options) {
         logProxyEvent("info", "proxy_download_backend_response", {
           status: backendResponse.status
         });
+        emitProxyEvent("storage.call", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -2204,7 +2338,13 @@ async function startProxy(options) {
           file_path: downloadResult.filePath,
           bytes_written: downloadResult.bytesWritten
         });
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: 200
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_download_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -2216,7 +2356,12 @@ async function startProxy(options) {
       return;
     }
     if (req.method === "POST" && matchesProxyPath(req.url, STORAGE_DELETE_PROXY_PATH)) {
+      const correlation = {
+        trace_id: randomUUID(),
+        operation_id: randomUUID()
+      };
       logProxyEvent("info", "proxy_delete_received");
+      emitProxyEvent("request.received", "start", correlation, { path: STORAGE_DELETE_PROXY_PATH });
       try {
         let payload;
         try {
@@ -2238,6 +2383,8 @@ async function startProxy(options) {
           });
           return;
         }
+        correlation.wallet_address = requestPayload.wallet_address;
+        correlation.object_key = requestPayload.object_key;
         if (requestPayload.wallet_address.toLowerCase() !== proxyWalletAddressLower) {
           logProxyEvent("warn", "proxy_delete_wallet_mismatch");
           sendJson(res, 403, {
@@ -2257,6 +2404,7 @@ async function startProxy(options) {
           res.end(createWalletRequiredBody());
           return;
         }
+        emitProxyEvent("storage.call", "start", correlation, { target: "storage/delete" });
         const backendResponse = await forwardStorageDeleteToBackend(requestPayload, {
           backendBaseUrl: MNEMOSPARK_BACKEND_API_BASE_URL,
           walletSignature
@@ -2264,6 +2412,7 @@ async function startProxy(options) {
         logProxyEvent("info", "proxy_delete_backend_response", {
           status: backendResponse.status
         });
+        emitProxyEvent("storage.call", "result", correlation, { status: backendResponse.status });
         const authFailure = normalizeBackendAuthFailure(
           backendResponse.status,
           backendResponse.bodyText
@@ -2284,7 +2433,13 @@ async function startProxy(options) {
         const responseHeaders = createBackendForwardHeaders(backendResponse);
         res.writeHead(backendResponse.status, responseHeaders);
         res.end(backendResponse.bodyText);
+        emitProxyEvent("terminal.success", "success", correlation, {
+          status: backendResponse.status
+        });
       } catch (err) {
+        emitProxyEvent("terminal.failure", "failure", correlation, {
+          error: err instanceof Error ? err.message : String(err)
+        });
         logProxyEvent("error", "proxy_delete_forward_failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -2438,9 +2593,9 @@ async function startProxy(options) {
 }
 
 // src/auth.ts
-import { writeFile as writeFile2, readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { writeFile as writeFile2, readFile as readFile2, mkdir as mkdir3 } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
 
 // src/wallet-key.ts
@@ -2449,10 +2604,10 @@ function isValidWalletPrivateKey(value) {
 }
 
 // src/auth.ts
-var LEGACY_WALLET_DIR = join4(homedir3(), ".openclaw", "blockrun");
-var LEGACY_WALLET_FILE = join4(LEGACY_WALLET_DIR, "wallet.key");
-var WALLET_DIR = join4(homedir3(), ".openclaw", "mnemospark", "wallet");
-var WALLET_FILE = join4(WALLET_DIR, "wallet.key");
+var LEGACY_WALLET_DIR = join5(homedir4(), ".openclaw", "blockrun");
+var LEGACY_WALLET_FILE = join5(LEGACY_WALLET_DIR, "wallet.key");
+var WALLET_DIR = join5(homedir4(), ".openclaw", "mnemospark", "wallet");
+var WALLET_FILE = join5(WALLET_DIR, "wallet.key");
 async function loadSavedWallet() {
   for (const path of [WALLET_FILE, LEGACY_WALLET_FILE]) {
     try {
@@ -2475,7 +2630,7 @@ async function loadSavedWallet() {
 async function generateAndSaveWallet() {
   const key = generatePrivateKey();
   const account = privateKeyToAccount4(key);
-  await mkdir2(WALLET_DIR, { recursive: true });
+  await mkdir3(WALLET_DIR, { recursive: true });
   await writeFile2(WALLET_FILE, key + "\n", { mode: 384 });
   try {
     const verification = (await readFile2(WALLET_FILE, "utf-8")).trim();
@@ -2508,11 +2663,11 @@ async function resolveOrGenerateWalletKey() {
 // src/version.ts
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname3(__filename);
 var require2 = createRequire(import.meta.url);
-var pkg = require2(join5(__dirname, "..", "package.json"));
+var pkg = require2(join6(__dirname, "..", "package.json"));
 var VERSION = pkg.version;
 var USER_AGENT = `mnemospark/${VERSION}`;
 
@@ -2522,20 +2677,383 @@ import {
   createCipheriv,
   createHash as createHash2,
   randomBytes as randomBytesNode,
-  randomUUID
+  randomUUID as randomUUID3
 } from "crypto";
-import { createReadStream, statfsSync } from "fs";
-import { appendFile, lstat, mkdir as mkdir3, readFile as readFile3, readdir, rm, stat, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { basename, dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { createReadStream as createReadStream2, statfsSync } from "fs";
+import { appendFile as appendFile2, lstat, mkdir as mkdir5, readFile as readFile3, readdir as readdir2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename2, dirname as dirname5, join as join8, resolve as resolve2 } from "path";
 import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
+
+// src/cloud-datastore.ts
+import { randomUUID as randomUUID2 } from "crypto";
+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;
+function resolveDbPath(homeDir) {
+  return join7(homeDir ?? homedir5(), DB_SUBPATH);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function createCloudDatastore(homeDir) {
+  const dbPath = resolveDbPath(homeDir);
+  let db = null;
+  const ensureReady = async () => {
+    if (db) return;
+    if (process.env.MNEMOSPARK_DISABLE_SQLITE === "1") {
+      throw new Error("SQLite disabled by MNEMOSPARK_DISABLE_SQLITE=1");
+    }
+    await mkdir4(dirname4(dbPath), { recursive: true });
+    const sqliteMod = await import("sqlite");
+    const DatabaseSync = sqliteMod.DatabaseSync;
+    if (!DatabaseSync) {
+      throw new Error("node:sqlite DatabaseSync is unavailable");
+    }
+    const nextDb = new DatabaseSync(dbPath);
+    nextDb.exec("PRAGMA journal_mode=WAL;");
+    nextDb.exec("PRAGMA foreign_keys=ON;");
+    nextDb.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version INTEGER PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS objects (
+        object_id TEXT PRIMARY KEY,
+        object_key TEXT,
+        wallet_address TEXT NOT NULL,
+        quote_id TEXT,
+        provider TEXT,
+        bucket_name TEXT,
+        region TEXT,
+        sha256 TEXT,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_objects_wallet ON objects(wallet_address);
+      CREATE INDEX IF NOT EXISTS idx_objects_quote ON objects(quote_id);
+      CREATE INDEX IF NOT EXISTS idx_objects_object_key ON objects(object_key);
+
+      CREATE TABLE IF NOT EXISTS payments (
+        quote_id TEXT PRIMARY KEY,
+        wallet_address TEXT NOT NULL,
+        trans_id TEXT,
+        amount REAL NOT NULL,
+        network TEXT,
+        status TEXT NOT NULL,
+        settled_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_payments_wallet ON payments(wallet_address);
+
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        cron_id TEXT PRIMARY KEY,
+        object_id TEXT NOT NULL,
+        object_key TEXT NOT NULL,
+        quote_id TEXT NOT NULL,
+        schedule TEXT NOT NULL,
+        command TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_object_key ON cron_jobs(object_key);
+
+      CREATE TABLE IF NOT EXISTS operations (
+        operation_id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        object_id TEXT,
+        quote_id TEXT,
+        status TEXT NOT NULL,
+        error_code TEXT,
+        error_message TEXT,
+        started_at TEXT,
+        finished_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_operations_type ON operations(type);
+      CREATE INDEX IF NOT EXISTS idx_operations_object_id ON operations(object_id);
+      CREATE INDEX IF NOT EXISTS idx_operations_quote_id ON operations(quote_id);
+
+      CREATE TABLE IF NOT EXISTS friendly_names (
+        friendly_name_id TEXT PRIMARY KEY,
+        friendly_name TEXT NOT NULL,
+        object_id TEXT NOT NULL,
+        object_key TEXT,
+        quote_id TEXT,
+        wallet_address TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        is_active INTEGER NOT NULL DEFAULT 1
+      );
+      CREATE INDEX IF NOT EXISTS idx_friendly_names_name ON friendly_names(friendly_name);
+      CREATE INDEX IF NOT EXISTS idx_friendly_names_object_id ON friendly_names(object_id);
+      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);
+    `);
+    nextDb.prepare(
+      `INSERT INTO schema_migrations(version, applied_at)
+       VALUES(?, ?)
+       ON CONFLICT(version) DO NOTHING`
+    ).run(SCHEMA_VERSION, nowIso());
+    db = nextDb;
+  };
+  const safe = async (fn, fallback) => {
+    try {
+      await ensureReady();
+      return fn();
+    } catch {
+      return fallback;
+    }
+  };
+  return {
+    dbPath,
+    ensureReady,
+    upsertObject: async (row) => {
+      await safe(() => {
+        const ts = nowIso();
+        db.prepare(
+          `INSERT INTO objects(object_id, object_key, wallet_address, quote_id, provider, bucket_name, region, sha256, status, created_at, updated_at)
+           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(object_id) DO UPDATE SET
+             object_key=excluded.object_key,
+             wallet_address=excluded.wallet_address,
+             quote_id=excluded.quote_id,
+             provider=excluded.provider,
+             bucket_name=excluded.bucket_name,
+             region=excluded.region,
+             sha256=excluded.sha256,
+             status=excluded.status,
+             updated_at=excluded.updated_at`
+        ).run(
+          row.object_id,
+          row.object_key,
+          row.wallet_address,
+          row.quote_id,
+          row.provider,
+          row.bucket_name,
+          row.region,
+          row.sha256,
+          row.status,
+          ts,
+          ts
+        );
+      }, void 0);
+    },
+    findObjectByObjectKey: async (objectKey) => safe(() => {
+      const row = db.prepare(
+        `SELECT object_id, object_key, wallet_address, quote_id, provider, bucket_name, region, sha256, status
+             FROM objects
+             WHERE object_key = ?
+             ORDER BY updated_at DESC
+             LIMIT 1`
+      ).get(objectKey);
+      return row ?? null;
+    }, null),
+    findObjectById: async (objectId) => safe(() => {
+      const row = db.prepare(
+        `SELECT object_id, object_key, wallet_address, quote_id, provider, bucket_name, region, sha256, status
+             FROM objects
+             WHERE object_id = ?
+             LIMIT 1`
+      ).get(objectId);
+      return row ?? null;
+    }, null),
+    upsertPayment: async (row) => {
+      await safe(() => {
+        const ts = nowIso();
+        db.prepare(
+          `INSERT INTO payments(quote_id, wallet_address, trans_id, amount, network, status, settled_at, created_at, updated_at)
+           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(quote_id) DO UPDATE SET
+             wallet_address=excluded.wallet_address,
+             trans_id=excluded.trans_id,
+             amount=excluded.amount,
+             network=excluded.network,
+             status=excluded.status,
+             settled_at=excluded.settled_at,
+             updated_at=excluded.updated_at`
+        ).run(
+          row.quote_id,
+          row.wallet_address,
+          row.trans_id,
+          row.amount,
+          row.network,
+          row.status,
+          row.settled_at ?? null,
+          ts,
+          ts
+        );
+      }, void 0);
+    },
+    upsertCronJob: async (row) => {
+      await safe(() => {
+        const ts = nowIso();
+        db.prepare(
+          `INSERT INTO cron_jobs(cron_id, object_id, object_key, quote_id, schedule, command, status, created_at, updated_at)
+           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(cron_id) DO UPDATE SET
+             object_id=excluded.object_id,
+             object_key=excluded.object_key,
+             quote_id=excluded.quote_id,
+             schedule=excluded.schedule,
+             command=excluded.command,
+             status=excluded.status,
+             updated_at=excluded.updated_at`
+        ).run(
+          row.cron_id,
+          row.object_id,
+          row.object_key,
+          row.quote_id,
+          row.schedule,
+          row.command,
+          row.status,
+          ts,
+          ts
+        );
+      }, void 0);
+    },
+    removeCronJob: async (cronId) => safe(() => {
+      const res = db.prepare(`DELETE FROM cron_jobs WHERE cron_id = ?`).run(cronId);
+      return Number(res.changes ?? 0) > 0;
+    }, false),
+    findCronByObjectKey: async (objectKey) => safe(() => {
+      const row = db.prepare(
+        `SELECT cron_id, object_id FROM cron_jobs WHERE object_key = ? ORDER BY updated_at DESC LIMIT 1`
+      ).get(objectKey);
+      if (!row) return null;
+      return { cronId: row.cron_id, objectId: row.object_id };
+    }, null),
+    upsertOperation: async (row) => {
+      await safe(() => {
+        const ts = nowIso();
+        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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(operation_id) DO UPDATE SET
+             type=excluded.type,
+             object_id=excluded.object_id,
+             quote_id=excluded.quote_id,
+             status=excluded.status,
+             error_code=excluded.error_code,
+             error_message=excluded.error_message,
+             started_at=COALESCE(excluded.started_at, operations.started_at),
+             finished_at=COALESCE(excluded.finished_at, operations.finished_at),
+             updated_at=excluded.updated_at`
+        ).run(
+          row.operation_id,
+          row.type,
+          row.object_id,
+          row.quote_id,
+          row.status,
+          row.error_code,
+          row.error_message,
+          row.status === "started" ? ts : null,
+          row.status === "succeeded" || row.status === "failed" ? ts : null,
+          ts,
+          ts
+        );
+      }, void 0);
+    },
+    findOperationById: async (operationId) => safe(() => {
+      const row = db.prepare(
+        `SELECT operation_id, type, status, error_code, error_message, started_at, finished_at, updated_at
+             FROM operations
+             WHERE operation_id = ?
+             LIMIT 1`
+      ).get(operationId);
+      return row ?? null;
+    }, null),
+    findQuoteById: async (quoteId) => safe(() => {
+      const row = db.prepare(
+        `SELECT quote_id, amount, wallet_address FROM payments WHERE quote_id = ? ORDER BY updated_at DESC LIMIT 1`
+      ).get(quoteId);
+      const object = db.prepare(
+        `SELECT object_id, sha256, provider, region FROM objects WHERE quote_id = ? ORDER BY updated_at DESC LIMIT 1`
+      ).get(quoteId);
+      if (!row || !object) return null;
+      if (object.sha256 === null || object.provider === null || object.region === null)
+        return null;
+      return {
+        quoteId,
+        storagePrice: Number(row.amount),
+        walletAddress: row.wallet_address,
+        objectId: object.object_id,
+        objectIdHash: object.sha256,
+        provider: object.provider,
+        location: object.region
+      };
+    }, null),
+    upsertFriendlyName: async (row) => {
+      await safe(() => {
+        const ts = nowIso();
+        db.prepare(
+          `INSERT INTO friendly_names(friendly_name_id, friendly_name, object_id, object_key, quote_id, wallet_address, created_at, updated_at, is_active)
+             VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          randomUUID2(),
+          row.friendly_name,
+          row.object_id,
+          row.object_key,
+          row.quote_id,
+          row.wallet_address,
+          ts,
+          ts,
+          row.is_active ?? 1
+        );
+      }, void 0);
+    },
+    resolveFriendlyName: async (params) => safe(() => {
+      const atIso = params.at ? new Date(params.at).toISOString() : null;
+      const row = params.latest || !atIso ? db.prepare(
+        `SELECT friendly_name_id, friendly_name, object_id, object_key, quote_id, wallet_address, created_at
+                 FROM friendly_names
+                 WHERE wallet_address = ? AND friendly_name = ? AND is_active = 1
+                 ORDER BY created_at DESC
+                 LIMIT 1`
+      ).get(params.walletAddress, params.friendlyName) : db.prepare(
+        `SELECT friendly_name_id, friendly_name, object_id, object_key, quote_id, wallet_address, created_at
+                 FROM friendly_names
+                 WHERE wallet_address = ? AND friendly_name = ? AND is_active = 1 AND created_at <= ?
+                 ORDER BY created_at DESC
+                 LIMIT 1`
+      ).get(params.walletAddress, params.friendlyName, atIso);
+      if (!row) return null;
+      return {
+        friendlyNameId: row.friendly_name_id,
+        friendlyName: row.friendly_name,
+        objectId: row.object_id,
+        objectKey: row.object_key,
+        quoteId: row.quote_id,
+        walletAddress: row.wallet_address,
+        createdAt: row.created_at
+      };
+    }, null),
+    countFriendlyNameMatches: async (walletAddress, friendlyName) => safe(() => {
+      const row = db.prepare(
+        `SELECT COUNT(1) AS cnt
+             FROM friendly_names
+             WHERE wallet_address = ? AND friendly_name = ? AND is_active = 1`
+      ).get(walletAddress, friendlyName);
+      return Number(row?.cnt ?? 0);
+    }, 0)
+  };
+}
+
+// src/cloud-command.ts
 var SUPPORTED_BACKUP_PLATFORMS = /* @__PURE__ */ new Set(["darwin", "linux"]);
-var BACKUP_DIR_SUBPATH = join6(".openclaw", "mnemospark", "backup");
-var DEFAULT_BACKUP_DIR = join6(homedir4(), BACKUP_DIR_SUBPATH);
-var OBJECT_LOG_SUBPATH = join6(".openclaw", "mnemospark", "object.log");
-var CRON_TABLE_SUBPATH = join6(".openclaw", "mnemospark", "crontab.txt");
-var BLOCKRUN_WALLET_KEY_SUBPATH = join6(".openclaw", "blockrun", "wallet.key");
-var MNEMOSPARK_WALLET_KEY_SUBPATH = join6(".openclaw", "mnemospark", "wallet", "wallet.key");
+var BACKUP_DIR_SUBPATH = join8(".openclaw", "mnemospark", "backup");
+var DEFAULT_BACKUP_DIR = join8(homedir6(), BACKUP_DIR_SUBPATH);
+var OBJECT_LOG_SUBPATH = join8(".openclaw", "mnemospark", "object.log");
+var CRON_TABLE_SUBPATH = join8(".openclaw", "mnemospark", "crontab.txt");
+var BLOCKRUN_WALLET_KEY_SUBPATH = join8(".openclaw", "blockrun", "wallet.key");
+var MNEMOSPARK_WALLET_KEY_SUBPATH = join8(".openclaw", "mnemospark", "wallet", "wallet.key");
 var INLINE_UPLOAD_MAX_BYTES = 45e5;
 var PAYMENT_REMINDER_INTERVAL_DAYS = 30;
 var PAYMENT_DELETE_DEADLINE_DAYS = 32;
@@ -2544,14 +3062,17 @@ var CRON_LOG_ROW_PREFIX = "cron";
 var TAR_OVERHEAD_BYTES = 10 * 1024 * 1024;
 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_STORAGE_OBJECT = "--wallet-address, --object-key";
+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_SELECTOR_AND_ASYNC_FLAGS = /* @__PURE__ */ new Set(["latest", "async"]);
 function expandTilde(path) {
   const trimmed = path.trim();
   if (trimmed === "~") {
-    return homedir4();
+    return homedir6();
   }
   if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return join6(homedir4(), trimmed.slice(2));
+    return join8(homedir6(), trimmed.slice(2));
   }
   return path;
 }
@@ -2560,24 +3081,27 @@ var CLOUD_HELP_TEXT = [
   "",
   "\u2022 `/mnemospark-cloud` or `/mnemospark-cloud help` \u2014 show this message",
   "",
-  "\u2022 `/mnemospark-cloud backup <file>` or `/mnemospark-cloud backup <directory>`",
+  "\u2022 `/mnemospark-cloud backup <file>` or `/mnemospark-cloud backup <directory> [--name <friendly-name>]`",
   "  Required: <file> or <directory> (path to back up)",
   "",
   "\u2022 `/mnemospark-cloud price-storage --wallet-address <addr> --object-id <id> --object-id-hash <hash> --gb <gb> --provider <provider> --region <region>`",
   "  Required: " + REQUIRED_PRICE_STORAGE,
   "",
-  "\u2022 `/mnemospark-cloud upload --quote-id <quote-id> --wallet-address <addr> --object-id <id> --object-id-hash <hash>`",
+  "\u2022 `/mnemospark-cloud upload --quote-id <quote-id> --wallet-address <addr> --object-id <id> --object-id-hash <hash> [--name <friendly-name>] [--async]`",
   "  Required: " + REQUIRED_UPLOAD,
   "",
-  "\u2022 `/mnemospark-cloud ls --wallet-address <addr> --object-key <object-key>`",
+  "\u2022 `/mnemospark-cloud ls --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>]`",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
-  "\u2022 `/mnemospark-cloud download --wallet-address <addr> --object-key <object-key>`",
+  "\u2022 `/mnemospark-cloud download --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>] [--async]`",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
-  "\u2022 `/mnemospark-cloud delete --wallet-address <addr> --object-key <object-key>`",
+  "\u2022 `/mnemospark-cloud delete --wallet-address <addr> [--object-key <object-key> | --name <friendly-name>] [--latest|--at <timestamp>]`",
   "  Required: " + REQUIRED_STORAGE_OBJECT,
   "",
+  "\u2022 `/mnemospark-cloud op-status --operation-id <id>`",
+  "  Required: --operation-id",
+  "",
   "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 {
@@ -2600,15 +3124,17 @@ function stripWrappingQuotes(input) {
   }
   return trimmed;
 }
-function tokenizeArgs(input) {
+function tokenizeArgsRaw(input) {
   const tokens = input.match(/"[^"]*"|'[^']*'|\S+/g);
   if (!tokens) {
     return [];
   }
-  return tokens.map((token) => stripWrappingQuotes(token));
+  return tokens;
 }
-function parseNamedFlags(input) {
-  const tokens = tokenizeArgs(input);
+function tokenizeArgs(input) {
+  return tokenizeArgsRaw(input).map((token) => stripWrappingQuotes(token));
+}
+function parseNamedFlagsTokens(tokens, booleanFlags = /* @__PURE__ */ new Set()) {
   if (tokens.length === 0) {
     return null;
   }
@@ -2621,6 +3147,10 @@ function parseNamedFlags(input) {
     const key = keyToken.slice(2).toLowerCase();
     const value = tokens[i + 1];
     if (!value || value.startsWith("--")) {
+      if (booleanFlags.has(key)) {
+        parsed[key] = "true";
+        continue;
+      }
       return null;
     }
     parsed[key] = value;
@@ -2628,6 +3158,44 @@ function parseNamedFlags(input) {
   }
   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();
+  const latest = flags.latest === "true";
+  const at = flags.at?.trim();
+  if (objectKey && name) return null;
+  if (!objectKey && !name) return null;
+  if (latest && at) return null;
+  if (objectKey) return { objectKey };
+  return { nameSelector: { name, latest, at } };
+}
+function parseStorageObjectRequestInput(flags, selector) {
+  const walletAddress = flags["wallet-address"]?.trim();
+  if (!walletAddress) {
+    return null;
+  }
+  const location = flags.location?.trim() || flags.region?.trim() || void 0;
+  if (!selector.objectKey) {
+    return {
+      wallet_address: walletAddress,
+      location
+    };
+  }
+  return parseStorageObjectRequest({
+    wallet_address: walletAddress,
+    object_key: selector.objectKey,
+    location
+  });
+}
+function stripAsyncFlag(args) {
+  const tokens = tokenizeArgsRaw(args ?? "");
+  const filtered = tokens.filter((token) => token.toLowerCase() !== "--async");
+  return filtered.join(" ");
+}
 function parseCloudArgs(args) {
   const trimmed = args?.trim() ?? "";
   if (!trimmed) {
@@ -2640,11 +3208,16 @@ function parseCloudArgs(args) {
     return { mode: "help" };
   }
   if (subcommand === "backup") {
-    const backupTarget = stripWrappingQuotes(rest);
+    const tokens = tokenizeArgs(rest);
+    if (tokens.length === 0) {
+      return { mode: "unknown" };
+    }
+    const backupTarget = tokens[0] ?? "";
     if (!backupTarget) {
       return { mode: "unknown" };
     }
-    return { mode: "backup", backupTarget };
+    const flags = parseNamedFlagsTokens(tokens.slice(1));
+    return { mode: "backup", backupTarget, friendlyName: flags?.name?.trim() || void 0 };
   }
   if (subcommand === "price-storage") {
     const flags = parseNamedFlags(rest);
@@ -2666,7 +3239,7 @@ function parseCloudArgs(args) {
     return { mode: "price-storage", priceStorageRequest: request };
   }
   if (subcommand === "upload") {
-    const flags = parseNamedFlags(rest);
+    const flags = parseNamedFlags(rest, BOOLEAN_ASYNC_FLAGS);
     if (!flags) {
       return { mode: "upload-invalid" };
     }
@@ -2679,6 +3252,8 @@ function parseCloudArgs(args) {
     }
     return {
       mode: "upload",
+      friendlyName: flags.name?.trim() || void 0,
+      async: flags.async === "true",
       uploadRequest: {
         quote_id: quoteId,
         wallet_address: walletAddress,
@@ -2688,62 +3263,75 @@ function parseCloudArgs(args) {
     };
   }
   if (subcommand === "ls") {
-    const flags = parseNamedFlags(rest);
+    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_FLAGS);
     if (!flags) {
       return { mode: "ls-invalid" };
     }
-    const request = parseStorageObjectRequest({
-      wallet_address: flags["wallet-address"],
-      object_key: flags["object-key"],
-      location: flags.location ?? flags.region
-    });
+    const selector = parseObjectSelector(flags);
+    if (!selector) {
+      return { mode: "ls-invalid" };
+    }
+    const request = parseStorageObjectRequestInput(flags, selector);
     if (!request) {
       return { mode: "ls-invalid" };
     }
-    return { mode: "ls", storageObjectRequest: request };
+    return { mode: "ls", storageObjectRequest: request, nameSelector: selector.nameSelector };
   }
   if (subcommand === "download") {
-    const flags = parseNamedFlags(rest);
+    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_AND_ASYNC_FLAGS);
     if (!flags) {
       return { mode: "download-invalid" };
     }
-    const request = parseStorageObjectRequest({
-      wallet_address: flags["wallet-address"],
-      object_key: flags["object-key"],
-      location: flags.location ?? flags.region
-    });
+    const selector = parseObjectSelector(flags);
+    if (!selector) {
+      return { mode: "download-invalid" };
+    }
+    const request = parseStorageObjectRequestInput(flags, selector);
     if (!request) {
       return { mode: "download-invalid" };
     }
-    return { mode: "download", storageObjectRequest: request };
+    return {
+      mode: "download",
+      storageObjectRequest: request,
+      nameSelector: selector.nameSelector,
+      async: flags.async === "true"
+    };
   }
   if (subcommand === "delete") {
-    const flags = parseNamedFlags(rest);
+    const flags = parseNamedFlags(rest, BOOLEAN_SELECTOR_FLAGS);
     if (!flags) {
       return { mode: "delete-invalid" };
     }
-    const request = parseStorageObjectRequest({
-      wallet_address: flags["wallet-address"],
-      object_key: flags["object-key"],
-      location: flags.location ?? flags.region
-    });
+    const selector = parseObjectSelector(flags);
+    if (!selector) {
+      return { mode: "delete-invalid" };
+    }
+    const request = parseStorageObjectRequestInput(flags, selector);
     if (!request) {
       return { mode: "delete-invalid" };
     }
-    return { mode: "delete", storageObjectRequest: request };
+    return { mode: "delete", storageObjectRequest: request, nameSelector: selector.nameSelector };
+  }
+  if (subcommand === "op-status") {
+    const flags = parseNamedFlags(rest);
+    const operationId = flags?.["operation-id"]?.trim();
+    if (!operationId) {
+      return { mode: "op-status-invalid" };
+    }
+    return { mode: "op-status", operationId };
   }
   return { mode: "unknown" };
 }
 function resolveObjectLogPath(homeDir) {
-  return join6(homeDir ?? homedir4(), OBJECT_LOG_SUBPATH);
+  return join8(homeDir ?? homedir6(), OBJECT_LOG_SUBPATH);
 }
 function resolveCronTablePath(homeDir) {
-  return join6(homeDir ?? homedir4(), CRON_TABLE_SUBPATH);
+  return join8(homeDir ?? homedir6(), CRON_TABLE_SUBPATH);
 }
 async function appendObjectLogLine(line, homeDir) {
   const objectLogPath = resolveObjectLogPath(homeDir);
-  await mkdir3(dirname3(objectLogPath), { recursive: true });
-  await appendFile(objectLogPath, `${line}
+  await mkdir5(dirname5(objectLogPath), { recursive: true });
+  await appendFile2(objectLogPath, `${line}
 `, "utf-8");
   return objectLogPath;
 }
@@ -2756,9 +3344,9 @@ async function calculateInputSizeBytes(targetPath) {
     throw new Error("Backup target must be a file or directory");
   }
   let total = 0;
-  const entries = await readdir(targetPath, { withFileTypes: true });
+  const entries = await readdir2(targetPath, { withFileTypes: true });
   for (const entry of entries) {
-    total += await calculateInputSizeBytes(join6(targetPath, entry.name));
+    total += await calculateInputSizeBytes(join8(targetPath, entry.name));
   }
   return total;
 }
@@ -2770,8 +3358,8 @@ function getAvailableDiskBytes(tmpDir, options) {
   return stats.bavail * stats.bsize;
 }
 async function runTarGzip(archivePath, sourcePath) {
-  const sourceDir = dirname3(sourcePath);
-  const sourceName = basename(sourcePath);
+  const sourceDir = dirname5(sourcePath);
+  const sourceName = basename2(sourcePath);
   await new Promise((resolvePromise, rejectPromise) => {
     let stderr = "";
     const child = spawn("tar", ["-czf", archivePath, "-C", sourceDir, sourceName], {
@@ -2793,7 +3381,7 @@ async function runTarGzip(archivePath, sourcePath) {
 async function sha256File(filePath) {
   const hash = createHash2("sha256");
   await new Promise((resolvePromise, rejectPromise) => {
-    const stream = createReadStream(filePath);
+    const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", rejectPromise);
     stream.on("end", () => resolvePromise());
@@ -2818,11 +3406,11 @@ async function buildBackupObject(targetPathArg, options = {}) {
   const tmpDir = options.tmpDir ?? DEFAULT_BACKUP_DIR;
   let tmpStats;
   try {
-    tmpStats = await stat(tmpDir);
+    tmpStats = await stat2(tmpDir);
   } catch (error) {
     if (error.code === "ENOENT") {
-      await mkdir3(tmpDir, { recursive: true });
-      tmpStats = await stat(tmpDir);
+      await mkdir5(tmpDir, { recursive: true });
+      tmpStats = await stat2(tmpDir);
     } else {
       throw error;
     }
@@ -2837,10 +3425,10 @@ async function buildBackupObject(targetPathArg, options = {}) {
     throw new Error("Insufficient disk space for backup object");
   }
   const objectId = createObjectId(options);
-  const archivePath = join6(tmpDir, objectId);
+  const archivePath = join8(tmpDir, objectId);
   try {
     await runTarGzip(archivePath, targetPath);
-    const archiveStats = await stat(archivePath);
+    const archiveStats = await stat2(archivePath);
     const objectIdHash = await sha256File(archivePath);
     const objectSizeGb = toGbString(archiveStats.size);
     const objectLogPath = await appendObjectLogLine(
@@ -3059,8 +3647,8 @@ async function appendStoragePaymentCronLog(cronJob, homeDir) {
 }
 async function appendStoragePaymentCronJob(cronJob, homeDir) {
   const cronTablePath = resolveCronTablePath(homeDir);
-  await mkdir3(dirname3(cronTablePath), { recursive: true });
-  await appendFile(cronTablePath, `${JSON.stringify(cronJob)}
+  await mkdir5(dirname5(cronTablePath), { recursive: true });
+  await appendFile2(cronTablePath, `${JSON.stringify(cronJob)}
 `, "utf-8");
   return cronTablePath;
 }
@@ -3093,14 +3681,14 @@ async function removeStoragePaymentCronJob(cronId, homeDir) {
   if (!removed) {
     return false;
   }
-  await mkdir3(dirname3(cronTablePath), { recursive: true });
+  await mkdir5(dirname5(cronTablePath), { recursive: true });
   const nextContent = keptLines.length > 0 ? `${keptLines.join("\n")}
 ` : "";
   await writeFile3(cronTablePath, nextContent, "utf-8");
   return true;
 }
 async function createStoragePaymentCronJob(upload, storagePrice, homeDir, nowDateFn = () => /* @__PURE__ */ new Date()) {
-  const cronId = randomUUID();
+  const cronId = randomUUID3();
   const createdAt = formatTimestamp(nowDateFn());
   const cronJob = {
     cronId,
@@ -3142,9 +3730,9 @@ async function resolveWalletPrivateKey(homeDir) {
   if (isValidWalletPrivateKey(envKey)) {
     return envKey;
   }
-  const baseHome = homeDir ?? homedir4();
-  const primaryWalletPath = join6(baseHome, MNEMOSPARK_WALLET_KEY_SUBPATH);
-  const fallbackWalletPath = join6(baseHome, BLOCKRUN_WALLET_KEY_SUBPATH);
+  const baseHome = homeDir ?? homedir6();
+  const primaryWalletPath = join8(baseHome, MNEMOSPARK_WALLET_KEY_SUBPATH);
+  const fallbackWalletPath = join8(baseHome, BLOCKRUN_WALLET_KEY_SUBPATH);
   const fromPrimary = await readWalletKeyIfPresent(primaryWalletPath);
   if (fromPrimary) {
     return fromPrimary;
@@ -3175,7 +3763,7 @@ function encryptAesGcm(plaintext, key, randomFn = randomBytesNode) {
 }
 async function loadOrCreateKek(walletAddress, homeDir) {
   const keyPath = resolveWalletKekPath(walletAddress, homeDir);
-  await mkdir3(dirname3(keyPath), { recursive: true });
+  await mkdir5(dirname5(keyPath), { recursive: true });
   try {
     const existing = await readFile3(keyPath);
     return { kek: parseStoredAes256Key(existing), keyPath };
@@ -3326,7 +3914,7 @@ function createCloudCommand(options = {}) {
           createPaymentFetchFn: options.createPaymentFetchFn ?? createPaymentFetch,
           fetchImpl: options.fetchImpl ?? fetch,
           nowDateFn: options.nowDateFn ?? (() => /* @__PURE__ */ new Date()),
-          idempotencyKeyFn: options.idempotencyKeyFn ?? randomUUID,
+          idempotencyKeyFn: options.idempotencyKeyFn ?? randomUUID3,
           requestStorageLsFn: options.requestStorageLsFn ?? requestStorageLsViaProxy,
           requestStorageDownloadFn: options.requestStorageDownloadFn ?? requestStorageDownloadViaProxy,
           requestStorageDeleteFn: options.requestStorageDeleteFn ?? requestStorageDeleteViaProxy,
@@ -3344,6 +3932,57 @@ function createCloudCommand(options = {}) {
     }
   };
 }
+async function resolveNameSelectorIfNeeded(datastore, request, selector) {
+  if (!selector) {
+    const parsedRequest2 = parseStorageObjectRequest(request);
+    if (!parsedRequest2) {
+      return { error: "Cannot resolve storage object request." };
+    }
+    return { request: parsedRequest2 };
+  }
+  const matches = await datastore.countFriendlyNameMatches(request.wallet_address, selector.name);
+  if (matches > 1 && !selector.latest && !selector.at) {
+    return {
+      error: `Multiple objects match --name ${selector.name}. Add --latest or --at <timestamp>.`
+    };
+  }
+  const resolved = await datastore.resolveFriendlyName({
+    walletAddress: request.wallet_address,
+    friendlyName: selector.name,
+    latest: selector.latest,
+    at: selector.at
+  });
+  if (!resolved || !resolved.objectKey) {
+    return { error: `No object found for --name ${selector.name}.` };
+  }
+  const parsedRequest = parseStorageObjectRequest({
+    ...request,
+    object_key: resolved.objectKey
+  });
+  if (!parsedRequest) {
+    return { error: "Cannot resolve storage object request." };
+  }
+  return {
+    request: parsedRequest
+  };
+}
+async function emitCloudEvent(eventType, details, homeDir) {
+  await appendJsonlEvent(
+    "events.jsonl",
+    {
+      ...details,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event_type: eventType
+    },
+    homeDir
+  );
+}
+async function emitCloudEventBestEffort(eventType, details, homeDir) {
+  try {
+    await emitCloudEvent(eventType, details, homeDir);
+  } catch {
+  }
+}
 async function runCloudCommandHandler(ctx, options) {
   const parsed = parseCloudArgs(ctx.args);
   const objectLogHomeDir = options.objectLogHomeDir;
@@ -3395,9 +4034,109 @@ async function runCloudCommandHandler(ctx, options) {
       isError: true
     };
   }
+  if (parsed.mode === "op-status-invalid") {
+    return {
+      text: "Cannot get operation status: required arguments are --operation-id.",
+      isError: true
+    };
+  }
+  const datastore = await createCloudDatastore(objectLogHomeDir);
+  if (parsed.mode === "op-status") {
+    const 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.mode === "upload" || parsed.mode === "download") && parsed.async) {
+    const operationId = randomUUID3();
+    const opType = parsed.mode;
+    const opObject = parsed.mode === "upload" ? parsed.uploadRequest.object_id : parsed.storageObjectRequest.object_key ?? null;
+    const opQuote = parsed.mode === "upload" ? parsed.uploadRequest.quote_id : null;
+    await datastore.upsertOperation({
+      operation_id: operationId,
+      type: opType,
+      object_id: opObject,
+      quote_id: opQuote,
+      status: "started",
+      error_code: null,
+      error_message: null
+    });
+    const syncArgs = stripAsyncFlag(ctx.args);
+    void runCloudCommandHandler({ args: syncArgs }, options).then(async (result) => {
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: opType,
+        object_id: opObject,
+        quote_id: opQuote,
+        status: result.isError ? "failed" : "succeeded",
+        error_code: result.isError ? "ASYNC_FAILED" : null,
+        error_message: result.isError ? result.text : null
+      });
+    }).catch(async (err) => {
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: opType,
+        object_id: opObject,
+        quote_id: opQuote,
+        status: "failed",
+        error_code: "ASYNC_EXCEPTION",
+        error_message: err instanceof Error ? err.message : String(err)
+      });
+    });
+    return {
+      text: `Operation started in background. operation-id: ${operationId}
+Use /mnemospark-cloud op-status --operation-id ${operationId}`
+    };
+  }
   if (parsed.mode === "backup") {
     try {
       const result = await backupBuilder(parsed.backupTarget, options.backupOptions);
+      await emitCloudEventBestEffort(
+        "backup.completed",
+        {
+          operation_id: randomUUID3(),
+          object_id: result.objectId,
+          status: "succeeded",
+          details: { friendly_name: parsed.friendlyName ?? basename2(parsed.backupTarget) }
+        },
+        objectLogHomeDir
+      );
+      await datastore.upsertObject({
+        object_id: result.objectId,
+        object_key: null,
+        wallet_address: "unknown",
+        quote_id: null,
+        provider: null,
+        bucket_name: null,
+        region: null,
+        sha256: result.objectIdHash,
+        status: "backed_up"
+      });
+      const friendlyName = parsed.friendlyName?.trim() || basename2(parsed.backupTarget);
+      if (friendlyName) {
+        await datastore.upsertFriendlyName({
+          friendly_name: friendlyName,
+          object_id: result.objectId,
+          object_key: null,
+          quote_id: null,
+          wallet_address: "unknown"
+        });
+      }
       return {
         text: [
           `object-id: ${result.objectId}`,
@@ -3425,6 +4164,25 @@ async function runCloudCommandHandler(ctx, options) {
         options.proxyQuoteOptions
       );
       await appendPriceStorageQuoteLog(quote, objectLogHomeDir);
+      await datastore.upsertObject({
+        object_id: quote.object_id,
+        object_key: null,
+        wallet_address: quote.addr,
+        quote_id: quote.quote_id,
+        provider: quote.provider,
+        bucket_name: null,
+        region: quote.location,
+        sha256: quote.object_id_hash,
+        status: "quoted"
+      });
+      await datastore.upsertPayment({
+        quote_id: quote.quote_id,
+        wallet_address: quote.addr,
+        trans_id: null,
+        amount: quote.storage_price,
+        network: null,
+        status: "quoted"
+      });
       return {
         text: formatPriceStorageUserMessage(quote)
       };
@@ -3438,10 +4196,7 @@ async function runCloudCommandHandler(ctx, options) {
   }
   if (parsed.mode === "upload") {
     try {
-      const loggedQuote = await findLoggedPriceStorageQuote(
-        parsed.uploadRequest.quote_id,
-        objectLogHomeDir
-      );
+      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.",
@@ -3454,13 +4209,13 @@ async function runCloudCommandHandler(ctx, options) {
           isError: true
         };
       }
-      const archivePath = join6(
+      const archivePath = join8(
         options.backupOptions?.tmpDir ?? DEFAULT_BACKUP_DIR,
         parsed.uploadRequest.object_id
       );
       let archiveStats;
       try {
-        archiveStats = await stat(archivePath);
+        archiveStats = await stat2(archivePath);
       } catch {
         return {
           text: `Cannot upload storage object: local archive not found at ${archivePath}. Run /mnemospark-cloud backup first.`,
@@ -3561,6 +4316,71 @@ async function runCloudCommandHandler(ctx, options) {
         objectLogHomeDir,
         nowDateFn
       );
+      await datastore.upsertObject({
+        object_id: finalizedUploadResponse.object_id,
+        object_key: finalizedUploadResponse.object_key,
+        wallet_address: finalizedUploadResponse.addr,
+        quote_id: finalizedUploadResponse.quote_id,
+        provider: finalizedUploadResponse.provider,
+        bucket_name: finalizedUploadResponse.bucket_name,
+        region: finalizedUploadResponse.location,
+        sha256: parsed.uploadRequest.object_id_hash,
+        status: "uploaded"
+      });
+      await datastore.upsertPayment({
+        quote_id: finalizedUploadResponse.quote_id,
+        wallet_address: finalizedUploadResponse.addr,
+        trans_id: finalizedUploadResponse.trans_id ?? null,
+        amount: cronStoragePrice,
+        network: null,
+        status: "settled",
+        settled_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await datastore.upsertCronJob({
+        cron_id: cronJob.cronId,
+        object_id: cronJob.objectId,
+        object_key: cronJob.objectKey,
+        quote_id: cronJob.quoteId,
+        schedule: cronJob.schedule,
+        command: cronJob.command,
+        status: "active"
+      });
+      if (parsed.friendlyName?.trim()) {
+        await datastore.upsertFriendlyName({
+          friendly_name: parsed.friendlyName.trim(),
+          object_id: finalizedUploadResponse.object_id,
+          object_key: finalizedUploadResponse.object_key,
+          quote_id: finalizedUploadResponse.quote_id,
+          wallet_address: finalizedUploadResponse.addr
+        });
+        try {
+          await appendJsonlEvent(
+            "manifest.jsonl",
+            {
+              friendly_name: parsed.friendlyName.trim(),
+              object_id: finalizedUploadResponse.object_id,
+              object_key: finalizedUploadResponse.object_key,
+              quote_id: finalizedUploadResponse.quote_id,
+              wallet_address: finalizedUploadResponse.addr,
+              created_at: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            objectLogHomeDir
+          );
+        } catch {
+        }
+      }
+      await emitCloudEventBestEffort(
+        "upload.completed",
+        {
+          operation_id: idempotencyKey,
+          wallet_address: finalizedUploadResponse.addr,
+          object_id: finalizedUploadResponse.object_id,
+          object_key: finalizedUploadResponse.object_key,
+          quote_id: finalizedUploadResponse.quote_id,
+          status: "succeeded"
+        },
+        objectLogHomeDir
+      );
       await maybeCleanupLocalBackupArchive(archivePath);
       return {
         text: formatStorageUploadUserMessage(finalizedUploadResponse, cronJob.cronId)
@@ -3574,18 +4394,72 @@ async function runCloudCommandHandler(ctx, options) {
     }
   }
   if (parsed.mode === "ls") {
+    const resolved = await resolveNameSelectorIfNeeded(
+      datastore,
+      parsed.storageObjectRequest,
+      parsed.nameSelector
+    );
+    if (resolved.error || !resolved.request) {
+      return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
+    }
+    const resolvedRequest = resolved.request;
+    const operationId = randomUUID3();
+    await datastore.upsertOperation({
+      operation_id: operationId,
+      type: "ls",
+      object_id: resolvedRequest.object_key,
+      quote_id: null,
+      status: "started",
+      error_code: null,
+      error_message: null
+    });
     try {
-      const lsResult = await requestStorageLs(
-        parsed.storageObjectRequest,
-        options.proxyStorageOptions
-      );
+      const lsResult = await requestStorageLs(resolvedRequest, options.proxyStorageOptions);
       if (!lsResult.success) {
         throw new Error("ls failed");
       }
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: "ls",
+        object_id: resolvedRequest.object_key,
+        quote_id: null,
+        status: "succeeded",
+        error_code: null,
+        error_message: null
+      });
+      await emitCloudEventBestEffort(
+        "ls.completed",
+        {
+          operation_id: operationId,
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          status: "succeeded"
+        },
+        objectLogHomeDir
+      );
       return {
-        text: formatStorageLsUserMessage(lsResult, parsed.storageObjectRequest.object_key)
+        text: formatStorageLsUserMessage(lsResult, resolvedRequest.object_key)
       };
     } catch {
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: "ls",
+        object_id: resolvedRequest.object_key,
+        quote_id: null,
+        status: "failed",
+        error_code: "LS_FAILED",
+        error_message: "Cannot list storage object"
+      });
+      await emitCloudEventBestEffort(
+        "ls.completed",
+        {
+          operation_id: operationId,
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          status: "failed"
+        },
+        objectLogHomeDir
+      );
       return {
         text: "Cannot list storage object",
         isError: true
@@ -3593,18 +4467,75 @@ async function runCloudCommandHandler(ctx, options) {
     }
   }
   if (parsed.mode === "download") {
+    const resolved = await resolveNameSelectorIfNeeded(
+      datastore,
+      parsed.storageObjectRequest,
+      parsed.nameSelector
+    );
+    if (resolved.error || !resolved.request) {
+      return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
+    }
+    const resolvedRequest = resolved.request;
+    const operationId = randomUUID3();
+    await datastore.upsertOperation({
+      operation_id: operationId,
+      type: "download",
+      object_id: resolvedRequest.object_key,
+      quote_id: null,
+      status: "started",
+      error_code: null,
+      error_message: null
+    });
     try {
       const downloadResult = await requestStorageDownload(
-        parsed.storageObjectRequest,
+        resolvedRequest,
         options.proxyStorageOptions
       );
       if (!downloadResult.success) {
         throw new Error("download failed");
       }
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: "download",
+        object_id: resolvedRequest.object_key,
+        quote_id: null,
+        status: "succeeded",
+        error_code: null,
+        error_message: null
+      });
+      await emitCloudEventBestEffort(
+        "download.completed",
+        {
+          operation_id: operationId,
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          status: "succeeded"
+        },
+        objectLogHomeDir
+      );
       return {
-        text: `File ${parsed.storageObjectRequest.object_key} downloaded to ${downloadResult.file_path}`
+        text: `File ${resolvedRequest.object_key} downloaded to ${downloadResult.file_path}`
       };
     } catch {
+      await datastore.upsertOperation({
+        operation_id: operationId,
+        type: "download",
+        object_id: resolvedRequest.object_key,
+        quote_id: null,
+        status: "failed",
+        error_code: "DOWNLOAD_FAILED",
+        error_message: "Cannot download file"
+      });
+      await emitCloudEventBestEffort(
+        "download.completed",
+        {
+          operation_id: operationId,
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          status: "failed"
+        },
+        objectLogHomeDir
+      );
       return {
         text: "Cannot download file",
         isError: true
@@ -3612,15 +4543,33 @@ async function runCloudCommandHandler(ctx, options) {
     }
   }
   if (parsed.mode === "delete") {
+    const resolved = await resolveNameSelectorIfNeeded(
+      datastore,
+      parsed.storageObjectRequest,
+      parsed.nameSelector
+    );
+    if (resolved.error || !resolved.request) {
+      return { text: resolved.error ?? "Cannot resolve storage object request.", isError: true };
+    }
+    const resolvedRequest = resolved.request;
+    const operationId = randomUUID3();
+    const existingObjectByKey = await datastore.findObjectByObjectKey(resolvedRequest.object_key);
     try {
-      const deleteResult = await requestStorageDelete(
-        parsed.storageObjectRequest,
-        options.proxyStorageOptions
-      );
+      const deleteResult = await requestStorageDelete(resolvedRequest, options.proxyStorageOptions);
       if (!deleteResult.success) {
         throw new Error("delete failed");
       }
     } catch {
+      await emitCloudEventBestEffort(
+        "delete.completed",
+        {
+          operation_id: operationId,
+          wallet_address: resolvedRequest.wallet_address,
+          object_key: resolvedRequest.object_key,
+          status: "failed"
+        },
+        objectLogHomeDir
+      );
       return {
         text: "Cannot delete file",
         isError: true
@@ -3629,16 +4578,58 @@ async function runCloudCommandHandler(ctx, options) {
     let cronEntry = null;
     let cronDeleted = false;
     try {
-      cronEntry = await findLoggedStoragePaymentCronByObjectKey(
-        parsed.storageObjectRequest.object_key,
-        objectLogHomeDir
-      );
-      cronDeleted = cronEntry ? await removeStoragePaymentCronJob(cronEntry.cronId, objectLogHomeDir) : false;
+      const dbCron = await datastore.findCronByObjectKey(resolvedRequest.object_key);
+      if (dbCron) {
+        cronEntry = {
+          cronId: dbCron.cronId,
+          objectId: dbCron.objectId,
+          objectKey: resolvedRequest.object_key
+        };
+      }
+      if (!cronEntry) {
+        cronEntry = await findLoggedStoragePaymentCronByObjectKey(
+          resolvedRequest.object_key,
+          objectLogHomeDir
+        );
+      }
+      if (cronEntry) {
+        const fileCronDeleted = await removeStoragePaymentCronJob(
+          cronEntry.cronId,
+          objectLogHomeDir
+        );
+        const dbCronDeleted = await datastore.removeCronJob(cronEntry.cronId);
+        cronDeleted = fileCronDeleted || dbCronDeleted;
+      }
     } catch {
     }
+    const objectId = cronEntry?.objectId ?? existingObjectByKey?.object_id ?? null;
+    if (objectId) {
+      const existingObject = existingObjectByKey?.object_id === objectId ? existingObjectByKey : await datastore.findObjectById(objectId);
+      await datastore.upsertObject({
+        object_id: objectId,
+        object_key: resolvedRequest.object_key,
+        wallet_address: existingObject?.wallet_address ?? resolvedRequest.wallet_address,
+        quote_id: existingObject?.quote_id ?? null,
+        provider: existingObject?.provider ?? null,
+        bucket_name: existingObject?.bucket_name ?? null,
+        region: resolvedRequest.location ?? existingObject?.region ?? null,
+        sha256: existingObject?.sha256 ?? null,
+        status: "deleted"
+      });
+    }
+    await emitCloudEventBestEffort(
+      "delete.completed",
+      {
+        operation_id: operationId,
+        wallet_address: resolvedRequest.wallet_address,
+        object_key: resolvedRequest.object_key,
+        status: "succeeded"
+      },
+      objectLogHomeDir
+    );
     return {
       text: formatStorageDeleteUserMessage(
-        parsed.storageObjectRequest.object_key,
+        resolvedRequest.object_key,
         cronEntry?.cronId ?? null,
         cronDeleted
       )
@@ -3652,11 +4643,11 @@ async function runCloudCommandHandler(ctx, options) {
 
 // src/cli.ts
 import { spawn as spawn2 } from "child_process";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { existsSync } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir7 } from "os";
 function isHexPrivateKey(value) {
   return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value.trim());
 }
@@ -3761,20 +4752,20 @@ function parseArgs(args) {
   return result;
 }
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname4(__filename2);
-var PACKAGE_ROOT = dirname4(__dirname2);
+var __dirname2 = dirname6(__filename2);
+var PACKAGE_ROOT = dirname6(__dirname2);
 async function ensureDir(path) {
-  await mkdir4(path, { recursive: true });
+  await mkdir6(path, { recursive: true });
 }
 async function deployExtensionFiles() {
-  const scriptsSource = join7(PACKAGE_ROOT, "scripts");
+  const scriptsSource = join9(PACKAGE_ROOT, "scripts");
   if (!existsSync(scriptsSource)) return;
-  const mnemoScriptsDir = join7(homedir5(), ".openclaw", "mnemospark", "scripts");
+  const mnemoScriptsDir = join9(homedir7(), ".openclaw", "mnemospark", "scripts");
   await ensureDir(mnemoScriptsDir);
-  const uninstallSrc = join7(scriptsSource, "uninstall.sh");
+  const uninstallSrc = join9(scriptsSource, "uninstall.sh");
   if (existsSync(uninstallSrc)) {
     const content = await readFile4(uninstallSrc);
-    await writeFile4(join7(mnemoScriptsDir, "uninstall.sh"), content, { mode: 493 });
+    await writeFile4(join9(mnemoScriptsDir, "uninstall.sh"), content, { mode: 493 });
   }
 }
 function isOpenClawAvailable() {
@@ -3788,8 +4779,8 @@ function isOpenClawAvailable() {
   });
 }
 function getOpenClawConfigPath() {
-  const stateDir = process.env.OPENCLAW_STATE_DIR ?? join7(homedir5(), ".openclaw");
-  return join7(stateDir, "openclaw.json");
+  const stateDir = process.env.OPENCLAW_STATE_DIR ?? join9(homedir7(), ".openclaw");
+  return join9(stateDir, "openclaw.json");
 }
 async function ensureMnemosparkInPluginsAllow() {
   const configPath = getOpenClawConfigPath();
@@ -3851,7 +4842,7 @@ async function readLegacyWalletIfPresent() {
   }
 }
 async function writeMnemosparkWallet(key) {
-  const dir = dirname4(WALLET_FILE);
+  const dir = dirname6(WALLET_FILE);
   await ensureDir(dir);
   await writeFile4(WALLET_FILE, `${key}
 `, { mode: 384 });