routstrd 0.4.0 → 0.4.2

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";
@@ -21220,7 +21234,10 @@ var init_constants = __esm(() => {
 // src/tui/usage/data.ts
 async function fetchStatus() {
   try {
-    const result = await callDaemon("/status");
+    const [result, config] = await Promise.all([
+      callDaemon("/status"),
+      loadConfig()
+    ]);
     if (result.error)
       return null;
     const output = result.output;
@@ -21228,6 +21245,7 @@ async function fetchStatus() {
       daemon: output?.daemon || "unknown",
       wallet: output?.wallet || "unknown",
       mode: output?.mode || "apikeys",
+      url: getDaemonBaseUrl(config),
       error: output?.error
     };
   } catch {
@@ -21276,7 +21294,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 +21536,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);
@@ -21545,6 +21563,12 @@ function renderOverview(stats, balance, status, width) {
     const walletColor = status.wallet === "connected" ? COLORS.green : COLORS.red;
     const modeColor = COLORS.cyan;
     statusLines.push(`${COLORS.bold}Daemon:${COLORS.reset} ${daemonColor}${status.daemon}${COLORS.reset}`);
+    if (status.url) {
+      const label = "Running on: ";
+      const maxUrlLen = Math.max(8, halfWidth2 - 4 - label.length);
+      const url = status.url.length > maxUrlLen ? `${status.url.slice(0, Math.max(0, maxUrlLen - 1))}\u2026` : status.url;
+      statusLines.push(`${COLORS.bold}${label}${COLORS.reset} ${COLORS.cyan}${url}${COLORS.reset}`);
+    }
     statusLines.push(`${COLORS.bold}Wallet:${COLORS.reset} ${walletColor}${status.wallet}${COLORS.reset}`);
     statusLines.push(`${COLORS.bold}Mode:${COLORS.reset} ${modeColor}${status.mode}${COLORS.reset}`);
     if (status.error) {
@@ -21667,11 +21691,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 +21737,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 +21755,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 +21764,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 +21775,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 +21811,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 +21826,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 +21862,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 +21878,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 +21914,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)),
@@ -22262,6 +22286,53 @@ var {
 
 // src/cli.ts
 init_start_daemon();
+
+// src/daemon/config-store.ts
+init_config();
+init_logger();
+import {
+  chmodSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+var REQUESTS_DIR = `${CONFIG_DIR}/requests`;
+function chmodIgnoreErrors(path, mode) {
+  try {
+    chmodSync(path, mode);
+  } catch {}
+}
+function ensureDirsSync() {
+  try {
+    mkdirSync2(CONFIG_DIR, { recursive: true, mode: 448 });
+  } catch {}
+  chmodSync(CONFIG_DIR, 448);
+  try {
+    mkdirSync2(REQUESTS_DIR, { recursive: true, mode: 448 });
+  } catch {}
+  chmodSync(REQUESTS_DIR, 448);
+}
+function saveDaemonConfig(config) {
+  ensureDirsSync();
+  const temporaryFile = `${CONFIG_FILE}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temporaryFile, JSON.stringify(config, null, 2), {
+      mode: 384
+    });
+    renameSync(temporaryFile, CONFIG_FILE);
+  } catch (error) {
+    try {
+      unlinkSync(temporaryFile);
+    } catch {}
+    throw error;
+  }
+  chmodIgnoreErrors(CONFIG_FILE, 384);
+}
+
+// src/cli.ts
 init_daemon_client();
 
 // src/utils/clients.ts
@@ -22273,7 +22344,7 @@ import { join as join3 } from "path";
 
 // src/integrations/opencode.ts
 init_daemon_client();
-import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
 var OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
@@ -22285,7 +22356,7 @@ Installing routstr models in opencode.json...`);
   const baseUrl = getDaemonBaseUrl(config);
   let opencodeConfig;
   try {
-    if (existsSync4(configPath)) {
+    if (existsSync5(configPath)) {
       const content = await readFile2(configPath, "utf-8");
       opencodeConfig = JSON.parse(content);
     } else {
@@ -22299,7 +22370,7 @@ Installing routstr models in opencode.json...`);
     opencodeConfig.provider = {};
   }
   try {
-    mkdirSync2(dirname2(configPath), { recursive: true });
+    mkdirSync3(dirname2(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -22330,7 +22401,7 @@ Installing routstr models in opencode.json...`);
 
 // src/integrations/pi.ts
 init_daemon_client();
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname3 } from "path";
 async function installPiIntegration(config, apiKey, integrationConfig) {
@@ -22341,7 +22412,7 @@ Installing routstr models in pi models.json...`);
   const baseUrl = `${getDaemonBaseUrl(config)}/v1`;
   let piConfig = {};
   try {
-    if (existsSync5(configPath)) {
+    if (existsSync6(configPath)) {
       const content = await readFile3(configPath, "utf-8");
       piConfig = JSON.parse(content);
     }
@@ -22353,21 +22424,25 @@ Installing routstr models in pi models.json...`);
     piConfig.providers = {};
   }
   try {
-    mkdirSync3(dirname3(configPath), { recursive: true });
+    mkdirSync4(dirname3(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
       console.log("No models found from routstr daemon.");
       return;
     }
+    const existingModels = new Map((piConfig.providers["routstr"]?.models ?? []).map((m) => [m.id, m]));
     const providerModels = models.map((model) => {
-      const entry = { id: model.id };
+      const previous = existingModels.get(model.id);
+      const entry = previous ? { ...previous } : { id: model.id };
+      entry.id = model.id;
       if (model.context_length !== undefined && model.context_length > 0) {
         entry.contextWindow = model.context_length;
       }
       return entry;
     });
     piConfig.providers["routstr"] = {
+      ...piConfig.providers["routstr"] ?? {},
       baseUrl,
       api: "openai-completions",
       apiKey,
@@ -22382,7 +22457,7 @@ Installing routstr models in pi models.json...`);
 
 // src/integrations/openclaw.ts
 init_daemon_client();
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
 import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 var OPENCLAW_PROVIDER_ID = "routstr";
@@ -22396,7 +22471,7 @@ Installing routstr models in openclaw.json...`);
   const baseUrl = getDaemonBaseUrl(config);
   let openclawConfig = {};
   try {
-    if (existsSync6(configPath)) {
+    if (existsSync7(configPath)) {
       const content = await readFile4(configPath, "utf-8");
       openclawConfig = JSON.parse(content);
     }
@@ -22417,7 +22492,7 @@ Installing routstr models in openclaw.json...`);
     openclawConfig.agents.defaults = {};
   }
   try {
-    mkdirSync4(dirname4(configPath), { recursive: true });
+    mkdirSync5(dirname4(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -22458,7 +22533,7 @@ Installing routstr models in openclaw.json...`);
 
 // src/integrations/claudecode.ts
 init_daemon_client();
-import { existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
 import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 async function installClaudeCodeIntegration(config, apiKey, integrationConfig) {
@@ -22469,7 +22544,7 @@ Installing routstr configuration in ${configPath}...`);
   const baseUrl = getDaemonBaseUrl(config);
   let settings = {};
   try {
-    if (existsSync7(configPath)) {
+    if (existsSync8(configPath)) {
       const content = await readFile5(configPath, "utf-8");
       settings = JSON.parse(content);
     }
@@ -22506,7 +22581,7 @@ Installing routstr configuration in ${configPath}...`);
     console.error("Failed to fetch models for Claude Code integration:", error);
   }
   try {
-    mkdirSync5(dirname5(configPath), { recursive: true });
+    mkdirSync6(dirname5(configPath), { recursive: true });
     await writeFile5(configPath, JSON.stringify(settings, null, 2));
     console.log(`Successfully updated ${configPath} with routstr settings.`);
   } catch (error) {
@@ -22515,7 +22590,7 @@ Installing routstr configuration in ${configPath}...`);
 }
 
 // src/integrations/hermes.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7 } from "fs";
 import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname6 } from "path";
 
@@ -22638,7 +22713,7 @@ Installing routstr configuration in ${configPath}...`);
   }
   let content = "";
   try {
-    if (existsSync8(configPath)) {
+    if (existsSync9(configPath)) {
       content = await readFile6(configPath, "utf-8");
     }
   } catch (error) {
@@ -22661,7 +22736,7 @@ Installing routstr configuration in ${configPath}...`);
       console.log(`${configPath} already contains current routstr settings.`);
       return;
     }
-    mkdirSync6(dirname6(configPath), { recursive: true });
+    mkdirSync7(dirname6(configPath), { recursive: true });
     await writeFile6(configPath, newContent);
     console.log(`Successfully updated ${configPath} with routstr settings.`);
   } catch (error) {
@@ -22898,9 +22973,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 chmodSync3, existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync5, statSync as statSync4, writeFileSync as writeFileSync3 } 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();
@@ -24180,13 +24255,13 @@ k("Cashu_P2BK_v1");
 // src/daemon/wallet/coco-client.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync7,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync8,
   openSync as openSync2,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
 } from "fs";
 
 // node_modules/@scure/bip39/index.js
@@ -24255,6 +24330,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 +24351,22 @@ var SAFE_COCO_LOG_FIELDS = new Set([
   "rollingBackOperations",
   "orphanedReservations"
 ]);
+function isZombieProcess(pid, readFile7 = (path) => readFileSync2(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 +24383,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.`);
-  }
+  const pathExists = options.pathExists || existsSync10;
   if (!pathExists(socketPath))
     return;
   const fetchImpl = options.fetchImpl || fetch;
@@ -24324,12 +24396,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 });
   }
@@ -24338,8 +24406,8 @@ async function assertLegacyCocodNotRunning(options = {}) {
 async function stopLegacyCocod(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 pathExists = options.pathExists || existsSync10;
+  const readFile7 = options.readFile || ((path) => readFileSync2(path, "utf-8"));
   const isProcessRunning2 = options.isProcessRunning || defaultIsProcessRunning;
   const fetchImpl = options.fetchImpl || fetch;
   const killProcess = options.killProcess || ((pid2, signal) => process.kill(pid2, signal));
@@ -24393,17 +24461,19 @@ 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 writePid = options.writePid || ((fd2, ownerPid) => writeFileSync2(fd2, String(ownerPid)));
   const closeFile = options.closeFile || closeSync2;
-  const readFile7 = options.readFile || ((path) => readFileSync(path, "utf-8"));
-  const removeFile = options.removeFile || unlinkSync;
+  const readFile7 = options.readFile || ((path) => readFileSync2(path, "utf-8"));
+  const removeFile = options.removeFile || unlinkSync2;
   const isProcessRunning2 = options.isProcessRunning || defaultIsProcessRunning;
   let fd;
   try {
@@ -24415,16 +24485,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,38 +24509,50 @@ 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,
+  chmodSync as chmodSync2,
   copyFileSync,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync2,
-  renameSync as renameSync2,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync9,
+  renameSync as renameSync3,
   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 existsSync12, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { Database } from "bun:sqlite";
-import { basename, dirname as dirname7, join as join6 } from "path";
-function state(configPath, dbPath) {
-  const hasConfig = existsSync10(configPath);
-  const hasDb = existsSync10(dbPath);
+import { join as join7 } from "path";
+
+// src/daemon/wallet/wallet-state.ts
+import { existsSync as existsSync11, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join6 } from "path";
+function walletState(configPath, dbPath) {
+  const hasConfig = existsSync11(configPath);
+  const hasDb = existsSync11(dbPath);
   if (hasConfig)
     return "initialized";
   if (hasDb)
@@ -24477,15 +24560,42 @@ function state(configPath, dbPath) {
   return "absent";
 }
 function filesEqual(left, right) {
-  if (!existsSync10(left) || !existsSync10(right))
+  if (!existsSync11(left) || !existsSync11(right))
     return false;
   if (statSync(left).size !== statSync(right).size)
     return false;
-  return readFileSync2(left).equals(readFileSync2(right));
+  return readFileSync3(left).equals(readFileSync3(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 = !existsSync11(targetDb) && !existsSync11(sourceDb) ? true : filesEqual(targetDb, sourceDb);
+    if (configsMatch && databasesMatch)
+      return { kind: "already-current" };
+    return { kind: "conflict" };
+  }
+  if (targetState === "initialized")
+    return { kind: "already-current" };
+  if (!existsSync11(sourceDb) && (existsSync11(sourceWal) || existsSync11(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 +24617,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 (!existsSync12(configPath))
+      return result;
+    result.exists = true;
+    result.mtimeMs = statSync2(configPath).mtimeMs;
+    const parsed = JSON.parse(readFileSync4(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 (!existsSync12(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 +24957,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,51 +24970,45 @@ 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");
+    mkdirSync9(dirname7(targetDir), { recursive: true, mode: 448 });
+    mkdirSync9(stagingDir, { mode: 448 });
+    const stagedConfig = join8(stagingDir, "config.json");
+    const stagedDb = join8(stagingDir, "coco.db");
     copyFileSync(sourceConfig, stagedConfig);
-    chmodSync(stagedConfig, 384);
-    const hasSourceDb = existsSync10(sourceDb);
+    chmodSync2(stagedConfig, 384);
+    const hasSourceDb = existsSync13(sourceDb);
     if (hasSourceDb) {
       snapshotDatabase(sourceDb, stagedDb);
-      chmodSync(stagedDb, 384);
+      chmodSync2(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);
+    renameSync3(stagingDir, targetDir);
   } catch (error) {
     rmSync(stagingDir, { recursive: true, force: true });
     throw error;
@@ -24581,13 +25016,13 @@ async function migrateLegacyWallet(options = {}) {
     releaseLegacyLock?.();
   }
   const cleanupWarnings = [];
-  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync10);
+  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync13);
   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 });
+      mkdirSync9(archiveDir, { mode: 448 });
       for (const path of sourceFiles)
-        renameSync2(path, join6(archiveDir, basename(path)));
+        renameSync3(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 +27156,7 @@ zoo`.split(`
 // package.json
 var package_default = {
   name: "routstrd",
-  version: "0.4.0",
+  version: "0.4.2",
   module: "src/index.ts",
   type: "module",
   private: false,
@@ -26747,7 +27182,7 @@ var package_default = {
     "@cashu/cashu-ts": "^4.3.0",
     "@cashu/coco-core": "^1.0.1",
     "@cashu/coco-sqlite-bun": "^1.0.1",
-    "@routstr/sdk": "^0.4.0",
+    "@routstr/sdk": "^0.4.1",
     "@scure/bip39": "^2.2.0",
     "applesauce-core": "^5.1.0",
     "applesauce-relay": "^5.1.0",
@@ -26787,11 +27222,11 @@ Invoice:
 ${invoice}`);
 }
 function initializeWallet(walletDir2 = walletDir()) {
-  const walletConfig = join7(walletDir2, "config.json");
-  mkdirSync9(walletDir2, { recursive: true, mode: 448 });
-  chmodSync2(walletDir2, 448);
-  if (existsSync11(walletConfig)) {
-    chmodSync2(walletConfig, 384);
+  const walletConfig = join9(walletDir2, "config.json");
+  mkdirSync10(walletDir2, { recursive: true, mode: 448 });
+  chmodSync3(walletDir2, 448);
+  if (existsSync14(walletConfig)) {
+    chmodSync3(walletConfig, 384);
     console.log("Wallet already initialized.");
     return;
   }
@@ -26802,7 +27237,7 @@ function initializeWallet(walletDir2 = walletDir()) {
     encrypted: false,
     createdAt: new Date().toISOString()
   };
-  writeFileSync2(walletConfig, JSON.stringify(config, null, 2), {
+  writeFileSync3(walletConfig, JSON.stringify(config, null, 2), {
     mode: 384,
     flag: "wx"
   });
@@ -26830,7 +27265,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 = !existsSync14(pidFilePath);
           if (healthDown && pidFileReleased)
             break;
         }
@@ -26873,16 +27308,16 @@ async function requireLocalDaemon() {
 }
 async function initDaemon() {
   console.log("Initializing routstrd...");
-  if (!existsSync11(CONFIG_DIR)) {
-    mkdirSync9(CONFIG_DIR, { recursive: true });
+  if (!existsSync14(CONFIG_DIR)) {
     console.log(`Created config directory: ${CONFIG_DIR}`);
   }
-  if (!existsSync11(CONFIG_FILE)) {
+  ensureDirsSync();
+  if (!existsSync14(CONFIG_FILE)) {
     const config2 = {
       ...DEFAULT_CONFIG,
       cocodPath: null
     };
-    await Bun.write(CONFIG_FILE, JSON.stringify(config2, null, 2));
+    saveDaemonConfig(config2);
     console.log(`Created config file: ${CONFIG_FILE}`);
   }
   const config = await loadConfig();
@@ -26891,7 +27326,7 @@ async function initDaemon() {
     const nsec = nip19_exports.nsecEncode(secretKey);
     const npub = npubFromSecretKey(secretKey);
     config.nsec = nsec;
-    await Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
+    saveDaemonConfig(config);
     console.log(`
 A new Nostr identity has been generated for authentication.`);
     console.log(`Your npub: ${npub}`);
@@ -26900,26 +27335,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()), {
+      mkdirSync10(dirname8(legacyCocodPidPath()), {
         recursive: true,
         mode: 448
       });
-      const release = claimLegacyCocodPidFile({
+      return claimLegacyCocodPidFile({
         pidFilePath: legacyCocodPidPath()
       });
-      migrationLockOwner = process.pid;
-      return () => {
-        migrationLockOwner = undefined;
-        release();
-      };
     }
   });
   if (migration.status === "migrated") {
@@ -26941,10 +27368,7 @@ To ensure routstrd persists across system restarts, run: 'routstrd service insta
 }
 program.name("routstrd").description("Routstr daemon - Manage routstr processes").version(package_default.version, "--version", "output the version number");
 program.command("update").description("Update routstrd to the latest version").action(async () => {
-  const packages = [
-    { name: "routstrd", label: "routstrd" },
-    { name: "@routstr/cocod", label: "cocod" }
-  ];
+  const packages = [{ name: "routstrd", label: "routstrd" }];
   let updatedAny = false;
   for (const { name, label } of packages) {
     const installed = await getGlobalPackageVersion(name);
@@ -26977,7 +27401,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 +27410,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,8 +27502,8 @@ program.command("remote [url]").description("Show the configured remote daemon,
       process.exit(1);
     }
   }
-  if (!existsSync11(CONFIG_DIR)) {
-    mkdirSync9(CONFIG_DIR, { recursive: true });
+  if (!existsSync14(CONFIG_DIR)) {
+    mkdirSync10(CONFIG_DIR, { recursive: true });
   }
   const updates = { daemonUrl: url };
   if (options.authUrl) {
@@ -27097,7 +27521,7 @@ program.command("remote [url]").description("Show the configured remote daemon,
     ...config,
     ...updates
   };
-  await Bun.write(CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
+  saveDaemonConfig(updatedConfig);
   console.log(`Remote daemon URL set to: ${url}`);
   if (options.authUrl) {
     console.log(`Auth proxy URL set to: ${options.authUrl}`);
@@ -27119,7 +27543,7 @@ program.command("local").description("Switch back to local daemon mode (removes
   const previousAuthUrl = config.authUrl;
   const { daemonUrl: _daemonUrl, authUrl: _authUrl, ...rest } = config;
   const updatedConfig = rest;
-  await Bun.write(CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
+  saveDaemonConfig(updatedConfig);
   console.log("Switched back to local daemon mode.");
   if (previousDaemonUrl) {
     console.log(`  Removed remote daemon URL: ${previousDaemonUrl}`);
@@ -27133,17 +27557,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 +27606,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;
@@ -27437,6 +27874,46 @@ providersCmd.command("enable <indices...>").description("Enable providers by the
     }
   }
 });
+providersCmd.command("reviews").description("Show all known providers with their stored review events and event IDs").action(async () => {
+  await ensureDaemonRunning();
+  const result = await callDaemon("/providers/reviews");
+  if (result.error) {
+    console.log(result.error);
+    process.exit(1);
+  }
+  const output = result.output;
+  if (!output) {
+    console.log("No provider review data available.");
+    return;
+  }
+  console.log(`Providers (${output.totalCount} total, ${output.reviewEventCount} stored review events):
+`);
+  for (const provider of output.providers) {
+    const status = provider.disabled ? "DISABLED" : "enabled ";
+    console.log(`  [${provider.index}] ${status}  ${provider.baseUrl}  (${provider.reviewCount} review${provider.reviewCount === 1 ? "" : "s"})`);
+    if (provider.nodePubkeys.length > 0) {
+      console.log(`      node pubkeys: ${provider.nodePubkeys.join(", ")}`);
+    }
+    for (const review of provider.reviews) {
+      const label = review.label || "review";
+      const created = new Date(review.createdAt * 1000).toISOString();
+      console.log(`      - ${label}  eventId: ${review.eventId}`);
+      console.log(`          node:   ${review.nodePubkey ?? "(none)"}`);
+      console.log(`          author: ${review.authorPubkey ?? "(none)"}`);
+      console.log(`          at:     ${created}`);
+    }
+  }
+  if (output.unmatchedReviews.length > 0) {
+    console.log(`
+  Unmatched review events (${output.unmatchedReviews.length} \u2014 node pubkey not in any known provider):`);
+    for (const review of output.unmatchedReviews) {
+      const created = new Date(review.createdAt * 1000).toISOString();
+      console.log(`      - eventId: ${review.eventId}`);
+      console.log(`          node:   ${review.nodePubkey ?? "(none)"}`);
+      console.log(`          at:     ${created}`);
+    }
+  }
+});
 var clientsCmd = program.command("clients").description("List and manage clients");
 clientsCmd.command("list").description("List all clients").action(async () => {
   await listClientsAction();
@@ -27714,6 +28191,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 +28207,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 +28436,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 (!existsSync14(daemonPath)) {
     console.error(`Could not find daemon at ${daemonPath}. Did you run 'bun run build'?`);
     process.exit(1);
   }
@@ -27938,7 +28484,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 = !existsSync14(pidFilePath);
       if (healthDown && pidFileReleased) {
         break;
       }
@@ -27996,7 +28542,7 @@ xcashu mode is coming soon! Only lazyrefund/apikeys is available at this time.`)
     ...config,
     mode: selectedMode
   };
-  await Bun.write(CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
+  saveDaemonConfig(updatedConfig);
   console.log(`Mode set to '${selectedMode}'. Restarting daemon...`);
   const wasRunning = await isDaemonRunning();
   if (wasRunning) {
@@ -28029,7 +28575,7 @@ function getLogFileForDate2(logsDir, date = new Date) {
   return `${logsDir}/${year}-${month}-${day}.log`;
 }
 function readLastLines(file, lines) {
-  const content = readFileSync3(file, "utf8");
+  const content = readFileSync5(file, "utf8");
   const allLines = content.replace(/\r\n/g, `
 `).split(`
 `);
@@ -28043,13 +28589,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 (!existsSync14(file)) {
       continue;
     }
-    const size = statSync2(file).size;
+    const size = statSync4(file).size;
     if (size < position) {
       position = 0;
     }
@@ -28068,17 +28614,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 (!existsSync14(todayFile) && !existsSync14(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 existsSync14(file) && files.indexOf(file) === index;
   });
   if (options.follow) {
-    if (existsSync11(todayFile)) {
+    if (existsSync14(todayFile)) {
       await followLogFile(todayFile, lines);
     } else {
       console.log("No log file for today to follow.");