agent-remnote 0.2.0 → 0.3.0

package/dist/main.js

@@ -73916,13 +73916,17 @@ var platformRunnerImpl = /* @__PURE__ */ PlatformRunner2.of({
 import { readFileSync as readFileSync2 } from "node:fs";
 import { format as format10 } from "node:util";
 
+// src/services/UserConfigFile.ts
+import { promises as fs4 } from "node:fs";
+import path7 from "node:path";
+
 // src/services/AppConfig.ts
 class AppConfig extends Tag2("AppConfig")() {
 }
 
-// src/services/DaemonFiles.ts
-import { promises as fs } from "node:fs";
-import path4 from "node:path";
+// src/services/Config.ts
+import fs3 from "node:fs";
+import path6 from "node:path";
 
 // src/services/Errors.ts
 class CliError extends TaggedError("CliError") {
@@ -73954,52 +73958,985 @@ function cliErrorFromValidationError(err) {
     exitCode: 2
   });
 }
-function exitCodeFromExit(exit3) {
-  if (isSuccess(exit3))
-    return 0;
-  if (isInterruptedOnly2(exit3.cause))
-    return 0;
-  const failure = failureOption2(exit3.cause);
-  if (isSome2(failure)) {
-    const error4 = failure.value;
-    if (isCliError(error4))
-      return error4.exitCode;
-    if (isValidationError2(error4))
-      return 2;
-  }
-  return 1;
+function exitCodeFromExit(exit3) {
+  if (isSuccess(exit3))
+    return 0;
+  if (isInterruptedOnly2(exit3.cause))
+    return 0;
+  const failure = failureOption2(exit3.cause);
+  if (isSome2(failure)) {
+    const error4 = failure.value;
+    if (isCliError(error4))
+      return error4.exitCode;
+    if (isValidationError2(error4))
+      return 2;
+  }
+  return 1;
+}
+
+// src/lib/paths.ts
+import os from "node:os";
+import path3 from "node:path";
+function homeDir() {
+  const h = os.homedir();
+  if (typeof h === "string" && h.trim())
+    return h;
+  return process.env.HOME || process.env.USERPROFILE || ".";
+}
+function expandHome(targetPath) {
+  const raw4 = targetPath.trim();
+  if (!raw4.startsWith("~"))
+    return raw4;
+  const home = homeDir();
+  if (raw4 === "~")
+    return home;
+  if (raw4.startsWith("~/") || raw4.startsWith("~\\")) {
+    return path3.join(home, raw4.slice(2));
+  }
+  return raw4.replace(/^~(?=$|[\\/])/, home);
+}
+function resolveUserFilePath(filePath) {
+  return path3.normalize(expandHome(filePath));
+}
+
+// src/lib/wsState.ts
+import fs from "node:fs";
+import path4 from "node:path";
+function defaultStateFilePath() {
+  return path4.join(homeDir(), ".agent-remnote", "ws.bridge.state.json");
+}
+function resolveStateFilePath(explicit) {
+  if (explicit && explicit.trim())
+    return { disabled: false, path: resolveUserFilePath(explicit) };
+  const raw4 = String(process.env.REMNOTE_WS_STATE_FILE || process.env.WS_STATE_FILE || "").trim();
+  if (raw4 === "0" || raw4.toLowerCase() === "false")
+    return { disabled: true, path: defaultStateFilePath() };
+  if (raw4)
+    return { disabled: false, path: resolveUserFilePath(raw4) };
+  return { disabled: false, path: defaultStateFilePath() };
+}
+function readJson(filePath) {
+  try {
+    const txt = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(txt);
+  } catch {
+    return null;
+  }
+}
+function pickClient(clients, connId) {
+  const target2 = (connId || "").trim();
+  if (target2) {
+    const found = clients.find((c) => c && typeof c === "object" && c.connId === target2);
+    if (found)
+      return found;
+  }
+  const active2 = clients.find((c) => c && typeof c === "object" && c.isActiveWorker === true);
+  if (active2)
+    return active2;
+  let best = null;
+  let bestScore = -1;
+  for (const c of clients) {
+    if (!c || typeof c !== "object")
+      continue;
+    const selAt = Number(c.selection?.updatedAt ?? 0);
+    const ctxAt = Number(c.uiContext?.updatedAt ?? 0);
+    const score = Math.max(selAt, ctxAt);
+    if (score > bestScore) {
+      bestScore = score;
+      best = c;
+    }
+  }
+  return best;
+}
+function resolveStaleMs(explicit) {
+  if (typeof explicit === "number" && Number.isFinite(explicit) && explicit > 0)
+    return Math.floor(explicit);
+  const raw4 = process.env.REMNOTE_WS_STATE_STALE_MS || process.env.WS_STATE_STALE_MS;
+  const n = Number(raw4);
+  if (Number.isFinite(n) && n > 0)
+    return Math.floor(n);
+  return 60000;
+}
+
+// src/lib/remnote.ts
+import fs2 from "node:fs";
+import path5 from "node:path";
+function tryParseRemnoteLink(input) {
+  const raw4 = input.trim();
+  let u;
+  try {
+    u = new URL(raw4);
+  } catch {
+    return;
+  }
+  if (u.protocol === "remnote:" && u.hostname === "w") {
+    const parts2 = u.pathname.split("/").filter(Boolean);
+    const workspaceId = parts2.length >= 1 ? parts2[0] : undefined;
+    const remId = parts2.length >= 2 ? parts2[1] : undefined;
+    if (workspaceId && remId) {
+      return { workspaceId: workspaceId.trim(), remId: remId.trim() };
+    }
+    return;
+  }
+  if ((u.protocol === "https:" || u.protocol === "http:") && u.hostname.endsWith("remnote.com")) {
+    const parts2 = u.pathname.split("/").filter(Boolean);
+    if (parts2.length >= 3 && parts2[0] === "w") {
+      const workspaceId = parts2[1];
+      const remId = parts2[2];
+      if (workspaceId && remId) {
+        return { workspaceId: workspaceId.trim(), remId: remId.trim() };
+      }
+    }
+  }
+  return;
+}
+function tryParseRemnoteLinkFromRef(input) {
+  const direct = tryParseRemnoteLink(input);
+  if (direct)
+    return direct;
+  const raw4 = input.trim();
+  const idx = raw4.indexOf(":");
+  if (idx <= 0)
+    return;
+  const value8 = raw4.slice(idx + 1).trim();
+  if (!value8)
+    return;
+  return tryParseRemnoteLink(value8);
+}
+function remnoteDbPathForWorkspaceId(workspaceId) {
+  return path5.join(homeDir(), "remnote", `remnote-${workspaceId}`, "remnote.db");
+}
+function tryResolveRemnoteDbPathForWorkspaceIdSync(workspaceId) {
+  const p3 = remnoteDbPathForWorkspaceId(workspaceId);
+  try {
+    return fs2.statSync(p3).isFile() ? p3 : undefined;
+  } catch {
+    return;
+  }
+}
+
+// src/services/Config.ts
+function defaultStoreDbPath() {
+  return path6.join(homeDir(), ".agent-remnote", "store.sqlite");
+}
+function defaultUserConfigFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "config.json");
+}
+function wsUrlFromPort(port3) {
+  return `ws://localhost:${port3}/ws`;
+}
+function defaultWsStateFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "ws.bridge.state.json");
+}
+function defaultStatusLineFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "status-line.txt");
+}
+function defaultStatusLineJsonFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "status-line.json");
+}
+function defaultApiPidFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "api.pid");
+}
+function defaultApiLogFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "api.log");
+}
+function defaultApiStateFilePath() {
+  return path6.join(homeDir(), ".agent-remnote", "api.state.json");
+}
+var ROOT_BOOL_FLAGS = new Set(["--json", "--md", "--ids", "--quiet", "--debug"]);
+var BUILTIN_BOOL_FLAGS = new Set(["--help", "-h", "--wizard", "--version"]);
+var BUILTIN_VALUE_FLAGS = new Set(["--completions", "--log-level"]);
+var ROOT_VALUE_FLAGS = new Set([
+  "--remnote-db",
+  "--store-db",
+  "--daemon-url",
+  "--ws-port",
+  "--repo",
+  "--api-base-url",
+  "--config-file",
+  ...BUILTIN_VALUE_FLAGS
+]);
+function isBooleanLiteralToken(token) {
+  const v = token.trim().toLowerCase();
+  return v === "true" || v === "false";
+}
+function splitFlagInlineValue(token) {
+  if (!token.startsWith("--"))
+    return { flag: token, inlineValue: null };
+  const eq = token.indexOf("=");
+  if (eq === -1)
+    return { flag: token, inlineValue: null };
+  return { flag: token.slice(0, eq), inlineValue: token.slice(eq + 1) };
+}
+function isConfigCommandInvocation(argv) {
+  const tokens = argv.slice(2);
+  let i = 0;
+  while (i < tokens.length) {
+    const raw4 = String(tokens[i] ?? "");
+    if (!raw4)
+      break;
+    if (raw4 === "--") {
+      i += 1;
+      break;
+    }
+    if (!raw4.startsWith("-"))
+      break;
+    const { flag, inlineValue } = splitFlagInlineValue(raw4);
+    if (ROOT_VALUE_FLAGS.has(flag)) {
+      i += inlineValue !== null ? 1 : 2;
+      continue;
+    }
+    if (ROOT_BOOL_FLAGS.has(flag) || BUILTIN_BOOL_FLAGS.has(flag)) {
+      if (inlineValue !== null) {
+        i += 1;
+        continue;
+      }
+      const next4 = tokens[i + 1];
+      if (typeof next4 === "string" && isBooleanLiteralToken(next4)) {
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    break;
+  }
+  return tokens[i] === "config";
+}
+function normalizeApiBasePath(raw4) {
+  const trimmed2 = raw4.trim();
+  if (!trimmed2)
+    return "/v1";
+  return trimmed2.startsWith("/") ? trimmed2 : `/${trimmed2}`;
+}
+function normalizeApiBaseUrl(raw4) {
+  const trimmed2 = raw4.trim();
+  if (!trimmed2)
+    return trimmed2;
+  let parsed;
+  try {
+    parsed = new URL(trimmed2);
+  } catch {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `Invalid apiBaseUrl: ${trimmed2}`,
+      exitCode: 2,
+      details: { api_base_url: trimmed2 }
+    });
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `apiBaseUrl protocol must be http/https: ${trimmed2}`,
+      exitCode: 2,
+      details: { api_base_url: trimmed2 }
+    });
+  }
+  const normalized = trimmed2.replace(/\/+$/, "");
+  return normalized;
+}
+function resolveWsStateFile(spec) {
+  const raw4 = spec.trim();
+  if (raw4 === "0" || raw4.toLowerCase() === "false") {
+    return { disabled: true, path: defaultWsStateFilePath() };
+  }
+  if (raw4)
+    return { disabled: false, path: resolveUserFilePath(raw4) };
+  return { disabled: false, path: defaultWsStateFilePath() };
+}
+function inferRemnoteDbFromWsState(params3) {
+  if (params3.wsStateFile.disabled)
+    return;
+  const state = readJson(params3.wsStateFile.path);
+  if (!state)
+    return;
+  const now2 = Date.now();
+  const updatedAt = Number(state.updatedAt ?? 0);
+  const staleMs = params3.wsStateStaleMs;
+  const stale = !Number.isFinite(updatedAt) || updatedAt <= 0 || now2 - updatedAt > staleMs;
+  if (stale)
+    return;
+  const clients = Array.isArray(state.clients) ? state.clients : [];
+  const activeConnIdRaw = typeof state.activeWorkerConnId === "string" ? state.activeWorkerConnId.trim() : "";
+  const client = pickClient(clients, activeConnIdRaw || undefined);
+  const kbIdRaw = typeof client?.uiContext?.kbId === "string" ? client.uiContext.kbId.trim() : "";
+  if (!kbIdRaw)
+    return;
+  const dbPath = resolveUserFilePath(remnoteDbPathForWorkspaceId(kbIdRaw));
+  try {
+    return fs3.statSync(dbPath).isFile() ? dbPath : undefined;
+  } catch {
+    return;
+  }
+}
+function pickFormat(raw4) {
+  const json4 = raw4.json === true;
+  const md = raw4.md === true;
+  const ids3 = raw4.ids === true;
+  const count4 = [json4, md, ids3].filter(Boolean).length;
+  if (count4 > 1) {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: "Output format conflict: choose only one of --json/--md/--ids",
+      exitCode: 2,
+      details: { json: json4, md, ids: ids3 }
+    });
+  }
+  if (json4)
+    return "json";
+  if (ids3)
+    return "ids";
+  return "md";
+}
+var rawConfigSpec = all8({
+  json: boolean4("json").pipe(withDefault2(false)),
+  md: boolean4("md").pipe(withDefault2(false)),
+  ids: boolean4("ids").pipe(withDefault2(false)),
+  quiet: boolean4("quiet").pipe(withDefault2(false)),
+  debug: boolean4("debug").pipe(withDefault2(false)),
+  configFile: string5("configFile").pipe(withDefault2(defaultUserConfigFilePath())),
+  remnoteDb: string5("remnoteDb").pipe(withDefault2("")),
+  storeDb: string5("storeDb").pipe(withDefault2(defaultStoreDbPath())),
+  daemonUrl: string5("daemonUrl").pipe(withDefault2("")),
+  wsPort: port2("wsPort").pipe(withDefault2(6789)),
+  wsScheduler: boolean4("wsScheduler").pipe(withDefault2(true)),
+  wsDispatchMaxBytes: integer2("wsDispatchMaxBytes").pipe(withDefault2(512000), validate3({
+    message: "wsDispatchMaxBytes must be a positive integer",
+    validation: (n) => Number.isFinite(n) && n > 0
+  })),
+  wsDispatchMaxOpBytes: integer2("wsDispatchMaxOpBytes").pipe(withDefault2(256000), validate3({
+    message: "wsDispatchMaxOpBytes must be a positive integer",
+    validation: (n) => Number.isFinite(n) && n > 0
+  })),
+  repo: string5("repo").pipe(withDefault2("")),
+  wsStateFile: string5("wsStateFile").pipe(withDefault2("")),
+  wsStateStaleMs: integer2("wsStateStaleMs").pipe(withDefault2(60000), validate3({
+    message: "wsStateStaleMs must be a positive integer",
+    validation: (n) => Number.isFinite(n) && n > 0
+  })),
+  tmuxRefresh: boolean4("tmuxRefresh").pipe(withDefault2(true)),
+  tmuxRefreshMinIntervalMs: integer2("tmuxRefreshMinIntervalMs").pipe(withDefault2(250), validate3({
+    message: "tmuxRefreshMinIntervalMs must be a positive integer",
+    validation: (n) => Number.isFinite(n) && n > 0
+  })),
+  statusLineFile: string5("statusLineFile").pipe(withDefault2(defaultStatusLineFilePath())),
+  statusLineMinIntervalMs: integer2("statusLineMinIntervalMs").pipe(withDefault2(250), validate3({
+    message: "statusLineMinIntervalMs must be a positive integer",
+    validation: (n) => Number.isFinite(n) && n > 0
+  })),
+  statusLineDebug: boolean4("statusLineDebug").pipe(withDefault2(false)),
+  statusLineJsonFile: string5("statusLineJsonFile").pipe(withDefault2(defaultStatusLineJsonFilePath())),
+  apiBaseUrl: string5("apiBaseUrl").pipe(withDefault2("")),
+  apiHost: string5("apiHost").pipe(withDefault2("0.0.0.0")),
+  apiPort: port2("apiPort").pipe(withDefault2(3000)),
+  apiBasePath: string5("apiBasePath").pipe(withDefault2("/v1")),
+  apiPidFile: string5("apiPidFile").pipe(withDefault2(defaultApiPidFilePath())),
+  apiLogFile: string5("apiLogFile").pipe(withDefault2(defaultApiLogFilePath())),
+  apiStateFile: string5("apiStateFile").pipe(withDefault2(defaultApiStateFilePath()))
+});
+function cliErrorFromConfigError(error4) {
+  if (isInvalidData2(error4) || isMissingData2(error4)) {
+    return new CliError({
+      code: "INVALID_ARGS",
+      message: error4.message || "Invalid configuration",
+      exitCode: 2,
+      details: { path: error4.path, op: error4._op }
+    });
+  }
+  return new CliError({
+    code: "INVALID_ARGS",
+    message: error4.message || "Invalid configuration",
+    exitCode: 2,
+    details: { op: error4._op }
+  });
+}
+function optionalTrimmed(s) {
+  const t = s.trim();
+  return t.length > 0 ? t : undefined;
+}
+function readUserConfigFile(configFile) {
+  const file6 = resolveUserFilePath(configFile);
+  let rawText = "";
+  try {
+    rawText = fs3.readFileSync(file6, "utf8");
+  } catch (error4) {
+    if (error4?.code === "ENOENT")
+      return {};
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `Failed to read config file: ${file6}`,
+      exitCode: 2,
+      details: { config_file: file6, error: String(error4?.message || error4) }
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch (error4) {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `Invalid JSON in config file: ${file6}`,
+      exitCode: 2,
+      details: { config_file: file6, error: String(error4?.message || error4) }
+    });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `Config file must contain a JSON object: ${file6}`,
+      exitCode: 2,
+      details: { config_file: file6 }
+    });
+  }
+  const config3 = parsed;
+  const api = config3.api;
+  const nestedBaseUrl = api && typeof api === "object" && !Array.isArray(api) ? api.baseUrl : undefined;
+  const apiBaseUrl = config3.apiBaseUrl ?? nestedBaseUrl;
+  if (apiBaseUrl === undefined)
+    return {};
+  if (typeof apiBaseUrl !== "string") {
+    throw new CliError({
+      code: "INVALID_ARGS",
+      message: `Config key apiBaseUrl must be a string: ${file6}`,
+      exitCode: 2,
+      details: { config_file: file6 }
+    });
+  }
+  return { apiBaseUrl };
+}
+function resolveConfig() {
+  return gen2(function* () {
+    const raw4 = yield* rawConfigSpec;
+    const configFile = resolveUserFilePath(raw4.configFile);
+    const userConfigResult = yield* either3(try_3({
+      try: () => readUserConfigFile(configFile),
+      catch: (error4) => isCliError(error4) ? error4 : new CliError({
+        code: "INVALID_ARGS",
+        message: `Failed to load config file: ${configFile}`,
+        exitCode: 2,
+        details: { config_file: configFile, error: String(error4?.message || error4) }
+      })
+    }));
+    const userConfig = userConfigResult._tag === "Right" ? userConfigResult.right : isConfigCommandInvocation(process.argv) ? {} : yield* fail8(userConfigResult.left);
+    const wsStateFile = resolveWsStateFile(raw4.wsStateFile);
+    const remnoteDb = optionalTrimmed(raw4.remnoteDb) ? resolveUserFilePath(raw4.remnoteDb) : inferRemnoteDbFromWsState({ wsStateFile, wsStateStaleMs: raw4.wsStateStaleMs }) || undefined;
+    const storeDb = resolveUserFilePath(raw4.storeDb);
+    const daemonUrl = optionalTrimmed(raw4.daemonUrl);
+    const wsUrl = daemonUrl ? daemonUrl : wsUrlFromPort(raw4.wsPort);
+    const format8 = yield* try_3({
+      try: () => pickFormat(raw4),
+      catch: (e) => isCliError(e) ? e : new CliError({
+        code: "INVALID_ARGS",
+        message: "Invalid output format flags",
+        exitCode: 2,
+        details: { error: String(e?.message || e) }
+      })
+    });
+    const apiBaseUrlRaw = optionalTrimmed(raw4.apiBaseUrl) ?? optionalTrimmed(userConfig.apiBaseUrl ?? "");
+    const apiBaseUrl = apiBaseUrlRaw ? normalizeApiBaseUrl(apiBaseUrlRaw) : undefined;
+    return {
+      format: format8,
+      quiet: raw4.quiet,
+      debug: raw4.debug,
+      configFile,
+      remnoteDb,
+      storeDb,
+      wsUrl,
+      wsScheduler: raw4.wsScheduler,
+      wsDispatchMaxBytes: raw4.wsDispatchMaxBytes,
+      wsDispatchMaxOpBytes: raw4.wsDispatchMaxOpBytes,
+      repo: optionalTrimmed(raw4.repo) ? resolveUserFilePath(raw4.repo) : undefined,
+      wsStateFile,
+      wsStateStaleMs: raw4.wsStateStaleMs,
+      tmuxRefresh: raw4.tmuxRefresh,
+      tmuxRefreshMinIntervalMs: raw4.tmuxRefreshMinIntervalMs,
+      statusLineFile: resolveUserFilePath(raw4.statusLineFile),
+      statusLineMinIntervalMs: raw4.statusLineMinIntervalMs,
+      statusLineDebug: raw4.statusLineDebug,
+      statusLineJsonFile: resolveUserFilePath(raw4.statusLineJsonFile),
+      apiBaseUrl,
+      apiHost: raw4.apiHost.trim() || "0.0.0.0",
+      apiPort: raw4.apiPort,
+      apiBasePath: normalizeApiBasePath(raw4.apiBasePath),
+      apiPidFile: resolveUserFilePath(raw4.apiPidFile),
+      apiLogFile: resolveUserFilePath(raw4.apiLogFile),
+      apiStateFile: resolveUserFilePath(raw4.apiStateFile)
+    };
+  }).pipe(catchAll2((error4) => {
+    if (isCliError(error4))
+      return fail8(error4);
+    if (isConfigError2(error4))
+      return fail8(cliErrorFromConfigError(error4));
+    return fail8(new CliError({
+      code: "INTERNAL",
+      message: "Failed to parse config",
+      exitCode: 1,
+      details: { error: String(error4?.message || error4) }
+    }));
+  }));
+}
+
+// src/services/UserConfigFile.ts
+class UserConfigFile extends Tag2("UserConfigFile")() {
+}
+function canonicalKey(input) {
+  const key = String(input ?? "").trim();
+  if (!key) {
+    throw new CliError({ code: "INVALID_ARGS", message: "Config key is required", exitCode: 2 });
+  }
+  if (key === "apiBaseUrl" || key === "api.baseUrl" || key === "api-base-url")
+    return "apiBaseUrl";
+  throw new CliError({ code: "INVALID_ARGS", message: `Unsupported config key: ${key}`, exitCode: 2 });
+}
+function isPlainObject(value8) {
+  return typeof value8 === "object" && value8 !== null && !Array.isArray(value8);
+}
+function cloneDoc(doc) {
+  return JSON.parse(JSON.stringify(doc));
+}
+function removeEmptyApiObject(doc) {
+  const api = doc.api;
+  if (!isPlainObject(api))
+    return;
+  if (Object.keys(api).length === 0)
+    delete doc.api;
+}
+function readApiBaseUrl(doc) {
+  const errors3 = [];
+  const root = doc.apiBaseUrl;
+  const api = doc.api;
+  const nested4 = isPlainObject(api) ? api.baseUrl : undefined;
+  const rootValue = root === undefined ? undefined : typeof root === "string" ? root : (errors3.push("Config key apiBaseUrl must be a string"), undefined);
+  const nestedValue = nested4 === undefined ? undefined : typeof nested4 === "string" ? nested4 : (errors3.push("Config key api.baseUrl must be a string"), undefined);
+  if (rootValue && nestedValue && rootValue !== nestedValue) {
+    errors3.push("Config keys apiBaseUrl and api.baseUrl conflict");
+  }
+  return { value: rootValue ?? nestedValue, errors: errors3 };
+}
+function inspectDoc(configFile, exists3, doc) {
+  const apiBaseUrl = readApiBaseUrl(doc);
+  const unknownKeys = [];
+  for (const key of Object.keys(doc)) {
+    if (key === "apiBaseUrl")
+      continue;
+    if (key !== "api") {
+      unknownKeys.push(key);
+      continue;
+    }
+    const api = doc.api;
+    if (!isPlainObject(api)) {
+      continue;
+    }
+    for (const nestedKey of Object.keys(api)) {
+      if (nestedKey === "baseUrl")
+        continue;
+      unknownKeys.push(`api.${nestedKey}`);
+    }
+  }
+  return {
+    configFile,
+    exists: exists3,
+    values: { apiBaseUrl: apiBaseUrl.value },
+    unknownKeys,
+    errors: apiBaseUrl.errors,
+    valid: apiBaseUrl.errors.length === 0
+  };
+}
+async function ensureDir(filePath) {
+  await fs4.mkdir(path7.dirname(filePath), { recursive: true });
+}
+async function readDocDetailed(configFile) {
+  const file6 = resolveUserFilePath(configFile);
+  let rawText = "";
+  try {
+    rawText = await fs4.readFile(file6, "utf8");
+  } catch (error4) {
+    if (error4?.code === "ENOENT")
+      return { ok: true, exists: false, configFile: file6, doc: {} };
+    return {
+      ok: false,
+      exists: true,
+      configFile: file6,
+      errors: [`Failed to read config file: ${file6}`]
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch {
+    return {
+      ok: false,
+      exists: true,
+      configFile: file6,
+      errors: [`Invalid JSON in config file: ${file6}`]
+    };
+  }
+  if (!isPlainObject(parsed)) {
+    return {
+      ok: false,
+      exists: true,
+      configFile: file6,
+      errors: [`Config file must contain a JSON object: ${file6}`]
+    };
+  }
+  return { ok: true, exists: true, configFile: file6, doc: parsed };
+}
+function requireParsedDoc(parsed) {
+  if (parsed.ok)
+    return parsed;
+  throw new CliError({
+    code: "INVALID_ARGS",
+    message: parsed.errors[0] || "Invalid config file",
+    exitCode: 2,
+    details: { config_file: parsed.configFile, errors: parsed.errors }
+  });
+}
+async function writeDoc(configFile, doc) {
+  const file6 = resolveUserFilePath(configFile);
+  await ensureDir(file6);
+  const tmp = `${file6}.tmp-${process.pid}-${Date.now()}`;
+  await fs4.writeFile(tmp, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+  await fs4.rename(tmp, file6);
+}
+async function deleteDoc(configFile) {
+  await fs4.rm(resolveUserFilePath(configFile), { force: true });
+}
+function setApiBaseUrl(doc, value8) {
+  const next4 = cloneDoc(doc);
+  next4.apiBaseUrl = normalizeApiBaseUrl(value8);
+  const api = next4.api;
+  if (isPlainObject(api)) {
+    delete api.baseUrl;
+    removeEmptyApiObject(next4);
+  }
+  return next4;
+}
+function unsetApiBaseUrl(doc) {
+  const next4 = cloneDoc(doc);
+  let removed = false;
+  if (Object.prototype.hasOwnProperty.call(next4, "apiBaseUrl")) {
+    delete next4.apiBaseUrl;
+    removed = true;
+  }
+  const api = next4.api;
+  if (isPlainObject(api) && Object.prototype.hasOwnProperty.call(api, "baseUrl")) {
+    delete api.baseUrl;
+    removeEmptyApiObject(next4);
+    removed = true;
+  }
+  return { next: next4, removed };
+}
+function isEmptyDoc(doc) {
+  return Object.keys(doc).length === 0;
+}
+function toCliFailure(error4, message) {
+  return isCliError(error4) ? error4 : new CliError({
+    code: "INVALID_ARGS",
+    message,
+    exitCode: 2,
+    details: { error: String(error4?.message || error4) }
+  });
+}
+var UserConfigFileLive = succeed10(UserConfigFile, {
+  path: () => gen2(function* () {
+    const cfg = yield* AppConfig;
+    return cfg.configFile;
+  }),
+  inspect: () => gen2(function* () {
+    const cfg = yield* AppConfig;
+    const parsed = yield* promise2(() => readDocDetailed(cfg.configFile));
+    if (!parsed.ok) {
+      return {
+        configFile: parsed.configFile,
+        exists: parsed.exists,
+        values: {},
+        unknownKeys: [],
+        errors: parsed.errors,
+        valid: false
+      };
+    }
+    return inspectDoc(parsed.configFile, parsed.exists, parsed.doc);
+  }),
+  get: (key) => gen2(function* () {
+    const targetKey = yield* try_3({
+      try: () => canonicalKey(key),
+      catch: (error4) => toCliFailure(error4, "Invalid config key")
+    });
+    const cfg = yield* AppConfig;
+    const parsed = yield* promise2(() => readDocDetailed(cfg.configFile));
+    const { configFile, doc } = yield* try_3({
+      try: () => requireParsedDoc(parsed),
+      catch: (error4) => toCliFailure(error4, "Invalid config file")
+    });
+    const inspection = inspectDoc(configFile, parsed.exists, doc);
+    const value8 = targetKey === "apiBaseUrl" ? inspection.values.apiBaseUrl ?? null : null;
+    return {
+      configFile,
+      key: targetKey,
+      exists: value8 !== null,
+      value: value8
+    };
+  }),
+  set: (key, value8) => gen2(function* () {
+    const targetKey = yield* try_3({
+      try: () => canonicalKey(key),
+      catch: (error4) => toCliFailure(error4, "Invalid config key")
+    });
+    const cfg = yield* AppConfig;
+    const parsed = yield* promise2(() => readDocDetailed(cfg.configFile));
+    const { configFile, doc } = yield* try_3({
+      try: () => requireParsedDoc(parsed),
+      catch: (error4) => toCliFailure(error4, "Invalid config file")
+    });
+    const next4 = targetKey === "apiBaseUrl" ? yield* try_3({
+      try: () => setApiBaseUrl(doc, value8),
+      catch: (error4) => toCliFailure(error4, "Invalid config value")
+    }) : doc;
+    yield* tryPromise2({
+      try: async () => await writeDoc(configFile, next4),
+      catch: (error4) => new CliError({
+        code: "INTERNAL",
+        message: "Failed to write config file",
+        exitCode: 1,
+        details: { config_file: configFile, error: String(error4?.message || error4) }
+      })
+    });
+    return {
+      configFile,
+      key: targetKey,
+      value: String(next4.apiBaseUrl ?? ""),
+      changed: true
+    };
+  }),
+  unset: (key) => gen2(function* () {
+    const targetKey = yield* try_3({
+      try: () => canonicalKey(key),
+      catch: (error4) => toCliFailure(error4, "Invalid config key")
+    });
+    const cfg = yield* AppConfig;
+    const parsed = yield* promise2(() => readDocDetailed(cfg.configFile));
+    const { configFile, doc, exists: exists3 } = yield* try_3({
+      try: () => requireParsedDoc(parsed),
+      catch: (error4) => toCliFailure(error4, "Invalid config file")
+    });
+    if (!exists3) {
+      return {
+        configFile,
+        key: targetKey,
+        removed: false,
+        fileDeleted: false
+      };
+    }
+    const result = targetKey === "apiBaseUrl" ? unsetApiBaseUrl(doc) : { next: doc, removed: false };
+    if (!result.removed) {
+      return {
+        configFile,
+        key: targetKey,
+        removed: false,
+        fileDeleted: false
+      };
+    }
+    if (isEmptyDoc(result.next)) {
+      yield* tryPromise2({
+        try: async () => await deleteDoc(configFile),
+        catch: (error4) => new CliError({
+          code: "INTERNAL",
+          message: "Failed to delete config file",
+          exitCode: 1,
+          details: { config_file: configFile, error: String(error4?.message || error4) }
+        })
+      });
+      return {
+        configFile,
+        key: targetKey,
+        removed: true,
+        fileDeleted: true
+      };
+    }
+    yield* tryPromise2({
+      try: async () => await writeDoc(configFile, result.next),
+      catch: (error4) => new CliError({
+        code: "INTERNAL",
+        message: "Failed to write config file",
+        exitCode: 1,
+        details: { config_file: configFile, error: String(error4?.message || error4) }
+      })
+    });
+    return {
+      configFile,
+      key: targetKey,
+      removed: true,
+      fileDeleted: false
+    };
+  })
+});
+
+// src/services/Output.ts
+class Output extends Tag2("Output")() {
+}
+var OutputLive = succeed10(Output, {
+  stdout: (text14) => sync3(() => {
+    process.stdout.write(text14);
+  }),
+  stderr: (text14) => sync3(() => {
+    process.stderr.write(text14);
+  }),
+  json: (value8) => sync3(() => {
+    process.stdout.write(`${JSON.stringify(value8)}
+`);
+  })
+});
+
+// src/commands/_shared.ts
+function ensureTrailingNewline(text14) {
+  return text14.endsWith(`
+`) ? text14 : `${text14}
+`;
+}
+function formatHumanErrorLine(message) {
+  const trimmed2 = String(message ?? "").trim();
+  if (!trimmed2)
+    return "Error: Unknown error";
+  return trimmed2.startsWith("Error:") ? trimmed2 : `Error: ${trimmed2}`;
+}
+function readStringArray(value8) {
+  if (!Array.isArray(value8))
+    return [];
+  return value8.map((v) => String(v ?? "").trim()).filter(Boolean);
+}
+function writeSuccess(params3) {
+  return gen2(function* () {
+    const config3 = yield* AppConfig;
+    const out = yield* Output;
+    if (config3.format === "json") {
+      yield* out.json(ok(params3.data));
+      return;
+    }
+    if (config3.quiet)
+      return;
+    if (config3.format === "ids") {
+      if (!params3.ids || params3.ids.length === 0) {
+        return yield* fail8(new CliError({
+          code: "INVALID_ARGS",
+          message: "This command does not support --ids output",
+          exitCode: 2
+        }));
+      }
+      yield* out.stdout(`${params3.ids.join(`
+`)}
+`);
+      return;
+    }
+    if (params3.data && typeof params3.data === "object") {
+      const anyData = params3.data;
+      const warnings = readStringArray(anyData?.warnings);
+      const nextActions = readStringArray(anyData?.nextActions);
+      if (warnings.length > 0) {
+        yield* out.stderr(`Warnings:
+`);
+        for (const w of warnings)
+          yield* out.stderr(`- ${w}
+`);
+      }
+      if (nextActions.length > 0) {
+        yield* out.stderr(`Next actions:
+`);
+        for (const a of nextActions)
+          yield* out.stderr(`- ${a}
+`);
+      }
+    }
+    const md = params3.md ?? "";
+    if (md.trim().length > 0) {
+      yield* out.stdout(ensureTrailingNewline(md));
+    }
+  });
+}
+function writeFailure(error4) {
+  return gen2(function* () {
+    const config3 = yield* AppConfig;
+    const out = yield* Output;
+    if (config3.format === "json") {
+      return yield* fail8(error4);
+    }
+    globalThis.__REMNOTE_CLI_ERROR_REPORTED__ = true;
+    yield* out.stderr(ensureTrailingNewline(formatHumanErrorLine(error4.message)));
+    if (config3.debug && error4.details !== undefined) {
+      yield* out.stderr(`${JSON.stringify(error4.details, null, 2)}
+`);
+    }
+    if (error4.hint && error4.hint.length > 0) {
+      yield* out.stderr(`Hint:
+`);
+      for (const h of error4.hint) {
+        yield* out.stderr(`- ${h}
+`);
+      }
+    }
+    return yield* fail8(error4);
+  });
 }
 
-// src/lib/paths.ts
-import os from "node:os";
-import path3 from "node:path";
-function homeDir() {
-  const h = os.homedir();
-  if (typeof h === "string" && h.trim())
-    return h;
-  return process.env.HOME || process.env.USERPROFILE || ".";
-}
-function expandHome(targetPath) {
-  const raw4 = targetPath.trim();
-  if (!raw4.startsWith("~"))
-    return raw4;
-  const home = homeDir();
-  if (raw4 === "~")
-    return home;
-  if (raw4.startsWith("~/") || raw4.startsWith("~\\")) {
-    return path3.join(home, raw4.slice(2));
-  }
-  return raw4.replace(/^~(?=$|[\\/])/, home);
-}
-function resolveUserFilePath(filePath) {
-  return path3.normalize(expandHome(filePath));
-}
+// src/commands/config/get.ts
+var configGetCommand = exports_Command.make("get", { key: text9("key") }, ({ key }) => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const data = yield* userConfig.get(key);
+  yield* writeSuccess({
+    data: {
+      config_file: data.configFile,
+      key: data.key,
+      exists: data.exists,
+      value: data.value
+    },
+    md: data.value === null ? "" : `${data.value}
+`
+  });
+}).pipe(catchAll2(writeFailure)));
+
+// src/commands/config/list.ts
+var configListCommand = exports_Command.make("list", {}, () => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const inspection = yield* userConfig.inspect();
+  const data = {
+    config_file: inspection.configFile,
+    exists: inspection.exists,
+    valid: inspection.valid,
+    values: inspection.values,
+    unknown_keys: inspection.unknownKeys,
+    errors: inspection.errors
+  };
+  const mdLines = [
+    `- config_file: ${data.config_file}`,
+    `- exists: ${data.exists}`,
+    `- valid: ${data.valid}`,
+    `- apiBaseUrl: ${data.values.apiBaseUrl ?? ""}`,
+    `- unknown_keys: ${data.unknown_keys.join(", ")}`,
+    `- errors: ${data.errors.join(" | ")}`
+  ];
+  yield* writeSuccess({ data, md: `${mdLines.join(`
+`)}
+` });
+}).pipe(catchAll2(writeFailure)));
+
+// src/commands/config/path.ts
+var configPathCommand = exports_Command.make("path", {}, () => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const configFile = yield* userConfig.path();
+  yield* writeSuccess({
+    data: { config_file: configFile },
+    md: `${configFile}
+`
+  });
+}).pipe(catchAll2(writeFailure)));
 
 // src/services/DaemonFiles.ts
