routstrd 0.4.0 → 0.4.1

package/dist/index.js

@@ -9914,6 +9914,17 @@ async function startDaemonUnlocked(options) {
     detached: true
   });
   proc.unref();
+  const killSpawnedDaemon = () => {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {}
+  };
+  const abandonOnSignal = () => {
+    killSpawnedDaemon();
+    process.exit(1);
+  };
+  process.once("SIGINT", abandonOnSignal);
+  process.once("SIGTERM", abandonOnSignal);
   let exitCode = null;
   proc.exited.then((code) => {
     exitCode = code;
@@ -9944,12 +9955,15 @@ Daemon output:
 ${daemonOutput}` : ` Check logs in ${LOGS_DIR2}`));
     }
     if (await healthyDaemonHost(port, host)) {
+      process.off("SIGINT", abandonOnSignal);
+      process.off("SIGTERM", abandonOnSignal);
       printStartupProgress(progressLogOffset);
       console.log(`Routstr daemon started (PID: ${proc.pid}, ${formatElapsed(Date.now() - startedAt)}).`);
       return;
     }
   }
-  throw new Error(`Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR2}`);
+  killSpawnedDaemon();
+  throw new Error(`Daemon did not become healthy within ${Math.round(startupTimeoutMs / 1000)} seconds; ` + `the incomplete daemon (PID ${proc.pid}) was stopped. Check logs in ${LOGS_DIR2}`);
 }
 async function startDaemon(options = {}) {
   const port = options.port || "8008";
@@ -21276,7 +21290,7 @@ function formatTime(timestamp) {
   const p = (n) => String(n).padStart(2, "0");
   return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
 }
-function formatNumber(n) {
+function formatNumber2(n) {
   if (n >= 1e6)
     return (n / 1e6).toFixed(1) + "M";
   if (n >= 1000)
@@ -21518,8 +21532,8 @@ function renderOverview(stats, balance, status, width) {
     `${COLORS.bold}Avg Cost/Req:${COLORS.reset} ${formatCost(avgCost)} sats`
   ];
   const rightBox = [
-    `${COLORS.bold}Total Tokens:${COLORS.reset} ${formatNumber(totals.totalTokens)}`,
-    `${COLORS.bold}Avg Tokens/Req:${COLORS.reset} ${formatNumber(Math.round(avgTokens))}`,
+    `${COLORS.bold}Total Tokens:${COLORS.reset} ${formatNumber2(totals.totalTokens)}`,
+    `${COLORS.bold}Avg Tokens/Req:${COLORS.reset} ${formatNumber2(Math.round(avgTokens))}`,
     `${COLORS.bold}Prompt/Comp:${COLORS.reset} ${(totals.promptTokens / Math.max(1, totals.completionTokens)).toFixed(2)}x`
   ];
   const halfWidth1 = Math.floor(width / 2);
@@ -21667,11 +21681,11 @@ function renderToday(stats, width) {
     `${COLORS.bold}Date:${COLORS.reset} ${todayStats.date}`,
     `${COLORS.bold}Requests:${COLORS.reset} ${formatReqs(todayStats.requests)}`,
     `${COLORS.bold}Cost:${COLORS.reset} ${COLORS.green}${formatCost(todayStats.satsCost)} sats${COLORS.reset}`,
-    `${COLORS.bold}Tokens:${COLORS.reset} ${formatNumber(todayStats.totalTokens)} (p: ${formatNumber(todayStats.promptTokens)} + c: ${formatNumber(todayStats.completionTokens)})`
+    `${COLORS.bold}Tokens:${COLORS.reset} ${formatNumber2(todayStats.totalTokens)} (p: ${formatNumber2(todayStats.promptTokens)} + c: ${formatNumber2(todayStats.completionTokens)})`
   ];
   let output = renderBox(summaryLines, width, "Today");
   if (recentDays.length > 0) {
-    const dayLines = recentDays.map((d) => `${d.date}: ${formatReqs(d.requests)} req, ${formatCost(d.satsCost)} sats, ${formatNumber(d.totalTokens)} tokens`);
+    const dayLines = recentDays.map((d) => `${d.date}: ${formatReqs(d.requests)} req, ${formatCost(d.satsCost)} sats, ${formatNumber2(d.totalTokens)} tokens`);
     output += `
 ` + renderBox(dayLines, width, "Recent Days");
   }
@@ -21713,7 +21727,7 @@ function renderModels(stats, width) {
     lines.push(`${color}${COLORS.bold}${model.modelId}${COLORS.reset}`);
     lines.push(`  ${COLORS.dim}Cost:${COLORS.reset} ${formatCost(model.satsCost)} sats (${pct}%)`);
     lines.push(`  ${COLORS.dim}Requests:${COLORS.reset} ${formatReqs(model.requests)}`);
-    lines.push(`  ${COLORS.dim}Tokens:${COLORS.reset} ${formatNumber(model.totalTokens)}`);
+    lines.push(`  ${COLORS.dim}Tokens:${COLORS.reset} ${formatNumber2(model.totalTokens)}`);
     lines.push(`  ${COLORS.dim}Avg:${COLORS.reset} ${formatCost(model.satsCost / model.requests)} sats/req`);
     lines.push(`  ${renderBarChart("  ", model.satsCost, maxCost, width - 6, color, Number(pct), "model-detail")}`);
     lines.push("");
@@ -21731,7 +21745,7 @@ function renderProviders(stats, width) {
     lines.push(`${COLORS.cyan}${COLORS.bold}${shortUrl}${COLORS.reset}`);
     lines.push(`  ${COLORS.dim}Requests:${COLORS.reset} ${formatReqs(provider.requests)}`);
     lines.push(`  ${COLORS.dim}Cost:${COLORS.reset} ${formatCost(provider.satsCost)} sats`);
-    lines.push(`  ${COLORS.dim}Tokens:${COLORS.reset} ${formatNumber(provider.totalTokens)}`);
+    lines.push(`  ${COLORS.dim}Tokens:${COLORS.reset} ${formatNumber2(provider.totalTokens)}`);
     lines.push("");
   }
   return renderBox(lines, width, "Provider Breakdown");
@@ -21740,9 +21754,9 @@ function renderTokens(stats, width) {
   const totals = stats.summary.totals;
   const modelStats = stats.summary.models;
   const summaryLines = [
-    `${COLORS.bold}Total Prompt Tokens:${COLORS.reset} ${formatNumber(totals.promptTokens)}`,
-    `${COLORS.bold}Total Completion Tokens:${COLORS.reset} ${formatNumber(totals.completionTokens)}`,
-    `${COLORS.bold}Total Tokens:${COLORS.reset} ${formatNumber(totals.totalTokens)}`,
+    `${COLORS.bold}Total Prompt Tokens:${COLORS.reset} ${formatNumber2(totals.promptTokens)}`,
+    `${COLORS.bold}Total Completion Tokens:${COLORS.reset} ${formatNumber2(totals.completionTokens)}`,
+    `${COLORS.bold}Total Tokens:${COLORS.reset} ${formatNumber2(totals.totalTokens)}`,
     `${COLORS.bold}Prompt/Completion Ratio:${COLORS.reset} ${(totals.promptTokens / Math.max(1, totals.completionTokens)).toFixed(2)}x`,
     `${COLORS.bold}Avg Tokens/Request:${COLORS.reset} ${(totals.totalTokens / Math.max(1, stats.totalEntries)).toFixed(0)}`
   ];
@@ -21751,7 +21765,7 @@ function renderTokens(stats, width) {
     const tokenLines = modelStats.slice(0, 6).map((m) => {
       const color = MODEL_COLORS[m.modelId] || MODEL_COLORS.default;
       const promptPct = m.totalTokens > 0 ? (m.promptTokens / m.totalTokens * 100).toFixed(0) : "0";
-      return `${color}${m.modelId.padEnd(15)}${COLORS.reset} ${formatNumber(m.totalTokens).padStart(8)} tokens (${promptPct}% prompt)`;
+      return `${color}${m.modelId.padEnd(15)}${COLORS.reset} ${formatNumber2(m.totalTokens).padStart(8)} tokens (${promptPct}% prompt)`;
     });
     output += `
 ` + renderBox(tokenLines, width, "Tokens by Model");
@@ -21787,7 +21801,7 @@ function renderClients(stats, width) {
     const dClient = client.client.slice(0, col1 - 1).padEnd(col1);
     const dReqs = formatReqs(client.requests).padEnd(col2);
     const dCost = `${formatCost(client.satsCost)} sats (${pct}%)`.padEnd(col3);
-    const dTok = formatNumber(client.totalTokens).padEnd(col4);
+    const dTok = formatNumber2(client.totalTokens).padEnd(col4);
     const dAvg = `${avgCostFormatted} sats/req`;
     lines.push(`${color}${COLORS.bold}${dClient}${COLORS.reset}` + `${dReqs}` + `${COLORS.green}${dCost}${COLORS.reset}` + `${COLORS.dim}${dTok}${dAvg}${COLORS.reset}`);
     lines.push(`  ${renderBarChart("", client.satsCost, maxCost, width - 6, color, Number(pct), "client-detail")}`);
@@ -21802,7 +21816,7 @@ function renderClients(stats, width) {
         continue;
       clientModelLines.push(`${COLORS.bold}${topClient.client}${COLORS.reset} (${formatReqs(topClient.requests)} reqs, ${formatCost(topClient.satsCost)} sats)`);
       for (const m of topClient.topModels) {
-        clientModelLines.push(`  ${MODEL_COLORS[m.modelId] || MODEL_COLORS.default}${m.modelId.padEnd(18)}${COLORS.reset} ${formatNumber(m.totalTokens).padEnd(8)} tokens  ${formatCost(m.satsCost)} sats`);
+        clientModelLines.push(`  ${MODEL_COLORS[m.modelId] || MODEL_COLORS.default}${m.modelId.padEnd(18)}${COLORS.reset} ${formatNumber2(m.totalTokens).padEnd(8)} tokens  ${formatCost(m.satsCost)} sats`);
       }
       clientModelLines.push("");
     }
@@ -21838,7 +21852,7 @@ function renderNpubs(stats, clients, width) {
     const dNpub = shortNpub.padEnd(col1);
     const dReqs = formatReqs(npub.requests).padEnd(col2);
     const dCost = `${formatCost(npub.satsCost)} sats (${pct}%)`.padEnd(col3);
-    const dTok = formatNumber(npub.totalTokens).padEnd(col4);
+    const dTok = formatNumber2(npub.totalTokens).padEnd(col4);
     const dAvg = `${avgCostFormatted} sats/req`;
     lines.push(`${COLORS.magenta}${COLORS.bold}${dNpub}${COLORS.reset}` + `${dReqs}` + `${COLORS.green}${dCost}${COLORS.reset}` + `${COLORS.dim}${dTok}${dAvg}${COLORS.reset}`);
     lines.push(`  ${COLORS.dim}${npub.npub}${COLORS.reset}`);
@@ -21854,7 +21868,7 @@ function renderNpubs(stats, clients, width) {
         continue;
       npubModelLines.push(`${COLORS.bold}${truncateNpub(topNpub.npub)}${COLORS.reset} (${formatReqs(topNpub.requests)} reqs, ${formatCost(topNpub.satsCost)} sats)`);
       for (const m of topNpub.topModels) {
-        npubModelLines.push(`  ${MODEL_COLORS[m.modelId] || MODEL_COLORS.default}${m.modelId.padEnd(18)}${COLORS.reset} ${formatNumber(m.totalTokens).padEnd(8)} tokens  ${formatCost(m.satsCost)} sats`);
+        npubModelLines.push(`  ${MODEL_COLORS[m.modelId] || MODEL_COLORS.default}${m.modelId.padEnd(18)}${COLORS.reset} ${formatNumber2(m.totalTokens).padEnd(8)} tokens  ${formatCost(m.satsCost)} sats`);
       }
       npubModelLines.push("");
     }
@@ -21890,7 +21904,7 @@ function renderRecent(stats, width) {
       entry.cacheReadInputTokens || 0,
       entry.cacheCreationInputTokens || 0,
       entry.completionTokens
-    ].map(formatNumber).join("/");
+    ].map(formatNumber2).join("/");
     const totalSats = typeof entry.totalMsats === "number" ? entry.totalMsats / 1000 : entry.satsCost;
     const cost = [
       formatCost(msatsToSats(entry.inputMsats)),
@@ -22898,9 +22912,9 @@ async function addClientAction(options) {
 // src/cli.ts
 init_config();
 init_logger();
-import { chmodSync as chmodSync2, existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync4, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
 import { execSync } from "child_process";
-import { dirname as dirname8, join as join7 } from "path";
+import { dirname as dirname8, join as join9 } from "path";
 
 // src/integrations/index.ts
 init_logger();
@@ -24255,6 +24269,11 @@ var STALE_SOCKET_ERROR_CODES = new Set([
   "ENOENT",
   "FailedToOpenSocket"
 ]);
+var RECOVERY_STALL_MARKERS = new Map([
+  ["SendOperationService\x00Could not reach mint for recovery, will retry later", "Send recovery: mint unreachable"],
+  ["ReceiveOperationService\x00Could not reach mint for receive recovery, will retry later", "Receive recovery: mint unreachable"],
+  ["MintOperationService\x00Failed to reconcile stale pending mint operation", "Mint recovery: pending operation check failed"]
+]);
 var SAFE_COCO_LOG_FIELDS = new Set([
   "module",
   "mintUrl",
@@ -24271,13 +24290,22 @@ var SAFE_COCO_LOG_FIELDS = new Set([
   "rollingBackOperations",
   "orphanedReservations"
 ]);
+function isZombieProcess(pid, readFile7 = (path) => readFileSync(path, "utf-8")) {
+  try {
+    const stat2 = readFile7(`/proc/${pid}/stat`);
+    const commandEnd = stat2.lastIndexOf(")");
+    return commandEnd >= 0 && stat2.charAt(commandEnd + 2) === "Z";
+  } catch {
+    return false;
+  }
+}
 function defaultIsProcessRunning(pid) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch (error) {
     return error.code === "EPERM";
   }
+  return !isZombieProcess(pid);
 }
 function hasErrorCode(error, codes) {
   let current = error;
@@ -24294,24 +24322,7 @@ function hasErrorCode(error, codes) {
 }
 async function assertLegacyCocodNotRunning(options = {}) {
   const socketPath = options.socketPath || legacyCocodSocketPath();
-  const pidFilePath = options.pidFilePath || legacyCocodPidPath();
   const pathExists = options.pathExists || existsSync9;
-  const readFile7 = options.readFile || ((path) => readFileSync(path, "utf-8"));
-  const isProcessRunning2 = options.isProcessRunning || defaultIsProcessRunning;
-  const getRunningLegacyPid = () => {
-    if (!pathExists(pidFilePath))
-      return null;
-    try {
-      const pid = Number.parseInt(readFile7(pidFilePath).trim(), 10);
-      return Number.isInteger(pid) && pid > 0 && pid !== options.ignorePid && isProcessRunning2(pid) ? pid : null;
-    } catch {
-      return null;
-    }
-  };
-  const runningPid = getRunningLegacyPid();
-  if (runningPid !== null) {
-    throw new Error(`Legacy cocod daemon is still running with PID ${runningPid}. ` + "Refusing to open the wallet database because cocod and coco-core cannot safely use it at the same time. " + `Run 'cocod stop' or 'kill ${runningPid}' and try again.`);
-  }
   if (!pathExists(socketPath))
     return;
   const fetchImpl = options.fetchImpl || fetch;
@@ -24324,12 +24335,8 @@ async function assertLegacyCocodNotRunning(options = {}) {
     await response.body?.cancel();
   } catch (error) {
     if (hasErrorCode(error, STALE_SOCKET_ERROR_CODES)) {
-      const newlyRunningPid = getRunningLegacyPid();
-      if (newlyRunningPid === null) {
-        logger.debug(`Ignoring stale legacy cocod socket at ${socketPath}`);
-        return;
-      }
-      throw new Error(`Legacy cocod daemon is still running with PID ${newlyRunningPid}. ` + "Refusing to open the wallet database because cocod and coco-core cannot safely use it at the same time. " + `Run 'cocod stop' or 'kill ${newlyRunningPid}' and try again.`, { cause: error });
+      logger.debug(`Ignoring stale legacy cocod socket at ${socketPath}`);
+      return;
     }
     throw new Error(`Cannot verify whether the legacy cocod daemon has stopped at ${socketPath}. ` + "Refusing to open the wallet database to prevent concurrent access. " + "Run 'cocod stop', verify the daemon has exited, and try again.", { cause: error });
   }
@@ -24393,12 +24400,14 @@ async function stopLegacyCocod(options = {}) {
 function claimLegacyCocodPidFile(options = {}) {
   return claimPidFile({
     ...options,
-    pidFilePath: options.pidFilePath || legacyCocodPidPath()
+    pidFilePath: options.pidFilePath || legacyCocodPidPath(),
+    label: options.label || "legacy cocod exclusion lock"
   });
 }
 function claimPidFile(options) {
   const pidFilePath = options.pidFilePath;
   const pid = options.pid ?? process.pid;
+  const label = options.label || "wallet process lock";
   const openExclusive = options.openExclusive || ((path) => openSync2(path, "wx", 384));
   const writePid = options.writePid || ((fd2, ownerPid) => writeFileSync(fd2, String(ownerPid)));
   const closeFile = options.closeFile || closeSync2;
@@ -24415,16 +24424,17 @@ function claimPidFile(options) {
     try {
       stalePid = Number.parseInt(readFile7(pidFilePath).trim(), 10);
     } catch {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error });
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error });
     }
     if (!Number.isInteger(stalePid) || stalePid <= 0 || isProcessRunning2(stalePid)) {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error });
+      const ownerMessage = Number.isInteger(stalePid) && stalePid > 0 ? `PID ${stalePid} is still running and holds it. ` + `Stop that process first ('routstrd stop' or 'kill ${stalePid}').` : "Another cocod or routstrd process may be starting. Stop it and try again.";
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}: ${ownerMessage}`, { cause: error });
     }
     try {
       removeFile(pidFilePath);
       fd = openExclusive(pidFilePath);
     } catch (retryError) {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: retryError });
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: retryError });
     }
   }
   try {
@@ -24438,36 +24448,48 @@ function claimPidFile(options) {
     closeFile(fd);
   }
   let released = false;
-  return () => {
+  const release = () => {
     if (released)
       return;
     released = true;
+    process.removeListener("exit", release);
     try {
       if (readFile7(pidFilePath).trim() === String(pid)) {
         removeFile(pidFilePath);
       }
     } catch (error) {
       if (error.code !== "ENOENT") {
-        logger.warn(`Failed to release wallet process lock at ${pidFilePath}:`, error);
+        logger.warn(`Failed to release ${label} at ${pidFilePath}:`, error);
       }
     }
   };
+  process.once("exit", release);
+  return release;
 }
 
 // src/daemon/wallet/migration.ts
 import {
   chmodSync,
   copyFileSync,
-  existsSync as existsSync10,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync2,
   renameSync as renameSync2,
   rmSync,
-  statSync
+  statSync as statSync3
 } from "fs";
+import { Database as Database2 } from "bun:sqlite";
+import { basename, dirname as dirname7, join as join8 } from "path";
+
+// src/daemon/wallet/diagnostics.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { Database } from "bun:sqlite";
-import { basename, dirname as dirname7, join as join6 } from "path";
-function state(configPath, dbPath) {
+import { join as join7 } from "path";
+
+// src/daemon/wallet/wallet-state.ts
+import { existsSync as existsSync10, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join6 } from "path";
+function walletState(configPath, dbPath) {
   const hasConfig = existsSync10(configPath);
   const hasDb = existsSync10(dbPath);
   if (hasConfig)
@@ -24483,9 +24505,36 @@ function filesEqual(left, right) {
     return false;
   return readFileSync2(left).equals(readFileSync2(right));
 }
-function sqlString(value) {
-  return `'${value.replaceAll("'", "''")}'`;
+function classifyWalletMigration(targetDir, sourceDir) {
+  const targetConfig = join6(targetDir, "config.json");
+  const targetDb = join6(targetDir, "coco.db");
+  const sourceConfig = join6(sourceDir, "config.json");
+  const sourceDb = join6(sourceDir, "coco.db");
+  const sourceWal = `${sourceDb}-wal`;
+  const sourceShm = `${sourceDb}-shm`;
+  const targetState = walletState(targetConfig, targetDb);
+  const sourceState = walletState(sourceConfig, sourceDb);
+  if (targetState === "initialized" && sourceState === "initialized") {
+    const configsMatch = filesEqual(targetConfig, sourceConfig);
+    const databasesMatch = !existsSync10(targetDb) && !existsSync10(sourceDb) ? true : filesEqual(targetDb, sourceDb);
+    if (configsMatch && databasesMatch)
+      return { kind: "already-current" };
+    return { kind: "conflict" };
+  }
+  if (targetState === "initialized")
+    return { kind: "already-current" };
+  if (!existsSync10(sourceDb) && (existsSync10(sourceWal) || existsSync10(sourceShm))) {
+    return { kind: "orphaned-sidecars" };
+  }
+  if (targetState === "database-only" || sourceState === "database-only") {
+    return { kind: "database-only", targetState, sourceState };
+  }
+  if (sourceState === "absent")
+    return { kind: "fresh" };
+  return { kind: "migrate" };
 }
+
+// src/daemon/wallet/diagnostics.ts
 var SUMMARY_QUERIES = {
   proofs: "SELECT mintUrl, state, COUNT(*) count, COALESCE(SUM(amount), 0) amount FROM coco_cashu_proofs GROUP BY mintUrl, state ORDER BY mintUrl, state",
   counters: "SELECT mintUrl, keysetId, counter FROM coco_cashu_counters ORDER BY mintUrl, keysetId",
@@ -24507,8 +24556,339 @@ function verifyDatabase(database, label) {
   }
   return summary;
 }
+function mnemonicFingerprint(mnemonic) {
+  const normalized = mnemonic.trim().split(/\s+/).join(" ");
+  const hex3 = createHash("sha256").update(normalized).digest("hex");
+  return hex3.slice(0, 16).match(/.{1,4}/g)?.join("-") ?? hex3.slice(0, 16);
+}
+function summarizeDbReadonly(dbPath) {
+  let database;
+  try {
+    database = new Database(dbPath, { readonly: true });
+    const raw = verifyDatabase(database, "Wallet database");
+    const proofs = raw.proofs ?? [];
+    const mints = raw.mints ?? [];
+    const amountByState = {};
+    let totalProofs = 0;
+    let totalAmount = 0;
+    for (const row of proofs) {
+      const count = typeof row.count === "number" ? row.count : 0;
+      const amount = typeof row.amount === "number" ? row.amount : 0;
+      totalProofs += count;
+      totalAmount += amount;
+      const state = row.state || "unknown";
+      amountByState[state] = (amountByState[state] ?? 0) + amount;
+    }
+    return {
+      summary: {
+        proofs,
+        mints,
+        totalProofs,
+        totalAmount,
+        amountByState,
+        distinctMints: new Set(proofs.map((row) => row.mintUrl).filter(Boolean)).size
+      }
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    database?.close();
+  }
+}
+function summarizeConfig(configPath) {
+  const result = { exists: false, path: configPath };
+  try {
+    if (!existsSync11(configPath))
+      return result;
+    result.exists = true;
+    result.mtimeMs = statSync2(configPath).mtimeMs;
+    const parsed = JSON.parse(readFileSync3(configPath, "utf-8"));
+    result.encrypted = parsed.encrypted === true;
+    if (typeof parsed.createdAt === "string")
+      result.createdAt = parsed.createdAt;
+    if (typeof parsed.version === "number")
+      result.version = parsed.version;
+    if (typeof parsed.defaultMintUrl === "string") {
+      result.defaultMintUrl = parsed.defaultMintUrl;
+    }
+    if (typeof parsed.mnemonic === "string") {
+      result.hasMnemonic = true;
+      if (!result.encrypted)
+        result.fingerprint = mnemonicFingerprint(parsed.mnemonic);
+    }
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+function summarizeDb(dbPath) {
+  const result = { exists: false, path: dbPath };
+  try {
+    if (!existsSync11(dbPath))
+      return result;
+    result.exists = true;
+    const stats = statSync2(dbPath);
+    result.mtimeMs = stats.mtimeMs;
+    result.sizeBytes = stats.size;
+    const { summary, error } = summarizeDbReadonly(dbPath);
+    if (summary)
+      result.summary = summary;
+    if (error)
+      result.error = error;
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+function summarizeWalletDirectory(dir, role) {
+  return {
+    dir,
+    role,
+    config: summarizeConfig(join7(dir, "config.json")),
+    db: summarizeDb(join7(dir, "coco.db"))
+  };
+}
+
+class WalletMigrationConflictError extends Error {
+  target;
+  source;
+  constructor(target, source) {
+    super(renderWalletConflict(target, source));
+    this.name = "WalletMigrationConflictError";
+    this.target = target;
+    this.source = source;
+  }
+}
+function timeAgo(ms) {
+  if (ms === undefined || !Number.isFinite(ms))
+    return;
+  const elapsed = Date.now() - ms;
+  if (elapsed < 0)
+    return;
+  const seconds = Math.floor(elapsed / 1000);
+  if (seconds < 5)
+    return "just now";
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 60)
+    return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months < 24)
+    return `${months}mo ago`;
+  return `${Math.floor(days / 365)}y ago`;
+}
+function modifiedDescription(config) {
+  if (config.createdAt)
+    return `created ${config.createdAt}`;
+  const ago = timeAgo(config.mtimeMs);
+  if (ago)
+    return `modified ${ago}`;
+  return "modified time unknown";
+}
+function roleLabel(role) {
+  return role === "canonical" ? "current routstrd wallet" : "legacy cocod wallet";
+}
+function configLine(config) {
+  if (!config.exists)
+    return "config.json  absent";
+  if (config.error)
+    return `config.json  present (unreadable: ${config.error})`;
+  const parts = ["config.json  present"];
+  if (config.fingerprint)
+    parts.push(`fingerprint ${config.fingerprint}`);
+  else if (config.encrypted)
+    parts.push("encrypted (mnemonic not readable)");
+  else
+    parts.push("no mnemonic found");
+  parts.push(modifiedDescription(config));
+  if (config.defaultMintUrl)
+    parts.push(`default mint ${config.defaultMintUrl}`);
+  return parts.join(" \xB7 ");
+}
+function formatNumber(value) {
+  return value.toLocaleString("en-US");
+}
+function amountByStateLine(summary) {
+  const parts = Object.entries(summary.amountByState).filter(([, amount]) => amount > 0);
+  if (parts.length === 0)
+    return "0 sats";
+  return parts.map(([state, amount]) => `${state}: ${formatNumber(amount)} sats`).join(", ");
+}
+function dbLine(db) {
+  if (!db.exists)
+    return "coco.db     absent";
+  if (db.error && !db.summary)
+    return `coco.db     present (unreadable: ${db.error})`;
+  const parts = ["coco.db     present"];
+  if (db.summary) {
+    const { totalProofs, mints, distinctMints } = db.summary;
+    const mintCount = mints.length > 0 ? mints.length : distinctMints;
+    parts.push(`${formatNumber(totalProofs)} proof${totalProofs === 1 ? "" : "s"}`);
+    parts.push(amountByStateLine(db.summary));
+    parts.push(`${mintCount} mint${mintCount === 1 ? "" : "s"}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function block(diag, letter) {
+  return [
+    `  ${letter}) ${diag.dir} (${roleLabel(diag.role)})`,
+    `     ${configLine(diag.config)}`,
+    `     ${dbLine(diag.db)}`
+  ].join(`
+`);
+}
+function moveAsideCommands(target, source) {
+  return [
+    "  \u2022 If B is your wallet (keep the legacy wallet):",
+    `      mv "${target.dir}" "${target.dir}.old"`,
+    "",
+    "  \u2022 If A is your wallet (keep the normal routstrd wallet):",
+    `      mv "${source.dir}" "${source.dir}.old"`
+  ].join(`
+`);
+}
+function renderResolutionSteps(target, source) {
+  return [
+    "To resolve, decide which wallet is yours, move the other one aside, and run",
+    "'routstrd onboard' (or 'routstrd start') again. Stop the daemon first:",
+    "",
+    "  routstrd stop",
+    "",
+    "Then:",
+    "",
+    moveAsideCommands(target, source)
+  ].join(`
+`);
+}
+function renderWalletConflict(target, source) {
+  return [
+    "Cannot migrate wallet: two different wallets were found, and routstrd will",
+    "not choose a mnemonic or merge databases automatically \u2014 the wrong choice",
+    "could lose access to your funds.",
+    "",
+    block(target, "A"),
+    block(source, "B"),
+    "",
+    "No files were changed.",
+    "",
+    renderResolutionSteps(target, source),
+    "",
+    "For a full comparison and safe cleanup, run: routstrd wallet doctor"
+  ].join(`
+`);
+}
+function conflictVerdict(target, source) {
+  const unreadable = !!target.config.error || !!source.config.error || !!target.db.error || !!source.db.error;
+  if (unreadable) {
+    return {
+      text: "Verdict: both wallets exist but one or both could not be fully read; startup will refuse to migrate. See the details above.",
+      showResolution: true,
+      conflict: true
+    };
+  }
+  if (target.config.fingerprint && source.config.fingerprint) {
+    if (target.config.fingerprint === source.config.fingerprint) {
+      return {
+        text: "Verdict: both wallets share the same mnemonic but the files differ, so startup still refuses. Keep the wallet with your funds and move the other aside.",
+        showResolution: true,
+        conflict: true
+      };
+    }
+    return {
+      text: "Verdict: the two wallets have DIFFERENT mnemonics. Startup will refuse to migrate.",
+      showResolution: true,
+      conflict: true
+    };
+  }
+  return {
+    text: "Verdict: both wallets exist but their mnemonics cannot be compared (encrypted or missing). Startup will refuse to migrate unless the files are identical.",
+    showResolution: true,
+    conflict: true
+  };
+}
+function verdictFromClassification(target, source, classification) {
+  switch (classification.kind) {
+    case "fresh":
+      return {
+        text: "Verdict: no wallet found in either location (fresh install).",
+        showResolution: false,
+        conflict: false
+      };
+    case "already-current":
+      return {
+        text: "Verdict: the current routstrd wallet is authoritative; no migration needed.",
+        showResolution: false,
+        conflict: false
+      };
+    case "migrate":
+      return {
+        text: "Verdict: only the legacy cocod wallet exists; it will be migrated on next startup.",
+        showResolution: false,
+        conflict: false
+      };
+    case "conflict":
+      return conflictVerdict(target, source);
+    case "database-only":
+      return {
+        text: "Verdict: a wallet is incomplete (coco.db without config.json). Startup will refuse to migrate. See the details above.",
+        showResolution: false,
+        conflict: true
+      };
+    case "orphaned-sidecars":
+      return {
+        text: "Verdict: the legacy wallet has SQLite sidecar files without coco.db. Startup will refuse to migrate. Restore the matching database first.",
+        showResolution: false,
+        conflict: true
+      };
+  }
+}
+function diagnoseWallets(target, source) {
+  let classification;
+  try {
+    classification = classifyWalletMigration(target.dir, source.dir);
+  } catch {
+    if (target.config.error || source.config.error || target.db.error || source.db.error) {
+      return conflictVerdict(target, source);
+    }
+    return {
+      text: "Verdict: the wallets could not be fully compared (read error); startup will refuse to migrate. See the details above.",
+      showResolution: true,
+      conflict: true
+    };
+  }
+  return verdictFromClassification(target, source, classification);
+}
+function renderWalletDoctor(target, source) {
+  const verdict = diagnoseWallets(target, source);
+  const lines = [
+    "Routstr wallet diagnostic",
+    "========================",
+    "",
+    block(target, "A"),
+    block(source, "B"),
+    "",
+    verdict.text
+  ];
+  if (verdict.showResolution) {
+    lines.push("", renderResolutionSteps(target, source));
+  }
+  return lines.join(`
+`);
+}
+
+// src/daemon/wallet/migration.ts
+function sqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
 function snapshotDatabase(sourcePath, destinationPath) {
-  const source = new Database(sourcePath);
+  const source = new Database2(sourcePath);
   let sourceSummary;
   try {
     sourceSummary = verifyDatabase(source, "Legacy wallet database");
@@ -24516,7 +24896,7 @@ function snapshotDatabase(sourcePath, destinationPath) {
   } finally {
     source.close();
   }
-  const destination = new Database(destinationPath, { readonly: true });
+  const destination = new Database2(destinationPath, { readonly: true });
   try {
     const destinationSummary = verifyDatabase(destination, "Staged wallet database");
     if (JSON.stringify(sourceSummary) !== JSON.stringify(destinationSummary)) {
@@ -24529,48 +24909,42 @@ function snapshotDatabase(sourcePath, destinationPath) {
 async function migrateLegacyWallet(options = {}) {
   const targetDir = options.walletDir || walletDir();
   const sourceDir = options.legacyDir || legacyCocodDir();
-  const targetConfig = join6(targetDir, "config.json");
-  const targetDb = join6(targetDir, "coco.db");
-  const sourceConfig = join6(sourceDir, "config.json");
-  const sourceDb = join6(sourceDir, "coco.db");
+  const sourceConfig = join8(sourceDir, "config.json");
+  const sourceDb = join8(sourceDir, "coco.db");
   const sourceWal = `${sourceDb}-wal`;
   const sourceShm = `${sourceDb}-shm`;
-  const targetState = state(targetConfig, targetDb);
-  const sourceState = state(sourceConfig, sourceDb);
-  if (targetState === "initialized" && sourceState === "initialized") {
-    const configsMatch = filesEqual(targetConfig, sourceConfig);
-    const databasesMatch = !existsSync10(targetDb) && !existsSync10(sourceDb) ? true : filesEqual(targetDb, sourceDb);
-    if (configsMatch && databasesMatch)
+  const classification = classifyWalletMigration(targetDir, sourceDir);
+  switch (classification.kind) {
+    case "fresh":
+      return { status: "fresh" };
+    case "already-current":
       return { status: "already-current" };
-    throw new Error(`Cannot migrate wallet: both ${targetDir} and ${sourceDir} contain different wallet data. ` + "Refusing to choose a mnemonic or merge wallet databases automatically.");
-  }
-  if (targetState === "initialized")
-    return { status: "already-current" };
-  if (!existsSync10(sourceDb) && (existsSync10(sourceWal) || existsSync10(sourceShm))) {
-    throw new Error(`Cannot migrate wallet: ${sourceDir} contains SQLite sidecar files without coco.db. ` + "Restore the matching main database before migration.");
-  }
-  if (targetState === "database-only" || sourceState === "database-only") {
-    throw new Error(`Cannot migrate wallet: ${targetDir} is ${targetState} and ${sourceDir} is ${sourceState}. ` + "A coco.db without config.json cannot be opened; restore the matching config first.");
+    case "migrate":
+      break;
+    case "conflict":
+      throw new WalletMigrationConflictError(summarizeWalletDirectory(targetDir, "canonical"), summarizeWalletDirectory(sourceDir, "legacy"));
+    case "orphaned-sidecars":
+      throw new Error(`Cannot migrate wallet: ${sourceDir} contains SQLite sidecar files without coco.db. ` + "Restore the matching main database before migration.");
+    case "database-only":
+      throw new Error(`Cannot migrate wallet: ${targetDir} is ${classification.targetState} and ${sourceDir} is ${classification.sourceState}. ` + "A coco.db without config.json cannot be opened; restore the matching config first.");
   }
-  if (sourceState === "absent")
-    return { status: "fresh" };
   await options.assertLegacyStopped?.();
   const releaseLegacyLock = await options.acquireLegacyLock?.();
-  const stagingDir = join6(dirname7(targetDir), `.${targetDir.split(/[\\/]/).at(-1) || "wallet"}.staging-${process.pid}-${Date.now()}`);
+  const stagingDir = join8(dirname7(targetDir), `.${targetDir.split(/[\\/]/).at(-1) || "wallet"}.staging-${process.pid}-${Date.now()}`);
   try {
     await options.assertLegacyStopped?.();
     mkdirSync8(dirname7(targetDir), { recursive: true, mode: 448 });
     mkdirSync8(stagingDir, { mode: 448 });
-    const stagedConfig = join6(stagingDir, "config.json");
-    const stagedDb = join6(stagingDir, "coco.db");
+    const stagedConfig = join8(stagingDir, "config.json");
+    const stagedDb = join8(stagingDir, "coco.db");
     copyFileSync(sourceConfig, stagedConfig);
     chmodSync(stagedConfig, 384);
-    const hasSourceDb = existsSync10(sourceDb);
+    const hasSourceDb = existsSync12(sourceDb);
     if (hasSourceDb) {
       snapshotDatabase(sourceDb, stagedDb);
       chmodSync(stagedDb, 384);
     }
-    if (statSync(stagedConfig).size !== statSync(sourceConfig).size) {
+    if (statSync3(stagedConfig).size !== statSync3(sourceConfig).size) {
       throw new Error("Cannot migrate wallet: staged config failed size validation.");
     }
     renameSync2(stagingDir, targetDir);
@@ -24581,13 +24955,13 @@ async function migrateLegacyWallet(options = {}) {
     releaseLegacyLock?.();
   }
   const cleanupWarnings = [];
-  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync10);
+  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync12);
   if (sourceFiles.length > 0) {
-    const archiveDir = join6(sourceDir, `wallet-migrated-${Date.now()}`);
+    const archiveDir = join8(sourceDir, `wallet-migrated-${Date.now()}`);
     try {
       mkdirSync8(archiveDir, { mode: 448 });
       for (const path of sourceFiles)
-        renameSync2(path, join6(archiveDir, basename(path)));
+        renameSync2(path, join8(archiveDir, basename(path)));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       cleanupWarnings.push(`Could not archive legacy wallet files: ${message}`);
@@ -26721,7 +27095,7 @@ zoo`.split(`
 // package.json
 var package_default = {
   name: "routstrd",
-  version: "0.4.0",
+  version: "0.4.1",
   module: "src/index.ts",
   type: "module",
   private: false,
@@ -26787,10 +27161,10 @@ Invoice:
 ${invoice}`);
 }
 function initializeWallet(walletDir2 = walletDir()) {
-  const walletConfig = join7(walletDir2, "config.json");
+  const walletConfig = join9(walletDir2, "config.json");
   mkdirSync9(walletDir2, { recursive: true, mode: 448 });
   chmodSync2(walletDir2, 448);
-  if (existsSync11(walletConfig)) {
+  if (existsSync13(walletConfig)) {
     chmodSync2(walletConfig, 384);
     console.log("Wallet already initialized.");
     return;
@@ -26830,7 +27204,7 @@ Restarting routstrd daemon...`);
         for (let i2 = 0;i2 < 100; i2++) {
           await new Promise((resolve) => setTimeout(resolve, 100));
           const healthDown = !await isDaemonRunning();
-          const pidFileReleased = !existsSync11(pidFilePath);
+          const pidFileReleased = !existsSync13(pidFilePath);
           if (healthDown && pidFileReleased)
             break;
         }
@@ -26873,11 +27247,11 @@ async function requireLocalDaemon() {
 }
 async function initDaemon() {
   console.log("Initializing routstrd...");
-  if (!existsSync11(CONFIG_DIR)) {
+  if (!existsSync13(CONFIG_DIR)) {
     mkdirSync9(CONFIG_DIR, { recursive: true });
     console.log(`Created config directory: ${CONFIG_DIR}`);
   }
-  if (!existsSync11(CONFIG_FILE)) {
+  if (!existsSync13(CONFIG_FILE)) {
     const config2 = {
       ...DEFAULT_CONFIG,
       cocodPath: null
@@ -26900,26 +27274,18 @@ A new Nostr identity has been generated for authentication.`);
   }
   console.log(`Database will be stored at: ${DB_PATH}`);
   await stopLegacyCocod();
-  let migrationLockOwner;
   const migration = await migrateLegacyWallet({
     assertLegacyStopped: () => assertLegacyCocodNotRunning({
-      socketPath: legacyCocodSocketPath(),
-      pidFilePath: legacyCocodPidPath(),
-      ignorePid: migrationLockOwner
+      socketPath: legacyCocodSocketPath()
     }),
     acquireLegacyLock: () => {
       mkdirSync9(dirname8(legacyCocodPidPath()), {
         recursive: true,
         mode: 448
       });
-      const release = claimLegacyCocodPidFile({
+      return claimLegacyCocodPidFile({
         pidFilePath: legacyCocodPidPath()
       });
-      migrationLockOwner = process.pid;
-      return () => {
-        migrationLockOwner = undefined;
-        release();
-      };
     }
   });
   if (migration.status === "migrated") {
@@ -26977,7 +27343,7 @@ program.command("update").description("Update routstrd to the latest version").a
 All packages are already up to date \u2014 nothing to do.`);
   }
 });
-program.command("refund").description("Refund pending tokens and API keys to a specified mint").option("-m, --mint-url <mintUrl>", "Mint URL to refund to (defaults to first mint in wallet)").option("-y, --yes", "Skip confirmation prompt", false).option("--xcashu", "Refund xcashu tokens only (uses refundXcashuTokens)", false).action(async (options) => {
+program.command("refund").description("Refund pending tokens and API keys to a specified mint").option("-m, --mint-url <mintUrl>", "Mint URL to refund to (defaults to active wallet mint)").option("-y, --yes", "Skip confirmation prompt", false).option("--xcashu", "Refund xcashu tokens only (uses refundXcashuTokens)", false).action(async (options) => {
   await ensureDaemonRunning();
   let mintUrl = options.mintUrl;
   if (!mintUrl) {
@@ -26986,12 +27352,12 @@ program.command("refund").description("Refund pending tokens and API keys to a s
       console.log(balanceResult.error);
       process.exit(1);
     }
-    const balances = balanceResult.output?.balances;
-    if (!balances || Object.keys(balances).length === 0) {
+    const output = balanceResult.output;
+    mintUrl = output?.activeMint ?? (output?.balances ? Object.keys(output.balances)[0] : undefined);
+    if (!mintUrl) {
       console.log("No mint URLs found in wallet balance");
       process.exit(1);
     }
-    mintUrl = Object.keys(balances)[0];
     console.log(`Using mint URL: ${mintUrl}`);
   }
   try {
@@ -27078,7 +27444,7 @@ program.command("remote [url]").description("Show the configured remote daemon,
       process.exit(1);
     }
   }
-  if (!existsSync11(CONFIG_DIR)) {
+  if (!existsSync13(CONFIG_DIR)) {
     mkdirSync9(CONFIG_DIR, { recursive: true });
   }
   const updates = { daemonUrl: url };
@@ -27133,17 +27499,30 @@ Use 'routstrd onboard' for first time using local mode or 'routstrd start' to st
 });
 program.command("onboard").description("Initialize routstrd (creates config directory and initializes wallet)").action(async () => {
   await requireLocalDaemon();
-  await initDaemon();
+  try {
+    await initDaemon();
+  } catch (error) {
+    if (error instanceof WalletMigrationConflictError) {
+      console.error(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
 });
 program.command("start").description("Start the background daemon").option("--port <port>", "Port to listen on").option("--host <host>", "Bind address (default: 127.0.0.1)").option("-p, --provider <provider>", "Default provider to use").action(async (options) => {
   await requireLocalDaemon();
   const config = await loadConfig();
   await stopLegacyCocod();
-  await startDaemon({
-    port: options.port || String(config.port || 8008),
-    host: options.host || config.host || undefined,
-    provider: options.provider
-  });
+  try {
+    await startDaemon({
+      port: options.port || String(config.port || 8008),
+      host: options.host || config.host || undefined,
+      provider: options.provider
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
 });
 program.command("status").description("Check daemon and wallet status").action(async () => {
   const running = await isDaemonRunning();
@@ -27169,7 +27548,7 @@ program.command("status").description("Check daemon and wallet status").action(a
     }
   }
 });
-program.command("balance").description("Get wallet and API key balances").option("--api-keys", "List all stored API keys (baseUrl + key + balance)", false).option("--delete-api-keys <baseUrl>", "Delete the API key stored for the given provider base URL (refunds balance first)").option("--mint-url <url>", "Mint URL to refund the deleted API key balance to (defaults to first mint in wallet)").action(async (options) => {
+program.command("balance").description("Get wallet and API key balances").option("--api-keys", "List all stored API keys (baseUrl + key + balance)", false).option("--delete-api-keys <baseUrl>", "Delete the API key stored for the given provider base URL (refunds balance first)").option("--mint-url <url>", "Mint URL to refund the deleted API key balance to (defaults to active wallet mint)").action(async (options) => {
   await ensureDaemonRunning();
   if (options.deleteApiKeys) {
     const baseUrl = options.deleteApiKeys;
@@ -27714,6 +28093,13 @@ var walletCmd = program.command("wallet").description("Wallet operations");
 walletCmd.command("status").description("Check wallet status").action(async () => {
   await handleDaemonCommand("/wallet/status");
 });
+walletCmd.command("doctor").description("Diagnose conflicting wallets (current routstrd wallet vs legacy cocod)").action(async () => {
+  const target = summarizeWalletDirectory(walletDir(), "canonical");
+  const source = summarizeWalletDirectory(legacyCocodDir(), "legacy");
+  console.log(renderWalletDoctor(target, source));
+  if (diagnoseWallets(target, source).conflict)
+    process.exit(1);
+});
 walletCmd.command("unlock <passphrase>").description("Unlock the wallet").action(async (passphrase) => {
   await handleDaemonCommand("/wallet/unlock", {
     method: "POST",
@@ -27723,6 +28109,68 @@ walletCmd.command("unlock <passphrase>").description("Unlock the wallet").action
 walletCmd.command("balance").description("Get wallet balance").action(async () => {
   await handleDaemonCommand("/wallet/balance");
 });
+walletCmd.command("cleanup").description("Clear stuck pending/in-flight wallet operations").option("--mint-url <url>", "Only clean up operations for this mint URL").option("--min-age <hours>", "Minimum age for reclaiming sends/cancelling melts, in hours (default: 168, one week; expired mint quotes are always failed)", "168").option("--dry-run", "Report what would be cleaned without applying changes", false).option("-y, --yes", "Skip confirmation prompt", false).action(async (options) => {
+  const minAgeHours = Number.parseFloat(options.minAge);
+  if (!Number.isFinite(minAgeHours) || minAgeHours < 0) {
+    console.error(`Invalid --min-age value: ${options.minAge}`);
+    process.exit(1);
+  }
+  if (!options.dryRun && !options.yes) {
+    const rl = __require("readline").createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question("This will fail expired mint quotes, reclaim old pending sends, and cancel prepared melts. Continue? [y/N] ", (value) => {
+        rl.close();
+        resolve(value.trim().toLowerCase());
+      });
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  try {
+    await ensureDaemonRunning();
+    const result = await callDaemon("/wallet/cleanup", {
+      method: "POST",
+      body: {
+        mintUrl: options.mintUrl,
+        minAgeMs: Math.round(minAgeHours * 60 * 60 * 1000),
+        dryRun: options.dryRun === true
+      }
+    });
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+    const output = result.output;
+    if (output) {
+      const prefix = output.dryRun ? "Would clean up:" : "Cleaned up:";
+      console.log(prefix);
+      console.log(`  Expired mint quotes failed: ${output.failedMintQuotes ?? 0}`);
+      console.log(`  Pending sends reclaimed: ${output.reclaimedSends ?? 0}`);
+      console.log(`  Prepared melts cancelled: ${output.cancelledMelts ?? 0}`);
+      console.log(`  Skipped (still recent or already terminal): ${output.skipped ?? 0}`);
+      if (output.errors && output.errors.length > 0) {
+        console.log(`
+Errors:`);
+        for (const e of output.errors) {
+          console.log(`  - ${e.operationId}: ${e.error}`);
+        }
+      }
+    }
+  } catch (error) {
+    const message = error.message;
+    if (message?.includes("fetch failed") || message?.includes("Connection refused")) {
+      console.error("Daemon is not running");
+      process.exit(1);
+    }
+    console.error(message);
+    process.exit(1);
+  }
+});
 var walletReceiveCmd = walletCmd.command("receive").description("Wallet receive operations");
 walletReceiveCmd.command("cashu <token>").description("Receive a Cashu token").action(async (token) => {
   await handleDaemonCommand("/wallet/receive/cashu", {
@@ -27890,7 +28338,7 @@ serviceCmd.command("install").description("Install and start routstrd using PM2
     const path = __require("path");
     daemonPath = path.join(path.dirname(import.meta.url).replace("file://", ""), "daemon", "index.js");
   }
-  if (!existsSync11(daemonPath)) {
+  if (!existsSync13(daemonPath)) {
     console.error(`Could not find daemon at ${daemonPath}. Did you run 'bun run build'?`);
     process.exit(1);
   }
@@ -27938,7 +28386,7 @@ program.command("restart").description("Restart the background daemon").option("
     for (let i2 = 0;i2 < 100; i2++) {
       await new Promise((resolve) => setTimeout(resolve, 100));
       const healthDown = !await isDaemonRunning();
-      const pidFileReleased = !existsSync11(pidFilePath);
+      const pidFileReleased = !existsSync13(pidFilePath);
       if (healthDown && pidFileReleased) {
         break;
       }
@@ -28029,7 +28477,7 @@ function getLogFileForDate2(logsDir, date = new Date) {
   return `${logsDir}/${year}-${month}-${day}.log`;
 }
 function readLastLines(file, lines) {
-  const content = readFileSync3(file, "utf8");
+  const content = readFileSync4(file, "utf8");
   const allLines = content.replace(/\r\n/g, `
 `).split(`
 `);
@@ -28043,13 +28491,13 @@ async function followLogFile(file, lines) {
   if (initial) {
     console.log(initial);
   }
-  let position = statSync2(file).size;
+  let position = statSync4(file).size;
   while (true) {
     await new Promise((resolve) => setTimeout(resolve, 1000));
-    if (!existsSync11(file)) {
+    if (!existsSync13(file)) {
       continue;
     }
-    const size = statSync2(file).size;
+    const size = statSync4(file).size;
     if (size < position) {
       position = 0;
     }
@@ -28068,17 +28516,17 @@ program.command("logs").description("View daemon logs").option("-f, --follow", "
   const yesterday = new Date;
   yesterday.setDate(yesterday.getDate() - 1);
   const yesterdayFile = getLogFileForDate2(logsDir, yesterday);
-  if (!existsSync11(todayFile) && !existsSync11(yesterdayFile)) {
+  if (!existsSync13(todayFile) && !existsSync13(yesterdayFile)) {
     console.log("No log files found. Daemon may not have started yet.");
     console.log(`Logs directory: ${logsDir}`);
     process.exit(1);
   }
   const lines = parseInt(options.lines, 10);
   const logFiles = [yesterdayFile, todayFile].filter((file, index, files) => {
-    return existsSync11(file) && files.indexOf(file) === index;
+    return existsSync13(file) && files.indexOf(file) === index;
   });
   if (options.follow) {
-    if (existsSync11(todayFile)) {
+    if (existsSync13(todayFile)) {
       await followLogFile(todayFile, lines);
     } else {
       console.log("No log file for today to follow.");