+import { promises as fs5 } from "node:fs";
+import path8 from "node:path";
 class DaemonFiles extends Tag2("DaemonFiles")() {
 }
-function ensureDir(p3) {
-  return fs.mkdir(path4.dirname(p3), { recursive: true }).then(() => {
+function ensureDir2(p3) {
+  return fs5.mkdir(path8.dirname(p3), { recursive: true }).then(() => {
     return;
   });
 }
@@ -74007,19 +74944,19 @@ function defaultPidFile() {
   const envPidFile = process.env.REMNOTE_DAEMON_PID_FILE || process.env.DAEMON_PID_FILE;
   if (typeof envPidFile === "string" && envPidFile.trim())
     return resolveUserFilePath(envPidFile);
-  return path4.join(homeDir(), ".agent-remnote", "ws.pid");
+  return path8.join(homeDir(), ".agent-remnote", "ws.pid");
 }
 function defaultLogFile() {
   const envLogFile = process.env.REMNOTE_DAEMON_LOG_FILE || process.env.DAEMON_LOG_FILE;
   if (typeof envLogFile === "string" && envLogFile.trim())
     return resolveUserFilePath(envLogFile);
-  return path4.join(homeDir(), ".agent-remnote", "ws.log");
+  return path8.join(homeDir(), ".agent-remnote", "ws.log");
 }
 async function writeJsonAtomic(filePath, json4) {
-  await ensureDir(filePath);
+  await ensureDir2(filePath);
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs.writeFile(tmp, JSON.stringify(json4), "utf8");
-  await fs.rename(tmp, filePath);
+  await fs5.writeFile(tmp, JSON.stringify(json4), "utf8");
+  await fs5.rename(tmp, filePath);
 }
 var DaemonFilesLive = succeed10(DaemonFiles, {
   defaultPidFile: () => defaultPidFile(),
@@ -74027,7 +74964,7 @@ var DaemonFilesLive = succeed10(DaemonFiles, {
   readPidFile: (pidFilePath) => tryPromise2({
     try: async () => {
       try {
-        const raw4 = await fs.readFile(pidFilePath, "utf8");
+        const raw4 = await fs5.readFile(pidFilePath, "utf8");
         const parsed = JSON.parse(raw4);
         return parsed;
       } catch (error4) {
@@ -74065,7 +75002,7 @@ var DaemonFilesLive = succeed10(DaemonFiles, {
   deletePidFile: (pidFilePath) => tryPromise2({
     try: async () => {
       try {
-        await fs.unlink(pidFilePath);
+        await fs5.unlink(pidFilePath);
       } catch (error4) {
         if (error4?.code === "ENOENT")
           return;
@@ -74086,30 +75023,30 @@ var DaemonFilesLive = succeed10(DaemonFiles, {
 });
 
 // src/services/SupervisorState.ts
-import { promises as fs2 } from "node:fs";
-import path5 from "node:path";
+import { promises as fs6 } from "node:fs";
+import path9 from "node:path";
 class SupervisorState extends Tag2("SupervisorState")() {
 }
-function ensureDir2(p3) {
-  return fs2.mkdir(path5.dirname(p3), { recursive: true }).then(() => {
+function ensureDir3(p3) {
+  return fs6.mkdir(path9.dirname(p3), { recursive: true }).then(() => {
     return;
   });
 }
 function defaultStateFile() {
-  return path5.join(homeDir(), ".agent-remnote", "ws.state.json");
+  return path9.join(homeDir(), ".agent-remnote", "ws.state.json");
 }
 async function writeJsonAtomic2(filePath, json4) {
-  await ensureDir2(filePath);
+  await ensureDir3(filePath);
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs2.writeFile(tmp, JSON.stringify(json4), "utf8");
-  await fs2.rename(tmp, filePath);
+  await fs6.writeFile(tmp, JSON.stringify(json4), "utf8");
+  await fs6.rename(tmp, filePath);
 }
 var SupervisorStateLive = succeed10(SupervisorState, {
   defaultStateFile: () => defaultStateFile(),
   readStateFile: (stateFilePath) => tryPromise2({
     try: async () => {
       try {
-        const raw4 = await fs2.readFile(stateFilePath, "utf8");
+        const raw4 = await fs6.readFile(stateFilePath, "utf8");
         const parsed = JSON.parse(raw4);
         return parsed;
       } catch (error4) {
@@ -74117,161 +75054,55 @@ var SupervisorStateLive = succeed10(SupervisorState, {
           return;
         throw error4;
       }
-    },
-    catch: (error4) => {
-      if (isCliError(error4))
-        return error4;
-      return new CliError({
-        code: "INTERNAL",
-        message: "Failed to read supervisor state",
-        exitCode: 1,
-        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
-      });
-    }
-  }),
-  writeStateFile: (stateFilePath, value8) => tryPromise2({
-    try: async () => {
-      await writeJsonAtomic2(stateFilePath, value8);
-    },
-    catch: (error4) => {
-      if (isCliError(error4))
-        return error4;
-      return new CliError({
-        code: "INTERNAL",
-        message: "Failed to write supervisor state",
-        exitCode: 1,
-        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
-      });
-    }
-  }),
-  deleteStateFile: (stateFilePath) => tryPromise2({
-    try: async () => {
-      try {
-        await fs2.unlink(stateFilePath);
-      } catch (error4) {
-        if (error4?.code === "ENOENT")
-          return;
-        throw error4;
-      }
-    },
-    catch: (error4) => {
-      if (isCliError(error4))
-        return error4;
-      return new CliError({
-        code: "INTERNAL",
-        message: "Failed to delete supervisor state",
-        exitCode: 1,
-        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
-      });
-    }
-  })
-});
-
-// src/services/Output.ts
-class Output extends Tag2("Output")() {
-}
-var OutputLive = succeed10(Output, {
-  stdout: (text14) => sync3(() => {
-    process.stdout.write(text14);
-  }),
-  stderr: (text14) => sync3(() => {
-    process.stderr.write(text14);
-  }),
-  json: (value8) => sync3(() => {
-    process.stdout.write(`${JSON.stringify(value8)}
-`);
-  })
-});
-
-// src/commands/_shared.ts
-function ensureTrailingNewline(text14) {
-  return text14.endsWith(`
-`) ? text14 : `${text14}
-`;
-}
-function formatHumanErrorLine(message) {
-  const trimmed2 = String(message ?? "").trim();
-  if (!trimmed2)
-    return "Error: Unknown error";
-  return trimmed2.startsWith("Error:") ? trimmed2 : `Error: ${trimmed2}`;
-}
-function readStringArray(value8) {
-  if (!Array.isArray(value8))
-    return [];
-  return value8.map((v) => String(v ?? "").trim()).filter(Boolean);
-}
-function writeSuccess(params3) {
-  return gen2(function* () {
-    const config3 = yield* AppConfig;
-    const out = yield* Output;
-    if (config3.format === "json") {
-      yield* out.json(ok(params3.data));
-      return;
-    }
-    if (config3.quiet)
-      return;
-    if (config3.format === "ids") {
-      if (!params3.ids || params3.ids.length === 0) {
-        return yield* fail8(new CliError({
-          code: "INVALID_ARGS",
-          message: "This command does not support --ids output",
-          exitCode: 2
-        }));
-      }
-      yield* out.stdout(`${params3.ids.join(`
-`)}
-`);
-      return;
-    }
-    if (params3.data && typeof params3.data === "object") {
-      const anyData = params3.data;
-      const warnings = readStringArray(anyData?.warnings);
-      const nextActions = readStringArray(anyData?.nextActions);
-      if (warnings.length > 0) {
-        yield* out.stderr(`Warnings:
-`);
-        for (const w of warnings)
-          yield* out.stderr(`- ${w}
-`);
-      }
-      if (nextActions.length > 0) {
-        yield* out.stderr(`Next actions:
-`);
-        for (const a of nextActions)
-          yield* out.stderr(`- ${a}
-`);
-      }
-    }
-    const md = params3.md ?? "";
-    if (md.trim().length > 0) {
-      yield* out.stdout(ensureTrailingNewline(md));
-    }
-  });
-}
-function writeFailure(error4) {
-  return gen2(function* () {
-    const config3 = yield* AppConfig;
-    const out = yield* Output;
-    if (config3.format === "json") {
-      return yield* fail8(error4);
+    },
+    catch: (error4) => {
+      if (isCliError(error4))
+        return error4;
+      return new CliError({
+        code: "INTERNAL",
+        message: "Failed to read supervisor state",
+        exitCode: 1,
+        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
+      });
     }
-    globalThis.__REMNOTE_CLI_ERROR_REPORTED__ = true;
-    yield* out.stderr(ensureTrailingNewline(formatHumanErrorLine(error4.message)));
-    if (config3.debug && error4.details !== undefined) {
-      yield* out.stderr(`${JSON.stringify(error4.details, null, 2)}
-`);
+  }),
+  writeStateFile: (stateFilePath, value8) => tryPromise2({
+    try: async () => {
+      await writeJsonAtomic2(stateFilePath, value8);
+    },
+    catch: (error4) => {
+      if (isCliError(error4))
+        return error4;
+      return new CliError({
+        code: "INTERNAL",
+        message: "Failed to write supervisor state",
+        exitCode: 1,
+        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
+      });
     }
-    if (error4.hint && error4.hint.length > 0) {
-      yield* out.stderr(`Hint:
-`);
-      for (const h of error4.hint) {
-        yield* out.stderr(`- ${h}
-`);
+  }),
+  deleteStateFile: (stateFilePath) => tryPromise2({
+    try: async () => {
+      try {
+        await fs6.unlink(stateFilePath);
+      } catch (error4) {
+        if (error4?.code === "ENOENT")
+          return;
+        throw error4;
       }
+    },
+    catch: (error4) => {
+      if (isCliError(error4))
+        return error4;
+      return new CliError({
+        code: "INTERNAL",
+        message: "Failed to delete supervisor state",
+        exitCode: 1,
+        details: { state_file: stateFilePath, error: String(error4?.message || error4) }
+      });
     }
-    return yield* fail8(error4);
-  });
-}
+  })
+});
 
 // src/commands/config/print.ts
 var configPrintCommand = exports_Command.make("print", {}, () => gen2(function* () {
@@ -74285,6 +75116,7 @@ var configPrintCommand = exports_Command.make("print", {}, () => gen2(function*
     format: cfg.format,
     quiet: cfg.quiet,
     debug: cfg.debug,
+    config_file: cfg.configFile,
     remnote_db: cfg.remnoteDb,
     store_db: cfg.storeDb,
     ws_url: cfg.wsUrl,
@@ -74299,6 +75131,13 @@ var configPrintCommand = exports_Command.make("print", {}, () => gen2(function*
     status_line_min_interval_ms: cfg.statusLineMinIntervalMs,
     status_line_debug: cfg.statusLineDebug,
     status_line_json_file: cfg.statusLineJsonFile,
+    api_base_url: cfg.apiBaseUrl,
+    api_host: cfg.apiHost,
+    api_port: cfg.apiPort,
+    api_base_path: cfg.apiBasePath,
+    api_pid_file: cfg.apiPidFile,
+    api_log_file: cfg.apiLogFile,
+    api_state_file: cfg.apiStateFile,
     daemon_pid_file_default: daemonPidFile,
     daemon_log_file_default: daemonLogFile,
     supervisor_state_file_default: supervisorStateFile
@@ -74307,6 +75146,7 @@ var configPrintCommand = exports_Command.make("print", {}, () => gen2(function*
     `- format: ${data.format}`,
     `- quiet: ${data.quiet}`,
     `- debug: ${data.debug}`,
+    `- config_file: ${data.config_file}`,
     `- remnote_db: ${data.remnote_db ?? ""}`,
     `- store_db: ${data.store_db}`,
     `- ws_url: ${data.ws_url}`,
@@ -74321,6 +75161,13 @@ var configPrintCommand = exports_Command.make("print", {}, () => gen2(function*
     `- status_line_min_interval_ms: ${data.status_line_min_interval_ms}`,
     `- status_line_debug: ${data.status_line_debug}`,
     `- status_line_json_file: ${data.status_line_json_file}`,
+    `- api_base_url: ${data.api_base_url ?? ""}`,
+    `- api_host: ${data.api_host ?? ""}`,
+    `- api_port: ${data.api_port ?? ""}`,
+    `- api_base_path: ${data.api_base_path ?? ""}`,
+    `- api_pid_file: ${data.api_pid_file ?? ""}`,
+    `- api_log_file: ${data.api_log_file ?? ""}`,
+    `- api_state_file: ${data.api_state_file ?? ""}`,
     `- daemon_pid_file_default: ${data.daemon_pid_file_default}`,
     `- daemon_log_file_default: ${data.daemon_log_file_default}`,
     `- supervisor_state_file_default: ${data.supervisor_state_file_default}`
@@ -74329,38 +75176,102 @@ var configPrintCommand = exports_Command.make("print", {}, () => gen2(function*
   yield* writeSuccess({ data, md });
 }).pipe(catchAll2(writeFailure)));
 
+// src/commands/config/set.ts
+var configSetCommand = exports_Command.make("set", { key: text9("key"), value: text9("value") }, ({ key, value: value8 }) => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const data = yield* userConfig.set(key, value8);
+  yield* writeSuccess({
+    data: {
+      config_file: data.configFile,
+      key: data.key,
+      value: data.value,
+      changed: data.changed
+    },
+    md: `${data.key}=${data.value}
+`
+  });
+}).pipe(catchAll2(writeFailure)));
+
+// src/commands/config/unset.ts
+var configUnsetCommand = exports_Command.make("unset", { key: text9("key") }, ({ key }) => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const data = yield* userConfig.unset(key);
+  yield* writeSuccess({
+    data: {
+      config_file: data.configFile,
+      key: data.key,
+      removed: data.removed,
+      file_deleted: data.fileDeleted
+    },
+    md: `${data.key} removed=${data.removed}
+`
+  });
+}).pipe(catchAll2(writeFailure)));
+
+// src/commands/config/validate.ts
+var configValidateCommand = exports_Command.make("validate", {}, () => gen2(function* () {
+  const userConfig = yield* UserConfigFile;
+  const inspection = yield* userConfig.inspect();
+  const data = {
+    config_file: inspection.configFile,
+    exists: inspection.exists,
+    valid: inspection.valid,
+    values: inspection.values,
+    unknown_keys: inspection.unknownKeys,
+    errors: inspection.errors
+  };
+  const mdLines = [
+    `- config_file: ${data.config_file}`,
+    `- exists: ${data.exists}`,
+    `- valid: ${data.valid}`,
+    `- unknown_keys: ${data.unknown_keys.join(", ")}`,
+    `- errors: ${data.errors.join(" | ")}`
+  ];
+  yield* writeSuccess({ data, md: `${mdLines.join(`
+`)}
+` });
+}).pipe(catchAll2(writeFailure)));
+
 // src/commands/config/index.ts
-var configCommand = exports_Command.make("config", {}).pipe(exports_Command.withSubcommands([configPrintCommand]));
+var configCommand = exports_Command.make("config", {}).pipe(exports_Command.withSubcommands([
+  configPrintCommand,
+  configPathCommand,
+  configListCommand,
+  configGetCommand,
+  configSetCommand,
+  configUnsetCommand,
+  configValidateCommand
+]));
 
 // src/services/FsAccess.ts
-import { constants as FS_CONSTANTS, promises as fs3 } from "node:fs";
-import path6 from "node:path";
+import { constants as FS_CONSTANTS, promises as fs7 } from "node:fs";
+import path10 from "node:path";
 
 class FsAccess extends Tag2("FsAccess")() {
 }
 async function canWritePath(filePath) {
   try {
-    await fs3.mkdir(path6.dirname(filePath), { recursive: true });
-    await fs3.access(path6.dirname(filePath), FS_CONSTANTS.W_OK);
+    await fs7.mkdir(path10.dirname(filePath), { recursive: true });
+    await fs7.access(path10.dirname(filePath), FS_CONSTANTS.W_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function checkWritableFile(filePath) {
-  const dir2 = path6.dirname(filePath);
+  const dir2 = path10.dirname(filePath);
   try {
-    await fs3.mkdir(dir2, { recursive: true });
+    await fs7.mkdir(dir2, { recursive: true });
   } catch (e) {
     return { ok: false, reason: `failed_to_create_dir: ${String(e?.message || e)}` };
   }
   try {
-    await fs3.access(dir2, FS_CONSTANTS.W_OK);
+    await fs7.access(dir2, FS_CONSTANTS.W_OK);
   } catch (e) {
     return { ok: false, reason: `dir_not_writable: ${String(e?.message || e)}` };
   }
   try {
-    await fs3.access(filePath, FS_CONSTANTS.W_OK);
+    await fs7.access(filePath, FS_CONSTANTS.W_OK);
     return { ok: true };
   } catch {
     return { ok: true };
@@ -74369,7 +75280,7 @@ async function checkWritableFile(filePath) {
 var FsAccessLive = succeed10(FsAccess, {
   isFile: (filePath) => tryPromise2({
     try: async () => {
-      const st = await fs3.stat(filePath);
+      const st = await fs7.stat(filePath);
       return st.isFile();
     },
     catch: (e) => e
@@ -74466,65 +75377,6 @@ function refreshTmuxStatusLine() {
   requestTmuxStatusLineRefresh("immediate");
 }
 
-// src/lib/wsState.ts
-import fs4 from "node:fs";
-import path7 from "node:path";
-function defaultStateFilePath() {
-  return path7.join(homeDir(), ".agent-remnote", "ws.bridge.state.json");
-}
-function resolveStateFilePath(explicit) {
-  if (explicit && explicit.trim())
-    return { disabled: false, path: resolveUserFilePath(explicit) };
-  const raw4 = String(process.env.REMNOTE_WS_STATE_FILE || process.env.WS_STATE_FILE || "").trim();
-  if (raw4 === "0" || raw4.toLowerCase() === "false")
-    return { disabled: true, path: defaultStateFilePath() };
-  if (raw4)
-    return { disabled: false, path: resolveUserFilePath(raw4) };
-  return { disabled: false, path: defaultStateFilePath() };
-}
-function readJson(filePath) {
-  try {
-    const txt = fs4.readFileSync(filePath, "utf8");
-    return JSON.parse(txt);
-  } catch {
-    return null;
-  }
-}
-function pickClient(clients, connId) {
-  const target2 = (connId || "").trim();
-  if (target2) {
-    const found = clients.find((c) => c && typeof c === "object" && c.connId === target2);
-    if (found)
-      return found;
-  }
-  const active2 = clients.find((c) => c && typeof c === "object" && c.isActiveWorker === true);
-  if (active2)
-    return active2;
-  let best = null;
-  let bestScore = -1;
-  for (const c of clients) {
-    if (!c || typeof c !== "object")
-      continue;
-    const selAt = Number(c.selection?.updatedAt ?? 0);
-    const ctxAt = Number(c.uiContext?.updatedAt ?? 0);
-    const score = Math.max(selAt, ctxAt);
-    if (score > bestScore) {
-      bestScore = score;
-      best = c;
-    }
-  }
-  return best;
-}
-function resolveStaleMs(explicit) {
-  if (typeof explicit === "number" && Number.isFinite(explicit) && explicit > 0)
-    return Math.floor(explicit);
-  const raw4 = process.env.REMNOTE_WS_STATE_STALE_MS || process.env.WS_STATE_STALE_MS;
-  const n = Number(raw4);
-  if (Number.isFinite(n) && n > 0)
-    return Math.floor(n);
-  return 60000;
-}
-
 // src/lib/wsBridgeNextActions.ts
 function buildDbFallbackNextAction(queryText) {
   const q = String(queryText || "").replace(/\s+/g, " ").trim();
@@ -74536,21 +75388,21 @@ function buildDbFallbackNextAction(queryText) {
 }
 
 // src/lib/wsDebug.ts
-import fs5 from "node:fs";
-import path8 from "node:path";
+import fs8 from "node:fs";
+import path11 from "node:path";
 function envDebug() {
   const v = (process.env.REMNOTE_WS_DEBUG || process.env.WS_DEBUG || "").toLowerCase();
   return v === "1" || v === "true";
 }
 function envLogFilePath(params3) {
   const p3 = process.env.REMNOTE_WS_LOGFILE || process.env.WS_LOGFILE || "";
-  const def = params3.debug ? path8.join(homeDir(), ".agent-remnote", "ws-debug.log") : "";
+  const def = params3.debug ? path11.join(homeDir(), ".agent-remnote", "ws-debug.log") : "";
   const out = p3 && p3.trim() || def;
   if (!out)
     return;
   try {
     const resolved = resolveUserFilePath(out);
-    fs5.mkdirSync(path8.dirname(resolved), { recursive: true });
+    fs8.mkdirSync(path11.dirname(resolved), { recursive: true });
     return resolved;
   } catch {
     return;
@@ -74582,19 +75434,19 @@ function wsLog(level, msg, ctx) {
   if (!LOG_FILE)
     return;
   try {
-    fs5.appendFileSync(LOG_FILE, `${new Date().toISOString()} ${line4}
+    fs8.appendFileSync(LOG_FILE, `${new Date().toISOString()} ${line4}
 `);
   } catch {}
 }
 
 // src/internal/queue/db.ts
-import path10 from "node:path";
+import path13 from "node:path";
 
 // src/internal/store/db.ts
 import Database from "better-sqlite3";
 import { createHash, randomUUID } from "node:crypto";
 import { constants as constants2, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import path9 from "node:path";
+import path12 from "node:path";
 
 // src/internal/store/migrations/0001-baseline.ts
 var migration = {
@@ -74831,7 +75683,7 @@ CREATE TABLE IF NOT EXISTS queue_consumers (
 );
 `;
 function absoluteDefaultStorePath() {
-  return path9.join(homeDir(), ".agent-remnote", "store.sqlite");
+  return path12.join(homeDir(), ".agent-remnote", "store.sqlite");
 }
 function defaultStorePath() {
   const env2 = process.env.REMNOTE_STORE_DB || process.env.STORE_DB;
@@ -74843,15 +75695,15 @@ function defaultLegacyQueuePath() {
   const env2 = process.env.REMNOTE_QUEUE_DB || process.env.QUEUE_DB;
   if (typeof env2 === "string" && env2.trim())
     return resolveUserFilePath(env2);
-  return path9.join(homeDir(), ".agent-remnote", "queue.sqlite");
+  return path12.join(homeDir(), ".agent-remnote", "queue.sqlite");
 }
-function ensureDir3(filePath) {
-  const dir2 = path9.dirname(filePath);
+function ensureDir4(filePath) {
+  const dir2 = path12.dirname(filePath);
   mkdirSync(dir2, { recursive: true });
 }
 function openStoreDb(dbPath = defaultStorePath()) {
   const resolvedPath = resolveUserFilePath(dbPath);
-  ensureDir3(resolvedPath);
+  ensureDir4(resolvedPath);
   maybeInitializeDefaultStoreFromLegacy(resolvedPath, { callerProvidedPath: dbPath });
   const db = new Database(resolvedPath);
   db.pragma("busy_timeout = 5000");
@@ -75176,7 +76028,7 @@ function maybeInitializeDefaultStoreFromLegacy(resolvedStorePath, params3) {
   if (!existsSync(legacyPath))
     return;
   const tmpPath = `${resolvedStorePath}.tmp.${process.pid}.${randomUUID()}`;
-  ensureDir3(tmpPath);
+  ensureDir4(tmpPath);
   try {
     const source = new Database(legacyPath, { readonly: true });
     try {
@@ -75215,10 +76067,10 @@ function defaultQueuePath() {
   const env2 = process.env.REMNOTE_QUEUE_DB || process.env.QUEUE_DB;
   if (typeof env2 === "string" && env2.trim())
     return resolveUserFilePath(env2);
-  return path10.join(homeDir(), ".agent-remnote", "queue.sqlite");
+  return path13.join(homeDir(), ".agent-remnote", "queue.sqlite");
 }
-function ensureDir4(filePath) {
-  ensureDir3(filePath);
+function ensureDir5(filePath) {
+  ensureDir4(filePath);
 }
 function queueErrorFromStoreSchema(dbPath, error4) {
   const code2 = error4.code === "STORE_SCHEMA_NEWER" ? "QUEUE_SCHEMA_NEWER" : error4.code === "STORE_SCHEMA_INVALID" ? "QUEUE_SCHEMA_INVALID" : "QUEUE_SCHEMA_UNKNOWN";
@@ -75231,7 +76083,7 @@ function queueErrorFromStoreSchema(dbPath, error4) {
 }
 function openQueueDb(dbPath = defaultQueuePath()) {
   const resolvedPath = resolveUserFilePath(dbPath);
-  ensureDir4(resolvedPath);
+  ensureDir5(resolvedPath);
   try {
     return openStoreDb(resolvedPath);
   } catch (e) {
@@ -75523,18 +76375,18 @@ function getFirstString(payload, keys8) {
   }
   return null;
 }
-function getFirstStringFromNested(payload, path11) {
+function getFirstStringFromNested(payload, path14) {
   let cur = payload;
-  for (const k of path11) {
+  for (const k of path14) {
     if (!cur || typeof cur !== "object")
       return null;
     cur = cur[k];
   }
   return asNonEmptyString(cur);
 }
-function getStringArrayFromNested(payload, path11) {
+function getStringArrayFromNested(payload, path14) {
   let cur = payload;
-  for (const k of path11) {
+  for (const k of path14) {
     if (!cur || typeof cur !== "object")
       return [];
     cur = cur[k];
@@ -76647,38 +77499,38 @@ function idFieldPathsForOpType(opTypeRaw) {
   return Array.isArray(entry.id_fields) ? entry.id_fields : [];
 }
 // src/kernel/op-catalog/pathWalk.ts
-function parsePathTokens(path11) {
-  return path11.split(".").map((part) => part.trim()).filter(Boolean).map((part) => {
+function parsePathTokens(path14) {
+  return path14.split(".").map((part) => part.trim()).filter(Boolean).map((part) => {
     const isArray2 = part.endsWith("[]");
     const key = isArray2 ? part.slice(0, -2).trim() : part;
     return { key, isArray: isArray2 };
   }).filter((token) => token.key.length > 0);
 }
-function collectLeafValues(value8, path11, idx = 0) {
-  if (idx >= path11.length)
+function collectLeafValues(value8, path14, idx = 0) {
+  if (idx >= path14.length)
     return [value8];
   if (!value8 || typeof value8 !== "object")
     return [];
-  const token = path11[idx];
+  const token = path14[idx];
   const next4 = value8[token.key];
   if (token.isArray) {
     if (!Array.isArray(next4))
       return [];
     const out = [];
     for (const item of next4) {
-      out.push(...collectLeafValues(item, path11, idx + 1));
+      out.push(...collectLeafValues(item, path14, idx + 1));
     }
     return out;
   }
-  return collectLeafValues(next4, path11, idx + 1);
+  return collectLeafValues(next4, path14, idx + 1);
 }
-function mapLeafValuesInPlace(value8, path11, mapFn, idx = 0) {
-  if (idx >= path11.length)
+function mapLeafValuesInPlace(value8, path14, mapFn, idx = 0) {
+  if (idx >= path14.length)
     return;
   if (!value8 || typeof value8 !== "object")
     return;
-  const token = path11[idx];
-  const isLeaf = idx === path11.length - 1;
+  const token = path14[idx];
+  const isLeaf = idx === path14.length - 1;
   if (token.isArray) {
     const next4 = value8[token.key];
     if (!Array.isArray(next4))
@@ -76688,7 +77540,7 @@ function mapLeafValuesInPlace(value8, path11, mapFn, idx = 0) {
       return;
     }
     for (const item of next4) {
-      mapLeafValuesInPlace(item, path11, mapFn, idx + 1);
+      mapLeafValuesInPlace(item, path14, mapFn, idx + 1);
     }
     return;
   }
@@ -76696,7 +77548,7 @@ function mapLeafValuesInPlace(value8, path11, mapFn, idx = 0) {
     value8[token.key] = mapFn(value8[token.key]);
     return;
   }
-  mapLeafValuesInPlace(value8[token.key], path11, mapFn, idx + 1);
+  mapLeafValuesInPlace(value8[token.key], path14, mapFn, idx + 1);
 }
 
 // src/kernel/op-catalog/substituteIds.ts
@@ -76718,8 +77570,8 @@ function collectTempIdsFromPayload(opTypeRaw, payload) {
   if (!payload || typeof payload !== "object")
     return [];
   const out = [];
-  for (const path11 of idFieldPathsForOpType(opTypeRaw)) {
-    const tokens = parsePathTokens(path11);
+  for (const path14 of idFieldPathsForOpType(opTypeRaw)) {
+    const tokens = parsePathTokens(path14);
     if (tokens.length === 0)
       continue;
     const values5 = collectLeafValues(payload, tokens);
@@ -76734,8 +77586,8 @@ function substituteTempIdsInPayload(opTypeRaw, payload, idMap) {
   if (!payload || typeof payload !== "object")
     return payload;
   const out = cloneJson(payload);
-  for (const path11 of idFieldPathsForOpType(opTypeRaw)) {
-    const tokens = parsePathTokens(path11);
+  for (const path14 of idFieldPathsForOpType(opTypeRaw)) {
+    const tokens = parsePathTokens(path14);
     if (tokens.length === 0)
       continue;
     mapLeafValuesInPlace(out, tokens, (value8) => {
@@ -78006,8 +78858,8 @@ function toWsBridgeClient2(client) {
 var GLOBAL_BRIDGE_KEY = Symbol.for("__REMNOTE_WS_BRIDGE__");
 // src/internal/remdb-tools/shared.ts
 import BetterSqlite3 from "better-sqlite3";
-import { promises as fs6 } from "fs";
-import path11 from "path";
+import { promises as fs9 } from "fs";
+import path14 from "path";
 
 // ../../node_modules/date-fns/constants.js
 var daysInYear = 365.2425;
@@ -79496,18 +80348,18 @@ async function withResolvedDatabase(dbPath, fn) {
 async function resolveDatabasePath(dbPath) {
   if (dbPath) {
     const expanded = expandHome2(dbPath.trim());
-    const stat3 = await fs6.stat(expanded);
+    const stat3 = await fs9.stat(expanded);
     if (!stat3.isFile()) {
       throw new Error(`${expanded} is not a file`);
     }
     return {
       dbPath: expanded,
       source: "explicit",
-      baseDir: path11.dirname(expanded)
+      baseDir: path14.dirname(expanded)
     };
   }
-  const baseDir = path11.join(homeDir(), REMNOTE_RELATIVE_DIR);
-  const entries2 = await fs6.readdir(baseDir, { withFileTypes: true }).catch(() => {
+  const baseDir = path14.join(homeDir(), REMNOTE_RELATIVE_DIR);
+  const entries2 = await fs9.readdir(baseDir, { withFileTypes: true }).catch(() => {
     throw new Error(`RemNote directory ${baseDir} not found – please specify dbPath manually`);
   });
   const candidates = [];
@@ -79520,9 +80372,9 @@ async function resolveDatabasePath(dbPath) {
     const isSecondary = SECONDARY_DIRS.has(entry.name);
     if (!isPrimary && !isSecondary)
       continue;
-    const candidatePath = path11.join(baseDir, entry.name, REMNOTE_DB_NAME);
+    const candidatePath = path14.join(baseDir, entry.name, REMNOTE_DB_NAME);
     try {
-      const stat3 = await fs6.stat(candidatePath);
+      const stat3 = await fs9.stat(candidatePath);
       candidates.push({
         dbPath: candidatePath,
         dirName: entry.name,
@@ -79553,18 +80405,18 @@ async function discoverBackups(basePath) {
   const backups = [];
   let entries2;
   try {
-    entries2 = await fs6.readdir(basePath, { withFileTypes: true });
+    entries2 = await fs9.readdir(basePath, { withFileTypes: true });
   } catch (error4) {
     throw new Error(`Unable to read ${basePath}: ${String(error4)}`);
   }
   for (const entry of entries2) {
     if (!entry.isDirectory())
       continue;
-    const accountDir = path11.join(basePath, entry.name);
-    const backupDir = path11.join(accountDir, "backups");
+    const accountDir = path14.join(basePath, entry.name);
+    const backupDir = path14.join(accountDir, "backups");
     let backupFiles;
     try {
-      backupFiles = await fs6.readdir(backupDir, { withFileTypes: true });
+      backupFiles = await fs9.readdir(backupDir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -79573,8 +80425,8 @@ async function discoverBackups(basePath) {
         continue;
       if (!file6.name.endsWith(".db") && !file6.name.endsWith(".db.zip"))
         continue;
-      const fullPath = path11.join(backupDir, file6.name);
-      const stat3 = await fs6.stat(fullPath);
+      const fullPath = path14.join(backupDir, file6.name);
+      const stat3 = await fs9.stat(fullPath);
       backups.push({
         accountDir: entry.name,
         file: file6.name,
@@ -79695,8 +80547,8 @@ function parseOrThrow(schema2, input, options6) {
   throw new Error(prefix2 + lines3.join("; "));
 }
 function formatZodIssueEN(issue) {
-  const path12 = issue.path && issue.path.length > 0 ? issue.path.join(".") : undefined;
-  const where = path12 ? `field ${path12}: ` : "";
+  const path15 = issue.path && issue.path.length > 0 ? issue.path.join(".") : undefined;
+  const where = path15 ? `field ${path15}: ` : "";
   switch (issue.code) {
     case "invalid_type": {
       const expected = toENType(issue.expected);
@@ -80148,8 +81000,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params3) => {
-  const { data, path: path12, errorMaps, issueData } = params3;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data, path: path15, errorMaps, issueData } = params3;
+  const fullPath = [...path15, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -80277,11 +81129,11 @@ var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 
 class ParseInputLazyPath {
-  constructor(parent, value8, path12, key) {
+  constructor(parent, value8, path15, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value8;
-    this._path = path12;
+    this._path = path15;
     this._key = key;
   }
   get path() {
@@ -83658,7 +84510,7 @@ var z = /* @__PURE__ */ Object.freeze({
 });
 
 // src/internal/remdb-tools/listRemBackups.ts
-import path12 from "node:path";
+import path15 from "node:path";
 var inputShape = {
   basePath: z.string().optional().describe("RemNote base directory (default: ~/remnote)"),
   limit: z.number().int().min(1).max(200).optional().describe("Max backups to return (default 50)")
@@ -83666,7 +84518,7 @@ var inputShape = {
 var listRemBackupsSchema = z.object(inputShape);
 async function executeListRemBackups(params3) {
   const parsed = parseOrThrow(listRemBackupsSchema, params3, { label: "list_rem_backups" });
-  const basePath = expandHome2(parsed.basePath ?? path12.join(homeDir(), REMNOTE_RELATIVE_DIR));
+  const basePath = expandHome2(parsed.basePath ?? path15.join(homeDir(), REMNOTE_RELATIVE_DIR));
   const backups = await discoverBackups(basePath);
   const limit = parsed.limit ?? 50;
   return {
@@ -85416,10 +86268,10 @@ function fetchDocs(db, rootId, includeDescendants, maxDepth) {
   }
   return rows.map((row) => convertRow(row.id, row.doc));
 }
-function collectReferences(value8, remId, path13, into3) {
+function collectReferences(value8, remId, path16, into3) {
   if (Array.isArray(value8)) {
     value8.forEach((item, index) => {
-      collectReferences(item, remId, [...path13, index], into3);
+      collectReferences(item, remId, [...path16, index], into3);
     });
     return;
   }
@@ -85429,7 +86281,7 @@ function collectReferences(value8, remId, path13, into3) {
       into3.push({
         refId: maybeRef._id,
         remId,
-        path: formatPath2(path13),
+        path: formatPath2(path16),
         tokenKind: classifyToken(maybeRef)
       });
       return;
@@ -85438,13 +86290,13 @@ function collectReferences(value8, remId, path13, into3) {
       into3.push({
         refId: maybeRef._id,
         remId,
-        path: formatPath2(path13),
+        path: formatPath2(path16),
         tokenKind: classifyToken(maybeRef)
       });
       return;
     }
     for (const [key, child] of Object.entries(maybeRef)) {
-      collectReferences(child, remId, [...path13, key], into3);
+      collectReferences(child, remId, [...path16, key], into3);
     }
   }
 }
@@ -85561,8 +86413,8 @@ function buildReferencesMarkdown(remId, guidance, outbound, inbound, includeInbo
       const tokenKind = Array.isArray(ref.tokenKinds) ? `type: ${formatTokenKinds(ref.tokenKinds)}` : "";
       const ancestor = ref.ancestor ? `, ancestor: ${ref.ancestor}` : "";
       const count4 = typeof ref.count === "number" ? `${ref.count} occurrences` : "";
-      const path13 = ref.occurrences ? ref.occurrences[0]?.path ?? null : ref.representativePath;
-      const samplePath = path13 ? `, sample path: ${path13}` : "";
+      const path16 = ref.occurrences ? ref.occurrences[0]?.path ?? null : ref.representativePath;
+      const samplePath = path16 ? `, sample path: ${path16}` : "";
       lines3.push(`- **${name}** (ID: ${ref.refId}, ${count4}${ancestor}${samplePath}${tokenKind ? `, ${tokenKind}` : ""})`);
     });
   }
@@ -89072,16 +89924,16 @@ var WsClientLive = succeed10(WsClient, {
 });
 
 // src/commands/ws/_shared.ts
-import path14 from "node:path";
+import path17 from "node:path";
 
 // src/services/Process.ts
 import { spawn as spawn3 } from "node:child_process";
-import fs7 from "node:fs";
-import path13 from "node:path";
+import fs10 from "node:fs";
+import path16 from "node:path";
 class Process extends Tag2("Process")() {
 }
 function ensureDirSync(filePath) {
-  fs7.mkdirSync(path13.dirname(filePath), { recursive: true });
+  fs10.mkdirSync(path16.dirname(filePath), { recursive: true });
 }
 var ProcessLive = succeed10(Process, {
   isPidRunning: (pid) => sync3(() => {
@@ -89099,7 +89951,7 @@ var ProcessLive = succeed10(Process, {
   spawnDetached: (params3) => try_3({
     try: () => {
       ensureDirSync(params3.logFile);
-      const fd = fs7.openSync(params3.logFile, "a");
+      const fd = fs10.openSync(params3.logFile, "a");
       const child = spawn3(params3.command, [...params3.args], {
         cwd: params3.cwd,
         env: params3.env,
@@ -89253,7 +90105,7 @@ function toInitialSupervisorState(now2) {
   };
 }
 function defaultStateFilePathFromPidFile(pidFilePath) {
-  return path14.join(path14.dirname(pidFilePath), "ws.state.json");
+  return path17.join(path17.dirname(pidFilePath), "ws.state.json");
 }
 function startWsSupervisor(params3) {
   return gen2(function* () {
@@ -89740,30 +90592,30 @@ var wsLogsCommand = exports_Command.make("logs", {
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/ws/restart.ts
-import path16 from "node:path";
+import path19 from "node:path";
 
 // src/lib/statuslineArtifacts.ts
-import { promises as fs9 } from "node:fs";
+import { promises as fs12 } from "node:fs";
 
 // src/services/StatusLineFile.ts
-import { promises as fs8 } from "node:fs";
-import path15 from "node:path";
+import { promises as fs11 } from "node:fs";
+import path18 from "node:path";
 class StatusLineFile extends Tag2("StatusLineFile")() {
 }
 function defaultTextFile() {
-  return path15.join(homeDir(), ".agent-remnote", "status-line.txt");
+  return path18.join(homeDir(), ".agent-remnote", "status-line.txt");
 }
 function defaultJsonFile() {
-  return path15.join(homeDir(), ".agent-remnote", "status-line.json");
+  return path18.join(homeDir(), ".agent-remnote", "status-line.json");
 }
-function ensureDir5(p3) {
-  return fs8.mkdir(path15.dirname(p3), { recursive: true }).then(() => {
+function ensureDir6(p3) {
+  return fs11.mkdir(path18.dirname(p3), { recursive: true }).then(() => {
     return;
   });
 }
 async function readFileOrEmpty(filePath) {
   try {
-    return await fs8.readFile(filePath, "utf8");
+    return await fs11.readFile(filePath, "utf8");
   } catch (e) {
     if (e?.code === "ENOENT")
       return "";
@@ -89771,10 +90623,10 @@ async function readFileOrEmpty(filePath) {
   }
 }
 async function writeTextAtomic(filePath, content) {
-  await ensureDir5(filePath);
+  await ensureDir6(filePath);
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs8.writeFile(tmp, content, "utf8");
-  await fs8.rename(tmp, filePath);
+  await fs11.writeFile(tmp, content, "utf8");
+  await fs11.rename(tmp, filePath);
 }
 var StatusLineFileLive = succeed10(StatusLineFile, {
   defaultTextFile: () => defaultTextFile(),
@@ -89827,7 +90679,7 @@ function resolveStatuslineArtifactPaths(params3) {
 function deleteFileIfExists(filePath) {
   return promise2(async () => {
     try {
-      await fs9.unlink(filePath);
+      await fs12.unlink(filePath);
       return { action: "deleted", file: filePath };
     } catch (e) {
       if (e?.code === "ENOENT")
@@ -89870,7 +90722,7 @@ var wsRestartCommand = exports_Command.make("restart", {
   const pidFilePath = resolveUserFilePath(pidFile4 ?? daemonFiles.defaultPidFile());
   const existing = yield* daemonFiles.readPidFile(pidFilePath);
   let stopResult = { stopped: true, pid_file: pidFilePath };
-  const stateFilePath = resolveUserFilePath(existing?.state_file ?? path16.join(path16.dirname(pidFilePath), "ws.state.json"));
+  const stateFilePath = resolveUserFilePath(existing?.state_file ?? path19.join(path19.dirname(pidFilePath), "ws.state.json"));
   if (existing) {
     const alive = yield* proc.isPidRunning(existing.pid);
     if (!alive) {
@@ -89942,10 +90794,10 @@ function safeJsonParse2(text14) {
   }
 }
 var WsBridgeServerLive = succeed10(WsBridgeServer, {
-  listen: ({ port: port3, path: path17, host }) => acquireRelease2(gen2(function* () {
+  listen: ({ port: port3, path: path20, host }) => acquireRelease2(gen2(function* () {
     const events = yield* unbounded5();
     const sockets = new Map;
-    const wss = new import_websocket_server.default({ port: port3, host, path: path17 });
+    const wss = new import_websocket_server.default({ port: port3, host, path: path20 });
     wss.on("connection", (ws, req) => {
       const connId = randomUUID4();
       const remoteAddr = safeStringHeader(req?.socket?.remoteAddress);
@@ -89979,7 +90831,7 @@ var WsBridgeServerLive = succeed10(WsBridgeServer, {
     });
     const handle = {
       events,
-      serverInfo: { port: port3, path: path17 },
+      serverInfo: { port: port3, path: path20 },
       sendText: (connId, text14) => sync3(() => {
         const ws = sockets.get(connId);
         if (!ws)
@@ -90041,23 +90893,23 @@ var WsBridgeServerLive = succeed10(WsBridgeServer, {
     code: "WS_UNAVAILABLE",
     message: "Failed to start ws bridge server",
     exitCode: 1,
-    details: { error: String(error4?.message || error4), port: port3, path: path17, host }
+    details: { error: String(error4?.message || error4), port: port3, path: path20, host }
   }))))
 });
 
 // src/services/WsBridgeStateFile.ts
-import { promises as fs10 } from "node:fs";
-import path17 from "node:path";
+import { promises as fs13 } from "node:fs";
+import path20 from "node:path";
 class WsBridgeStateFile extends Tag2("WsBridgeStateFile")() {
 }
-async function ensureDir6(filePath) {
-  await fs10.mkdir(path17.dirname(filePath), { recursive: true });
+async function ensureDir7(filePath) {
+  await fs13.mkdir(path20.dirname(filePath), { recursive: true });
 }
 async function writeTextAtomic2(filePath, content) {
-  await ensureDir6(filePath);
+  await ensureDir7(filePath);
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs10.writeFile(tmp, content, "utf8");
-  await fs10.rename(tmp, filePath);
+  await fs13.writeFile(tmp, content, "utf8");
+  await fs13.rename(tmp, filePath);
 }
 var WsBridgeStateFileLive = succeed10(WsBridgeStateFile, {
   write: ({ filePath, json: json4 }) => tryPromise2({
@@ -90163,7 +91015,7 @@ var TmuxLive = scoped3(Tmux, gen2(function* () {
 }));
 
 // src/services/WsBridgeState.ts
-import { promises as fs11 } from "node:fs";
+import { promises as fs14 } from "node:fs";
 class WsBridgeState extends Tag2("WsBridgeState")() {
 }
 function toNonNegativeInt3(value8) {
@@ -90189,7 +91041,7 @@ var WsBridgeStateLive = succeed10(WsBridgeState, {
       return { connection: "off", selection: { kind: "none" } };
     }
     const raw4 = yield* tryPromise2({
-      try: async () => await fs11.readFile(cfg.wsStateFile.path, "utf8"),
+      try: async () => await fs14.readFile(cfg.wsStateFile.path, "utf8"),
       catch: (e) => {
         if (e?.code === "ENOENT")
           return null;
@@ -90602,18 +91454,18 @@ function parseWsUrl(url2) {
   }
   const port3 = u.port ? Number(u.port) : u.protocol === "wss:" ? 443 : 80;
   const host = u.hostname && u.hostname.length > 0 ? u.hostname : "localhost";
-  const path18 = u.pathname && u.pathname.length > 0 ? u.pathname : "/ws";
+  const path21 = u.pathname && u.pathname.length > 0 ? u.pathname : "/ws";
   if (!Number.isFinite(port3) || port3 <= 0) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid wsUrl port: ${url2}`, exitCode: 2 });
   }
-  if (!path18.startsWith("/")) {
+  if (!path21.startsWith("/")) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid wsUrl path: ${url2}`, exitCode: 2 });
   }
-  return { host, port: port3, path: path18 };
+  return { host, port: port3, path: path21 };
 }
 var wsServeCommand = exports_Command.make("serve", {}, () => gen2(function* () {
   const cfg = yield* AppConfig;
-  const { host, port: port3, path: path18 } = yield* try_3({
+  const { host, port: port3, path: path21 } = yield* try_3({
     try: () => parseWsUrl(cfg.wsUrl),
     catch: (e) => isCliError(e) ? e : new CliError({
       code: "INVALID_ARGS",
@@ -90622,7 +91474,7 @@ var wsServeCommand = exports_Command.make("serve", {}, () => gen2(function* () {
       details: { ws_url: cfg.wsUrl, error: String(e?.message || e) }
     })
   });
-  yield* runWsBridgeRuntime({ host, port: port3, path: path18 });
+  yield* runWsBridgeRuntime({ host, port: port3, path: path21 });
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/ws/start.ts
@@ -90638,14 +91490,14 @@ function parseWsUrl2(url2) {
   }
   const port3 = u.port ? Number(u.port) : u.protocol === "wss:" ? 443 : 80;
   const host = u.hostname && u.hostname.length > 0 ? u.hostname : "localhost";
-  const path18 = u.pathname && u.pathname.length > 0 ? u.pathname : "/ws";
+  const path21 = u.pathname && u.pathname.length > 0 ? u.pathname : "/ws";
   if (!Number.isFinite(port3) || port3 <= 0) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid wsUrl port: ${url2}`, exitCode: 2 });
   }
-  if (!path18.startsWith("/")) {
+  if (!path21.startsWith("/")) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid wsUrl path: ${url2}`, exitCode: 2 });
   }
-  return { host, port: port3, path: path18 };
+  return { host, port: port3, path: path21 };
 }
 var pidFile4 = text9("pid-file").pipe(optional5, map34(optionToUndefined4));
 var logFile3 = text9("log-file").pipe(optional5, map34(optionToUndefined4));
@@ -90657,7 +91509,7 @@ var wsStartCommand = exports_Command.make("start", {
 }, ({ foreground, wait, pidFile: pidFile5, logFile: logFile4 }) => gen2(function* () {
   const cfg = yield* AppConfig;
   if (foreground) {
-    const { host, port: port3, path: path18 } = yield* try_3({
+    const { host, port: port3, path: path21 } = yield* try_3({
       try: () => parseWsUrl2(cfg.wsUrl),
       catch: (e) => isCliError(e) ? e : new CliError({
         code: "INVALID_ARGS",
@@ -90666,7 +91518,7 @@ var wsStartCommand = exports_Command.make("start", {
         details: { ws_url: cfg.wsUrl, error: String(e?.message || e) }
       })
     });
-    yield* runWsBridgeRuntime({ host, port: port3, path: path18 });
+    yield* runWsBridgeRuntime({ host, port: port3, path: path21 });
     return;
   }
   const result = yield* startWsSupervisor({ waitMs: wait, pidFile: pidFile5, logFile: logFile4 });
@@ -90681,7 +91533,7 @@ var wsStartCommand = exports_Command.make("start", {
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/ws/status.ts
-import path18 from "node:path";
+import path21 from "node:path";
 function optionToUndefined5(opt) {
   return isSome2(opt) ? opt.value : undefined;
 }
@@ -90700,14 +91552,14 @@ var wsStatusCommand = exports_Command.make("status", { pidFile: pidFile5 }, ({ p
     if (!alive) {
       const stalePidInfo = pidInfo;
       yield* daemonFiles.deletePidFile(pidFilePath);
-      const staleStateFilePath = resolveUserFilePath(pidInfo.state_file ?? path18.join(path18.dirname(pidFilePath), "ws.state.json"));
+      const staleStateFilePath = resolveUserFilePath(pidInfo.state_file ?? path21.join(path21.dirname(pidFilePath), "ws.state.json"));
       yield* supervisorState.deleteStateFile(staleStateFilePath);
       selfHealCleanup = yield* cleanupStatuslineArtifacts(resolveStatuslineArtifactPaths({ cfg, pidInfo: stalePidInfo }));
       yield* sync3(() => refreshTmuxStatusLine());
       pidInfo = undefined;
     }
   }
-  const stateFilePath = resolveUserFilePath(pidInfo?.state_file ?? path18.join(path18.dirname(pidFilePath), "ws.state.json"));
+  const stateFilePath = resolveUserFilePath(pidInfo?.state_file ?? path21.join(path21.dirname(pidFilePath), "ws.state.json"));
   const state = yield* supervisorState.readStateFile(stateFilePath);
   const mode = pidInfo ? pidInfo.mode ?? "legacy" : "supervisor";
   const supervisorPid = pidInfo?.pid;
@@ -90870,7 +91722,7 @@ var wsStatusLineCommand = exports_Command.make("status-line", { stateFile, stale
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/ws/stop.ts
-import path19 from "node:path";
+import path22 from "node:path";
 function optionToUndefined7(opt) {
   return isSome2(opt) ? opt.value : undefined;
 }
@@ -90898,7 +91750,7 @@ var wsStopCommand = exports_Command.make("stop", { force: boolean8("force"), pid
     });
     return;
   }
-  const stateFilePath = resolveUserFilePath(existing.state_file ?? path19.join(path19.dirname(pidFilePath), "ws.state.json"));
+  const stateFilePath = resolveUserFilePath(existing.state_file ?? path22.join(path22.dirname(pidFilePath), "ws.state.json"));
   const alive = yield* proc.isPidRunning(existing.pid);
   if (!alive) {
     yield* daemonFiles.deletePidFile(pidFilePath);
@@ -91092,8 +91944,8 @@ var ChildProcessLive = succeed10(ChildProcess2, {
 });
 
 // src/services/LogWriter.ts
-import { promises as fs12 } from "node:fs";
-import path20 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path23 from "node:path";
 class LogWriterFactory extends Tag2("LogWriterFactory")() {
 }
 function sanitizePositiveInt(value8, fallback) {
@@ -91104,12 +91956,12 @@ function sanitizeMaxBytes(value8, fallback) {
     return null;
   return Number.isFinite(value8) && value8 > 0 ? Math.floor(value8) : fallback;
 }
-async function ensureDir7(filePath) {
-  await fs12.mkdir(path20.dirname(filePath), { recursive: true });
+async function ensureDir8(filePath) {
+  await fs15.mkdir(path23.dirname(filePath), { recursive: true });
 }
 async function safeStat(filePath) {
   try {
-    const s = await fs12.stat(filePath);
+    const s = await fs15.stat(filePath);
     return { size: s.size };
   } catch {
     return;
@@ -91118,25 +91970,25 @@ async function safeStat(filePath) {
 async function rotateFiles(filePath, keep) {
   if (keep <= 0)
     return;
-  const dir2 = path20.dirname(filePath);
-  const base = path20.basename(filePath);
+  const dir2 = path23.dirname(filePath);
+  const base = path23.basename(filePath);
   let entries2 = [];
   try {
-    entries2 = await fs12.readdir(dir2);
+    entries2 = await fs15.readdir(dir2);
   } catch {
     return;
   }
-  const rotated = entries2.filter((name) => name.startsWith(`${base}.`)).map((name) => path20.join(dir2, name)).sort().reverse();
+  const rotated = entries2.filter((name) => name.startsWith(`${base}.`)).map((name) => path23.join(dir2, name)).sort().reverse();
   for (const p3 of rotated.slice(keep)) {
     try {
-      await fs12.unlink(p3);
+      await fs15.unlink(p3);
     } catch {}
   }
 }
 async function createLogWriter(filePath, options6) {
   const maxBytes = sanitizeMaxBytes(options6.maxBytes, 20 * 1024 * 1024);
   const keep = sanitizePositiveInt(options6.keep, 5);
-  await ensureDir7(filePath);
+  await ensureDir8(filePath);
   let currentSize = (await safeStat(filePath))?.size ?? 0;
   let handle;
   let closing = false;
@@ -91145,7 +91997,7 @@ async function createLogWriter(filePath, options6) {
   async function openIfNeeded() {
     if (handle)
       return handle;
-    handle = await fs12.open(filePath, "a");
+    handle = await fs15.open(filePath, "a");
     return handle;
   }
   async function rotateIfNeeded(nextBytes) {
@@ -91159,7 +92011,7 @@ async function createLogWriter(filePath, options6) {
     handle = undefined;
     const rotatedPath = `${filePath}.${Date.now()}`;
     try {
-      await fs12.rename(filePath, rotatedPath);
+      await fs15.rename(filePath, rotatedPath);
     } catch {}
     currentSize = 0;
     await rotateFiles(filePath, keep);
@@ -91567,7 +92419,7 @@ var dailySummaryCommand = exports_Command.make("summary", { days: days2, maxLine
 }).pipe(catchAll2(writeFailure)));
 
 // src/services/FileInput.ts
-import { promises as fs13 } from "node:fs";
+import { promises as fs16 } from "node:fs";
 class FileInput extends Tag2("FileInput")() {
 }
 var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
@@ -91603,7 +92455,7 @@ async function readTextFromFilePath(pathSpec, maxBytes) {
   }
   const resolved = resolveUserFilePath(trimmed2);
   try {
-    const stat3 = await fs13.stat(resolved);
+    const stat3 = await fs16.stat(resolved);
     if (!stat3.isFile()) {
       throw new CliError({ code: "INVALID_ARGS", message: `Not a file: ${resolved}`, exitCode: 2 });
     }
@@ -91615,7 +92467,7 @@ async function readTextFromFilePath(pathSpec, maxBytes) {
         details: { bytes: stat3.size, max_bytes: maxBytes, file: resolved }
       });
     }
-    return await fs13.readFile(resolved, "utf8");
+    return await fs16.readFile(resolved, "utf8");
   } catch (error4) {
     if (isCliError(error4))
       throw error4;
@@ -91659,7 +92511,7 @@ var FileInputLive = succeed10(FileInput, {
 });
 
 // src/services/Payload.ts
-import { promises as fs14 } from "node:fs";
+import { promises as fs17 } from "node:fs";
 class Payload extends Tag2("Payload")() {
 }
 var MAX_PAYLOAD_BYTES = 5 * 1024 * 1024;
@@ -91700,7 +92552,7 @@ async function readPayloadSpec(spec) {
     if (!filePath) {
       throw new CliError({ code: "INVALID_ARGS", message: "Payload file path cannot be empty", exitCode: 2 });
     }
-    return await fs14.readFile(filePath, "utf8");
+    return await fs17.readFile(filePath, "utf8");
   }
   return spec;
 }
@@ -92496,86 +93348,29 @@ var dbRecentCommand = exports_Command.make("recent", {
           ids3.push(row.id);
           const marker = row.edited_after_create ? " (edited after creation)" : "";
           mdLines.push(`- \`${msToLocalStr(row.created_at)}\` ${row.preview} \`${row.id}\`${marker}`);
-        }
-        mdLines.push("");
-      }
-    }
-  }
-  const data = {
-    db_path: dbPath,
-    resolution: result.info.source,
-    days: d,
-    cutoff_ms: cutoffMs,
-    counts: result.result.counts,
-    items: result.result.items
-  };
-  yield* writeSuccess({ data, ids: ids3, md: mdLines.join(`
-`).trimEnd() + `
-` });
-}).pipe(catchAll2(writeFailure)));
-
-// src/commands/read/db/index.ts
-var readDbCommand = exports_Command.make("db", {}).pipe(exports_Command.withSubcommands([dbBackupsCommand, dbRecentCommand]));
-
-// src/commands/db/index.ts
-var dbCommand = readDbCommand;
-
-// src/lib/remnote.ts
-import fs15 from "node:fs";
-import path21 from "node:path";
-function tryParseRemnoteLink(input) {
-  const raw4 = input.trim();
-  let u;
-  try {
-    u = new URL(raw4);
-  } catch {
-    return;
-  }
-  if (u.protocol === "remnote:" && u.hostname === "w") {
-    const parts2 = u.pathname.split("/").filter(Boolean);
-    const workspaceId = parts2.length >= 1 ? parts2[0] : undefined;
-    const remId = parts2.length >= 2 ? parts2[1] : undefined;
-    if (workspaceId && remId) {
-      return { workspaceId: workspaceId.trim(), remId: remId.trim() };
-    }
-    return;
-  }
-  if ((u.protocol === "https:" || u.protocol === "http:") && u.hostname.endsWith("remnote.com")) {
-    const parts2 = u.pathname.split("/").filter(Boolean);
-    if (parts2.length >= 3 && parts2[0] === "w") {
-      const workspaceId = parts2[1];
-      const remId = parts2[2];
-      if (workspaceId && remId) {
-        return { workspaceId: workspaceId.trim(), remId: remId.trim() };
-      }
-    }
-  }
-  return;
-}
-function tryParseRemnoteLinkFromRef(input) {
-  const direct = tryParseRemnoteLink(input);
-  if (direct)
-    return direct;
-  const raw4 = input.trim();
-  const idx = raw4.indexOf(":");
-  if (idx <= 0)
-    return;
-  const value8 = raw4.slice(idx + 1).trim();
-  if (!value8)
-    return;
-  return tryParseRemnoteLink(value8);
-}
-function remnoteDbPathForWorkspaceId(workspaceId) {
-  return path21.join(homeDir(), "remnote", `remnote-${workspaceId}`, "remnote.db");
-}
-function tryResolveRemnoteDbPathForWorkspaceIdSync(workspaceId) {
-  const p3 = remnoteDbPathForWorkspaceId(workspaceId);
-  try {
-    return fs15.statSync(p3).isFile() ? p3 : undefined;
-  } catch {
-    return;
+        }
+        mdLines.push("");
+      }
+    }
   }
-}
+  const data = {
+    db_path: dbPath,
+    resolution: result.info.source,
+    days: d,
+    cutoff_ms: cutoffMs,
+    counts: result.result.counts,
+    items: result.result.items
+  };
+  yield* writeSuccess({ data, ids: ids3, md: mdLines.join(`
+`).trimEnd() + `
+` });
+}).pipe(catchAll2(writeFailure)));
+
+// src/commands/read/db/index.ts
+var readDbCommand = exports_Command.make("db", {}).pipe(exports_Command.withSubcommands([dbBackupsCommand, dbRecentCommand]));
+
+// src/commands/db/index.ts
+var dbCommand = readDbCommand;
 
 // src/services/RefResolver.ts
 class RefResolver extends Tag2("RefResolver")() {
@@ -93713,12 +94508,12 @@ var applyCommand = exports_Command.make("apply", {
 }).pipe(catchAll2(writeFailure)));
 
 // src/services/ApiDaemonFiles.ts
-import { promises as fs16 } from "node:fs";
-import path22 from "node:path";
+import { promises as fs18 } from "node:fs";
+import path24 from "node:path";
 class ApiDaemonFiles extends Tag2("ApiDaemonFiles")() {
 }
-function ensureDir8(p3) {
-  return fs16.mkdir(path22.dirname(p3), { recursive: true }).then(() => {
+function ensureDir9(p3) {
+  return fs18.mkdir(path24.dirname(p3), { recursive: true }).then(() => {
     return;
   });
 }
@@ -93726,19 +94521,19 @@ function defaultPidFile2() {
   const envPidFile = process.env.REMNOTE_API_PID_FILE;
   if (typeof envPidFile === "string" && envPidFile.trim())
     return resolveUserFilePath(envPidFile);
-  return path22.join(homeDir(), ".agent-remnote", "api.pid");
+  return path24.join(homeDir(), ".agent-remnote", "api.pid");
 }
 function defaultLogFile2() {
   const envLogFile = process.env.REMNOTE_API_LOG_FILE;
   if (typeof envLogFile === "string" && envLogFile.trim())
     return resolveUserFilePath(envLogFile);
-  return path22.join(homeDir(), ".agent-remnote", "api.log");
+  return path24.join(homeDir(), ".agent-remnote", "api.log");
 }
 function defaultStateFile2() {
   const envStateFile = process.env.REMNOTE_API_STATE_FILE;
   if (typeof envStateFile === "string" && envStateFile.trim())
     return resolveUserFilePath(envStateFile);
-  return path22.join(homeDir(), ".agent-remnote", "api.state.json");
+  return path24.join(homeDir(), ".agent-remnote", "api.state.json");
 }
 function parseJson2(raw4, filePath) {
   try {
@@ -93759,7 +94554,7 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   readPidFile: (pidFilePath) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(pidFilePath);
-      const raw4 = await fs16.readFile(resolved, "utf8");
+      const raw4 = await fs18.readFile(resolved, "utf8");
       return parseJson2(raw4, resolved);
     },
     catch: (error4) => {
@@ -93783,8 +94578,8 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   writePidFile: (pidFilePath, value8) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(pidFilePath);
-      await ensureDir8(resolved);
-      await fs16.writeFile(resolved, `${JSON.stringify(value8, null, 2)}
+      await ensureDir9(resolved);
+      await fs18.writeFile(resolved, `${JSON.stringify(value8, null, 2)}
 `, "utf8");
     },
     catch: (error4) => new CliError({
@@ -93797,7 +94592,7 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   deletePidFile: (pidFilePath) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(pidFilePath);
-      await fs16.rm(resolved, { force: true });
+      await fs18.rm(resolved, { force: true });
     },
     catch: (error4) => new CliError({
       code: "INTERNAL",
@@ -93809,7 +94604,7 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   readStateFile: (stateFilePath) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(stateFilePath);
-      const raw4 = await fs16.readFile(resolved, "utf8");
+      const raw4 = await fs18.readFile(resolved, "utf8");
       return parseJson2(raw4, resolved);
     },
     catch: (error4) => {
@@ -93833,8 +94628,8 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   writeStateFile: (stateFilePath, value8) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(stateFilePath);
-      await ensureDir8(resolved);
-      await fs16.writeFile(resolved, `${JSON.stringify(value8, null, 2)}
+      await ensureDir9(resolved);
+      await fs18.writeFile(resolved, `${JSON.stringify(value8, null, 2)}
 `, "utf8");
     },
     catch: (error4) => new CliError({
@@ -93847,7 +94642,7 @@ var ApiDaemonFilesLive = succeed10(ApiDaemonFiles, {
   deleteStateFile: (stateFilePath) => tryPromise2({
     try: async () => {
       const resolved = resolveUserFilePath(stateFilePath);
-      await fs16.rm(resolved, { force: true });
+      await fs18.rm(resolved, { force: true });
     },
     catch: (error4) => new CliError({
       code: "INTERNAL",
@@ -95873,8 +96668,8 @@ function resolveRefsInPayload(params3) {
     const out = structuredClone(params3.payload);
     const resolvedRefCache = new Map;
     const idPaths = idFieldPathsForOpType(params3.opType);
-    for (const path23 of idPaths) {
-      const tokens = parsePathTokens(path23);
+    for (const path25 of idPaths) {
+      const tokens = parsePathTokens(path25);
       if (tokens.length === 0)
         continue;
       const leaves = collectLeafValues(out, tokens);
@@ -102648,7 +103443,7 @@ var stackEnsureCommand = exports_Command.make("ensure", {
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/stack/status.ts
-import path23 from "node:path";
+import path25 from "node:path";
 var stackStatusCommand = exports_Command.make("status", {}, () => gen2(function* () {
   const cfg = yield* AppConfig;
   const daemonFiles = yield* DaemonFiles;
@@ -102668,7 +103463,7 @@ var stackStatusCommand = exports_Command.make("status", {}, () => gen2(function*
   const apiBaseUrl = apiLocalBaseUrl(apiPidInfo?.port ?? cfg.apiPort ?? 3000);
   const apiStatus = yield* api.status({ baseUrl: apiBaseUrl, timeoutMs: 2000 }).pipe(either3);
   const queueStats2 = yield* queue.stats({ dbPath: cfg.storeDb }).pipe(either3);
-  const stateFilePath = resolveUserFilePath(daemonPidInfo?.state_file ?? path23.join(path23.dirname(daemonPidFile), "ws.state.json"));
+  const stateFilePath = resolveUserFilePath(daemonPidInfo?.state_file ?? path25.join(path25.dirname(daemonPidFile), "ws.state.json"));
   const data = {
     daemon: {
       running: daemonRunning,
@@ -102706,7 +103501,7 @@ var stackStatusCommand = exports_Command.make("status", {}, () => gen2(function*
 }).pipe(catchAll2(writeFailure)));
 
 // src/commands/stack/stop.ts
-import path24 from "node:path";
+import path26 from "node:path";
 var stackStopCommand = exports_Command.make("stop", {}, () => gen2(function* () {
   const apiFiles = yield* ApiDaemonFiles;
   const daemonFiles = yield* DaemonFiles;
@@ -102743,7 +103538,7 @@ var stackStopCommand = exports_Command.make("stop", {}, () => gen2(function* ()
     }
   }
   yield* daemonFiles.deletePidFile(daemonPidFile).pipe(catchAll2(() => _void));
-  yield* supervisorState.deleteStateFile(resolveUserFilePath(daemonPidInfo?.state_file ?? path24.join(path24.dirname(daemonPidFile), "ws.state.json"))).pipe(catchAll2(() => _void));
+  yield* supervisorState.deleteStateFile(resolveUserFilePath(daemonPidInfo?.state_file ?? path26.join(path26.dirname(daemonPidFile), "ws.state.json"))).pipe(catchAll2(() => _void));
   yield* writeSuccess({
     data: { stopped: true, api_stopped: apiStopped, daemon_stopped: daemonStopped },
     md: `- stopped: true
@@ -102756,242 +103551,6 @@ var stackStopCommand = exports_Command.make("stop", {}, () => gen2(function* ()
 // src/commands/stack/index.ts
 var stackCommand = exports_Command.make("stack", {}).pipe(exports_Command.withSubcommands([stackEnsureCommand, stackStopCommand, stackStatusCommand]));
 
-// src/services/Config.ts
-import fs17 from "node:fs";
-import path25 from "node:path";
-function defaultStoreDbPath() {
-  return path25.join(homeDir(), ".agent-remnote", "store.sqlite");
-}
-function wsUrlFromPort(port7) {
-  return `ws://localhost:${port7}/ws`;
-}
-function defaultWsStateFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "ws.bridge.state.json");
-}
-function defaultStatusLineFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "status-line.txt");
-}
-function defaultStatusLineJsonFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "status-line.json");
-}
-function defaultApiPidFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "api.pid");
-}
-function defaultApiLogFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "api.log");
-}
-function defaultApiStateFilePath() {
-  return path25.join(homeDir(), ".agent-remnote", "api.state.json");
-}
-function normalizeApiBasePath(raw4) {
-  const trimmed2 = raw4.trim();
-  if (!trimmed2)
-    return "/v1";
-  return trimmed2.startsWith("/") ? trimmed2 : `/${trimmed2}`;
-}
-function normalizeApiBaseUrl(raw4) {
-  const trimmed2 = raw4.trim();
-  if (!trimmed2)
-    return trimmed2;
-  let parsed;
-  try {
-    parsed = new URL(trimmed2);
-  } catch {
-    throw new CliError({
-      code: "INVALID_ARGS",
-      message: `Invalid apiBaseUrl: ${trimmed2}`,
-      exitCode: 2,
-      details: { api_base_url: trimmed2 }
-    });
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new CliError({
-      code: "INVALID_ARGS",
-      message: `apiBaseUrl protocol must be http/https: ${trimmed2}`,
-      exitCode: 2,
-      details: { api_base_url: trimmed2 }
-    });
-  }
-  const normalized = trimmed2.replace(/\/+$/, "");
-  return normalized;
-}
-function resolveWsStateFile(spec) {
-  const raw4 = spec.trim();
-  if (raw4 === "0" || raw4.toLowerCase() === "false") {
-    return { disabled: true, path: defaultWsStateFilePath() };
-  }
-  if (raw4)
-    return { disabled: false, path: resolveUserFilePath(raw4) };
-  return { disabled: false, path: defaultWsStateFilePath() };
-}
-function inferRemnoteDbFromWsState(params3) {
-  if (params3.wsStateFile.disabled)
-    return;
-  const state = readJson(params3.wsStateFile.path);
-  if (!state)
-    return;
-  const now2 = Date.now();
-  const updatedAt = Number(state.updatedAt ?? 0);
-  const staleMs13 = params3.wsStateStaleMs;
-  const stale = !Number.isFinite(updatedAt) || updatedAt <= 0 || now2 - updatedAt > staleMs13;
-  if (stale)
-    return;
-  const clients = Array.isArray(state.clients) ? state.clients : [];
-  const activeConnIdRaw = typeof state.activeWorkerConnId === "string" ? state.activeWorkerConnId.trim() : "";
-  const client = pickClient(clients, activeConnIdRaw || undefined);
-  const kbIdRaw = typeof client?.uiContext?.kbId === "string" ? client.uiContext.kbId.trim() : "";
-  if (!kbIdRaw)
-    return;
-  const dbPath = resolveUserFilePath(remnoteDbPathForWorkspaceId(kbIdRaw));
-  try {
-    return fs17.statSync(dbPath).isFile() ? dbPath : undefined;
-  } catch {
-    return;
-  }
-}
-function pickFormat(raw4) {
-  const json4 = raw4.json === true;
-  const md = raw4.md === true;
-  const ids6 = raw4.ids === true;
-  const count4 = [json4, md, ids6].filter(Boolean).length;
-  if (count4 > 1) {
-    throw new CliError({
-      code: "INVALID_ARGS",
-      message: "Output format conflict: choose only one of --json/--md/--ids",
-      exitCode: 2,
-      details: { json: json4, md, ids: ids6 }
-    });
-  }
-  if (json4)
-    return "json";
-  if (ids6)
-    return "ids";
-  return "md";
-}
-var rawConfigSpec = all8({
-  json: boolean4("json").pipe(withDefault2(false)),
-  md: boolean4("md").pipe(withDefault2(false)),
-  ids: boolean4("ids").pipe(withDefault2(false)),
-  quiet: boolean4("quiet").pipe(withDefault2(false)),
-  debug: boolean4("debug").pipe(withDefault2(false)),
-  remnoteDb: string5("remnoteDb").pipe(withDefault2("")),
-  storeDb: string5("storeDb").pipe(withDefault2(defaultStoreDbPath())),
-  daemonUrl: string5("daemonUrl").pipe(withDefault2("")),
-  wsPort: port2("wsPort").pipe(withDefault2(6789)),
-  wsScheduler: boolean4("wsScheduler").pipe(withDefault2(true)),
-  wsDispatchMaxBytes: integer2("wsDispatchMaxBytes").pipe(withDefault2(512000), validate3({
-    message: "wsDispatchMaxBytes must be a positive integer",
-    validation: (n) => Number.isFinite(n) && n > 0
-  })),
-  wsDispatchMaxOpBytes: integer2("wsDispatchMaxOpBytes").pipe(withDefault2(256000), validate3({
-    message: "wsDispatchMaxOpBytes must be a positive integer",
-    validation: (n) => Number.isFinite(n) && n > 0
-  })),
-  repo: string5("repo").pipe(withDefault2("")),
-  wsStateFile: string5("wsStateFile").pipe(withDefault2("")),
-  wsStateStaleMs: integer2("wsStateStaleMs").pipe(withDefault2(60000), validate3({
-    message: "wsStateStaleMs must be a positive integer",
-    validation: (n) => Number.isFinite(n) && n > 0
-  })),
-  tmuxRefresh: boolean4("tmuxRefresh").pipe(withDefault2(true)),
-  tmuxRefreshMinIntervalMs: integer2("tmuxRefreshMinIntervalMs").pipe(withDefault2(250), validate3({
-    message: "tmuxRefreshMinIntervalMs must be a positive integer",
-    validation: (n) => Number.isFinite(n) && n > 0
-  })),
-  statusLineFile: string5("statusLineFile").pipe(withDefault2(defaultStatusLineFilePath())),
-  statusLineMinIntervalMs: integer2("statusLineMinIntervalMs").pipe(withDefault2(250), validate3({
-    message: "statusLineMinIntervalMs must be a positive integer",
-    validation: (n) => Number.isFinite(n) && n > 0
-  })),
-  statusLineDebug: boolean4("statusLineDebug").pipe(withDefault2(false)),
-  statusLineJsonFile: string5("statusLineJsonFile").pipe(withDefault2(defaultStatusLineJsonFilePath())),
-  apiBaseUrl: string5("apiBaseUrl").pipe(withDefault2("")),
-  apiHost: string5("apiHost").pipe(withDefault2("0.0.0.0")),
-  apiPort: port2("apiPort").pipe(withDefault2(3000)),
-  apiBasePath: string5("apiBasePath").pipe(withDefault2("/v1")),
-  apiPidFile: string5("apiPidFile").pipe(withDefault2(defaultApiPidFilePath())),
-  apiLogFile: string5("apiLogFile").pipe(withDefault2(defaultApiLogFilePath())),
-  apiStateFile: string5("apiStateFile").pipe(withDefault2(defaultApiStateFilePath()))
-});
-function cliErrorFromConfigError(error4) {
-  if (isInvalidData2(error4) || isMissingData2(error4)) {
-    return new CliError({
-      code: "INVALID_ARGS",
-      message: error4.message || "Invalid configuration",
-      exitCode: 2,
-      details: { path: error4.path, op: error4._op }
-    });
-  }
-  return new CliError({
-    code: "INVALID_ARGS",
-    message: error4.message || "Invalid configuration",
-    exitCode: 2,
-    details: { op: error4._op }
-  });
-}
-function optionalTrimmed(s) {
-  const t = s.trim();
-  return t.length > 0 ? t : undefined;
-}
-function resolveConfig() {
-  return gen2(function* () {
-    const raw4 = yield* rawConfigSpec;
-    const wsStateFile = resolveWsStateFile(raw4.wsStateFile);
-    const remnoteDb = optionalTrimmed(raw4.remnoteDb) ? resolveUserFilePath(raw4.remnoteDb) : inferRemnoteDbFromWsState({ wsStateFile, wsStateStaleMs: raw4.wsStateStaleMs }) || undefined;
-    const storeDb = resolveUserFilePath(raw4.storeDb);
-    const daemonUrl = optionalTrimmed(raw4.daemonUrl);
-    const wsUrl = daemonUrl ? daemonUrl : wsUrlFromPort(raw4.wsPort);
-    const format10 = yield* try_3({
-      try: () => pickFormat(raw4),
-      catch: (e) => isCliError(e) ? e : new CliError({
-        code: "INVALID_ARGS",
-        message: "Invalid output format flags",
-        exitCode: 2,
-        details: { error: String(e?.message || e) }
-      })
-    });
-    const apiBaseUrl = optionalTrimmed(raw4.apiBaseUrl) ? normalizeApiBaseUrl(raw4.apiBaseUrl) : undefined;
-    return {
-      format: format10,
-      quiet: raw4.quiet,
-      debug: raw4.debug,
-      remnoteDb,
-      storeDb,
-      wsUrl,
-      wsScheduler: raw4.wsScheduler,
-      wsDispatchMaxBytes: raw4.wsDispatchMaxBytes,
-      wsDispatchMaxOpBytes: raw4.wsDispatchMaxOpBytes,
-      repo: optionalTrimmed(raw4.repo) ? resolveUserFilePath(raw4.repo) : undefined,
-      wsStateFile,
-      wsStateStaleMs: raw4.wsStateStaleMs,
-      tmuxRefresh: raw4.tmuxRefresh,
-      tmuxRefreshMinIntervalMs: raw4.tmuxRefreshMinIntervalMs,
-      statusLineFile: resolveUserFilePath(raw4.statusLineFile),
-      statusLineMinIntervalMs: raw4.statusLineMinIntervalMs,
-      statusLineDebug: raw4.statusLineDebug,
-      statusLineJsonFile: resolveUserFilePath(raw4.statusLineJsonFile),
-      apiBaseUrl,
-      apiHost: raw4.apiHost.trim() || "0.0.0.0",
-      apiPort: raw4.apiPort,
-      apiBasePath: normalizeApiBasePath(raw4.apiBasePath),
-      apiPidFile: resolveUserFilePath(raw4.apiPidFile),
-      apiLogFile: resolveUserFilePath(raw4.apiLogFile),
-      apiStateFile: resolveUserFilePath(raw4.apiStateFile)
-    };
-  }).pipe(catchAll2((error4) => {
-    if (isCliError(error4))
-      return fail8(error4);
-    if (isConfigError2(error4))
-      return fail8(cliErrorFromConfigError(error4));
-    return fail8(new CliError({
-      code: "INTERNAL",
-      message: "Failed to parse config",
-      exitCode: 1,
-      details: { error: String(error4?.message || error4) }
-    }));
-  }));
-}
-
 // src/commands/index.ts
 function optionToUndefined51(opt) {
   return isSome2(opt) ? opt.value : undefined;
@@ -103002,10 +103561,11 @@ var daemonUrl = text9("daemon-url").pipe(optional5, map34(optionToUndefined51));
 var wsPort = integer7("ws-port").pipe(optional5, map34(optionToUndefined51));
 var repo = text9("repo").pipe(optional5, map34(optionToUndefined51));
 var apiBaseUrl = text9("api-base-url").pipe(optional5, map34(optionToUndefined51));
+var configFile = text9("config-file").pipe(optional5, map34(optionToUndefined51));
 var appConfigLive = effect(AppConfig, resolveConfig());
 var statusLineUpdaterLive = StatusLineUpdaterLive.pipe(provide3([appConfigLive, QueueLive, StatusLineFileLive, TmuxLive, WsBridgeStateLive]));
 var statusLineLive = StatusLineControllerLive.pipe(provide3(statusLineUpdaterLive), provide3(appConfigLive));
-var servicesLive = mergeAll5(appConfigLive, OutputLive, FileInputLive, FsAccessLive, LogWriterFactoryLive, PayloadLive, DaemonFilesLive, ApiDaemonFilesLive, ProcessLive, ChildProcessLive, WsClientLive, HostApiClientLive, QueueLive, RefResolverLive, RemDbLive, StatusLineFileLive, SubprocessLive, SupervisorStateLive, WsBridgeServerLive, WsBridgeStateFileLive, statusLineLive);
+var servicesLive = mergeAll5(appConfigLive, OutputLive, FileInputLive, FsAccessLive, LogWriterFactoryLive, PayloadLive, DaemonFilesLive, ApiDaemonFilesLive, ProcessLive, ChildProcessLive, WsClientLive, HostApiClientLive, UserConfigFileLive, QueueLive, RefResolverLive, RemDbLive, StatusLineFileLive, SubprocessLive, SupervisorStateLive, WsBridgeServerLive, WsBridgeStateFileLive, statusLineLive);
 var rootCommand = exports_Command.make("agent-remnote", {
   json: boolean8("json"),
   md: boolean8("md"),
@@ -103017,7 +103577,8 @@ var rootCommand = exports_Command.make("agent-remnote", {
   daemonUrl,
   wsPort,
   repo,
-  apiBaseUrl
+  apiBaseUrl,
+  configFile
 }).pipe(exports_Command.withSubcommands([
   daemonCommand,
   apiCommand,
@@ -103119,6 +103680,9 @@ function buildCliEnvConfigProvider(params3) {
   const envApiBaseUrl = env2.REMNOTE_API_BASE_URL;
   if (typeof envApiBaseUrl === "string" && envApiBaseUrl.trim())
     map39.set("apiBaseUrl", envApiBaseUrl);
+  const envConfigFile = env2.REMNOTE_CONFIG_FILE || env2.AGENT_REMNOTE_CONFIG_FILE;
+  if (typeof envConfigFile === "string" && envConfigFile.trim())
+    map39.set("configFile", envConfigFile);
   const envApiHost = env2.REMNOTE_API_HOST;
   if (typeof envApiHost === "string" && envApiHost.trim())
     map39.set("apiHost", envApiHost);
@@ -103215,17 +103779,18 @@ function buildCommandTree(desc) {
   }
   return { name, children: children2 };
 }
-var ROOT_BOOL_FLAGS = new Set(["--json", "--md", "--ids", "--quiet", "--debug"]);
-var BUILTIN_BOOL_FLAGS = new Set(["--help", "-h", "--wizard", "--version"]);
-var BUILTIN_VALUE_FLAGS = new Set(["--completions", "--log-level"]);
-var ROOT_VALUE_FLAGS = new Set([
+var ROOT_BOOL_FLAGS2 = new Set(["--json", "--md", "--ids", "--quiet", "--debug"]);
+var BUILTIN_BOOL_FLAGS2 = new Set(["--help", "-h", "--wizard", "--version"]);
+var BUILTIN_VALUE_FLAGS2 = new Set(["--completions", "--log-level"]);
+var ROOT_VALUE_FLAGS2 = new Set([
   "--remnote-db",
   "--store-db",
   "--daemon-url",
   "--ws-port",
   "--repo",
   "--api-base-url",
-  ...BUILTIN_VALUE_FLAGS
+  "--config-file",
+  ...BUILTIN_VALUE_FLAGS2
 ]);
 function parseRootConfigFromArgv(argv2) {
   const tokens = argv2.slice(2);
@@ -103239,8 +103804,8 @@ function parseRootConfigFromArgv(argv2) {
       break;
     if (!raw4.startsWith("-"))
       break;
-    const { flag, inlineValue } = splitFlagInlineValue(raw4);
-    if (ROOT_BOOL_FLAGS.has(flag)) {
+    const { flag, inlineValue } = splitFlagInlineValue2(raw4);
+    if (ROOT_BOOL_FLAGS2.has(flag)) {
       const key = flag.slice(2);
       if (inlineValue !== null) {
         out.set(key, inlineValue.trim().toLowerCase());
@@ -103248,7 +103813,7 @@ function parseRootConfigFromArgv(argv2) {
         continue;
       }
       const next4 = tokens[i + 1];
-      if (typeof next4 === "string" && isBooleanLiteralToken(next4)) {
+      if (typeof next4 === "string" && isBooleanLiteralToken2(next4)) {
         out.set(key, next4.trim().toLowerCase());
         i += 2;
         continue;
@@ -103257,8 +103822,8 @@ function parseRootConfigFromArgv(argv2) {
       i += 1;
       continue;
     }
-    if (ROOT_VALUE_FLAGS.has(flag)) {
-      const key = flag === "--remnote-db" ? "remnoteDb" : flag === "--store-db" ? "storeDb" : flag === "--daemon-url" ? "daemonUrl" : flag === "--ws-port" ? "wsPort" : flag === "--repo" ? "repo" : flag === "--api-base-url" ? "apiBaseUrl" : null;
+    if (ROOT_VALUE_FLAGS2.has(flag)) {
+      const key = flag === "--remnote-db" ? "remnoteDb" : flag === "--store-db" ? "storeDb" : flag === "--daemon-url" ? "daemonUrl" : flag === "--ws-port" ? "wsPort" : flag === "--repo" ? "repo" : flag === "--api-base-url" ? "apiBaseUrl" : flag === "--config-file" ? "configFile" : null;
       if (inlineValue !== null) {
         if (key)
           out.set(key, inlineValue);
@@ -103273,13 +103838,13 @@ function parseRootConfigFromArgv(argv2) {
       i += 2;
       continue;
     }
-    if (BUILTIN_BOOL_FLAGS.has(flag)) {
+    if (BUILTIN_BOOL_FLAGS2.has(flag)) {
       if (inlineValue !== null) {
         i += 1;
         continue;
       }
       const next4 = tokens[i + 1];
-      if (typeof next4 === "string" && isBooleanLiteralToken(next4)) {
+      if (typeof next4 === "string" && isBooleanLiteralToken2(next4)) {
         i += 2;
         continue;
       }
@@ -103290,11 +103855,11 @@ function parseRootConfigFromArgv(argv2) {
   }
   return out;
 }
-function isBooleanLiteralToken(token) {
+function isBooleanLiteralToken2(token) {
   const v = token.trim().toLowerCase();
   return v === "true" || v === "false";
 }
-function splitFlagInlineValue(token) {
+function splitFlagInlineValue2(token) {
   if (!token.startsWith("--"))
     return { flag: token, inlineValue: null };
   const eq = token.indexOf("=");
@@ -103303,7 +103868,7 @@ function splitFlagInlineValue(token) {
   return { flag: token.slice(0, eq), inlineValue: token.slice(eq + 1) };
 }
 function isKnownRootFlag(flag) {
-  return ROOT_BOOL_FLAGS.has(flag) || ROOT_VALUE_FLAGS.has(flag) || BUILTIN_BOOL_FLAGS.has(flag);
+  return ROOT_BOOL_FLAGS2.has(flag) || ROOT_VALUE_FLAGS2.has(flag) || BUILTIN_BOOL_FLAGS2.has(flag);
 }
 function consumeRootFlag(tokens, index) {
   const raw4 = String(tokens[index] ?? "");
@@ -103313,14 +103878,14 @@ function consumeRootFlag(tokens, index) {
       error: new CliError({ code: "INVALID_ARGS", message: "Received unknown argument: ''", exitCode: 2 })
     };
   }
-  const { flag, inlineValue } = splitFlagInlineValue(raw4);
+  const { flag, inlineValue } = splitFlagInlineValue2(raw4);
   if (!isKnownRootFlag(flag)) {
     return {
       nextIndex: index + 1,
       error: new CliError({ code: "INVALID_ARGS", message: `Received unknown argument: '${raw4}'`, exitCode: 2 })
     };
   }
-  if (ROOT_VALUE_FLAGS.has(flag)) {
+  if (ROOT_VALUE_FLAGS2.has(flag)) {
     if (inlineValue !== null)
       return { nextIndex: index + 1, error: null };
     if (index + 1 >= tokens.length) {
@@ -103335,8 +103900,8 @@ function consumeRootFlag(tokens, index) {
     }
     return { nextIndex: index + 2, error: null };
   }
-  if (ROOT_BOOL_FLAGS.has(flag) || BUILTIN_BOOL_FLAGS.has(flag)) {
-    if (inlineValue !== null && !isBooleanLiteralToken(inlineValue)) {
+  if (ROOT_BOOL_FLAGS2.has(flag) || BUILTIN_BOOL_FLAGS2.has(flag)) {
+    if (inlineValue !== null && !isBooleanLiteralToken2(inlineValue)) {
       return {
         nextIndex: index + 1,
         error: new CliError({
@@ -103349,7 +103914,7 @@ function consumeRootFlag(tokens, index) {
     if (inlineValue !== null)
       return { nextIndex: index + 1, error: null };
     const next4 = tokens[index + 1];
-    if (typeof next4 === "string" && isBooleanLiteralToken(next4))
+    if (typeof next4 === "string" && isBooleanLiteralToken2(next4))
       return { nextIndex: index + 2, error: null };
     return { nextIndex: index + 1, error: null };
   }
@@ -103357,8 +103922,8 @@ function consumeRootFlag(tokens, index) {
 }
 function consumeBuiltInFlag(tokens, index) {
   const raw4 = String(tokens[index] ?? "");
-  const { flag, inlineValue } = splitFlagInlineValue(raw4);
-  if (BUILTIN_VALUE_FLAGS.has(flag)) {
+  const { flag, inlineValue } = splitFlagInlineValue2(raw4);
+  if (BUILTIN_VALUE_FLAGS2.has(flag)) {
     if (inlineValue !== null)
       return { ok: true, nextIndex: index + 1, error: null };
     if (index + 1 >= tokens.length) {
@@ -103374,8 +103939,8 @@ function consumeBuiltInFlag(tokens, index) {
     }
     return { ok: true, nextIndex: index + 2, error: null };
   }
-  if (BUILTIN_BOOL_FLAGS.has(flag)) {
-    if (inlineValue !== null && !isBooleanLiteralToken(inlineValue)) {
+  if (BUILTIN_BOOL_FLAGS2.has(flag)) {
+    if (inlineValue !== null && !isBooleanLiteralToken2(inlineValue)) {
       return {
         ok: true,
         nextIndex: index + 1,
@@ -103389,7 +103954,7 @@ function consumeBuiltInFlag(tokens, index) {
     if (inlineValue !== null)
       return { ok: true, nextIndex: index + 1, error: null };
     const next4 = tokens[index + 1];
-    if (typeof next4 === "string" && isBooleanLiteralToken(next4))
+    if (typeof next4 === "string" && isBooleanLiteralToken2(next4))
       return { ok: true, nextIndex: index + 2, error: null };
     return { ok: true, nextIndex: index + 1, error: null };
   }
@@ -103442,8 +104007,8 @@ function strictCliPreflight(tree, argv2) {
         i = builtIn2.nextIndex;
         continue;
       }
-      const { flag } = splitFlagInlineValue(t);
-      if (isKnownRootFlag(flag) && !BUILTIN_BOOL_FLAGS.has(flag) && !BUILTIN_VALUE_FLAGS.has(flag)) {
+      const { flag } = splitFlagInlineValue2(t);
+      if (isKnownRootFlag(flag) && !BUILTIN_BOOL_FLAGS2.has(flag) && !BUILTIN_VALUE_FLAGS2.has(flag)) {
         return new CliError({
           code: "INVALID_ARGS",
           message: `Global option '${flag}' must be specified before the first subcommand`,
@@ -103652,7 +104217,7 @@ function strictCommandPreflightOrExit(argv2) {
   if (jsonRequested) {
     const tokens = argv2.slice(2);
     const outputBuiltins = new Set(["--help", "-h", "--version", "--wizard", "--completions"]);
-    const conflict = tokens.map((t) => splitFlagInlineValue(String(t)).flag).find((flag) => outputBuiltins.has(flag));
+    const conflict = tokens.map((t) => splitFlagInlineValue2(String(t)).flag).find((flag) => outputBuiltins.has(flag));
     if (conflict) {
       const error5 = new CliError({
         code: "INVALID_ARGS",