very-happy-cli 0.2.124 → 0.2.126

package/dist/{types-CZIwVSN2.cjs → types-P5deH8Ls.cjs}

@@ -1,33 +1,32 @@
 'use strict';
 
 var axios = require('axios');
-var chalk = require('chalk');
-var node_util = require('node:util');
-var node_fs = require('node:fs');
-var os = require('node:os');
-var path = require('node:path');
-var promises = require('node:fs/promises');
+var persistence = require('./limits-DG1OQnCb.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
 var cuid2 = require('@paralleldrive/cuid2');
 var node_crypto = require('node:crypto');
-var tweetnacl = require('tweetnacl');
-var limits = require('./limits-KdWKmwtH.cjs');
 var child_process = require('child_process');
 var util = require('util');
 var fs = require('fs/promises');
 var crypto = require('crypto');
-var path$1 = require('path');
+var path = require('path');
 var spawn = require('cross-spawn');
 var url = require('url');
-var os$1 = require('os');
+var os = require('os');
+var promises = require('node:fs/promises');
+var path$1 = require('node:path');
+var os$1 = require('node:os');
 var node_child_process = require('node:child_process');
 var pty = require('node-pty');
+var node_fs = require('node:fs');
 var fs$1 = require('fs');
+var tweetnacl = require('tweetnacl');
 var node_readline = require('node:readline');
 var sandboxRuntime = require('@anthropic-ai/sandbox-runtime');
 var expoServerSdk = require('expo-server-sdk');
+var chalk = require('chalk');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
@@ -50,599 +49,6 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 var pty__namespace = /*#__PURE__*/_interopNamespaceDefault(pty);
 
-var name = "very-happy-cli";
-var version = "0.2.124";
-var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
-var author = "Kirill Dubovitskiy";
-var contributors = [
-	"Mereith (very-happy-cli fork)"
-];
-var license = "MIT";
-var engines = {
-	node: "^20.19.0 || ^22.13.0 || >=24.0.0"
-};
-var type = "module";
-var homepage = "https://github.com/Mereithhh/very-happy";
-var bugs = "https://github.com/Mereithhh/very-happy/issues";
-var repository = {
-	type: "git",
-	url: "git+https://github.com/Mereithhh/very-happy.git"
-};
-var bin = {
-	"very-happy": "./bin/very-happy.mjs",
-	"very-happy-mcp": "./bin/very-happy-mcp.mjs"
-};
-var main = "./dist/index.cjs";
-var module$1 = "./dist/index.mjs";
-var types = "./dist/index.d.cts";
-var exports$1 = {
-	".": {
-		require: {
-			types: "./dist/index.d.cts",
-			"default": "./dist/index.cjs"
-		},
-		"import": {
-			types: "./dist/index.d.mts",
-			"default": "./dist/index.mjs"
-		}
-	},
-	"./lib": {
-		require: {
-			types: "./dist/lib.d.cts",
-			"default": "./dist/lib.cjs"
-		},
-		"import": {
-			types: "./dist/lib.d.mts",
-			"default": "./dist/lib.mjs"
-		}
-	},
-	"./codex/happyMcpStdioBridge": {
-		require: {
-			types: "./dist/codex/happyMcpStdioBridge.d.cts",
-			"default": "./dist/codex/happyMcpStdioBridge.cjs"
-		},
-		"import": {
-			types: "./dist/codex/happyMcpStdioBridge.d.mts",
-			"default": "./dist/codex/happyMcpStdioBridge.mjs"
-		}
-	}
-};
-var files = [
-	"dist",
-	"bin",
-	"scripts",
-	"tools/licenses",
-	"package.json",
-	"README.md",
-	"LICENSE"
-];
-var scripts = {
-	typecheck: "tsc --noEmit",
-	"bundle:server": "node scripts/bundle-server.cjs",
-	"bundle:server:all": "node scripts/bundle-server.cjs --all-platforms",
-	"bundle:webapp": "node scripts/bundle-webapp.cjs",
-	build: "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc --noEmit && pkgroll",
-	test: "pnpm run build && vitest run --project unit",
-	"test:integration": "pnpm run build && vitest run --project integration-empty --project integration-plan-mode --project integration-authenticated",
-	"cli:install": "node scripts/install-local.cjs",
-	prepublishOnly: "pnpm test",
-	postinstall: "node scripts/unpack-tools.cjs && node scripts/fix-pty-perms.cjs"
-};
-var dependencies = {
-	"@agentclientprotocol/sdk": "^0.14.1",
-	"@anthropic-ai/claude-agent-sdk": "^0.3.232",
-	"@anthropic-ai/sandbox-runtime": "^0.0.37",
-	"@modelcontextprotocol/sdk": "1.30.0",
-	"@noble/ed25519": "^3.0.0",
-	"@noble/hashes": "^2.0.1",
-	"@paralleldrive/cuid2": "^2.2.2",
-	"@stablelib/base64": "^2.0.1",
-	"@stablelib/hex": "^2.0.1",
-	"@types/cross-spawn": "^6.0.6",
-	"@types/http-proxy": "^1.17.17",
-	"@types/react": "^19.2.7",
-	"@types/tmp": "^0.2.6",
-	axios: "^1.13.2",
-	chalk: "^5.6.2",
-	"cross-spawn": "^7.0.6",
-	"expo-server-sdk": "^3.15.0",
-	fastify: "5.8.5",
-	"fastify-type-provider-zod": "^6.1.0",
-	"http-proxy": "^1.18.1",
-	"http-proxy-middleware": "^3.0.7",
-	ink: "^6.5.1",
-	inquirer: "^13.2.2",
-	"node-pty": "^1.0.0",
-	open: "^10.2.0",
-	"ps-list": "^8.1.1",
-	react: "^19.2.0",
-	"socket.io-client": "^4.8.1",
-	tar: "^7.5.22",
-	tmp: "^0.2.7",
-	tweetnacl: "^1.0.3",
-	ws: "^8.21.3",
-	zod: "^4.0.0"
-};
-var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.124",
-	"very-happy-tools-x64-darwin": "0.2.124",
-	"very-happy-tools-arm64-linux": "0.2.124",
-	"very-happy-tools-x64-linux": "0.2.124",
-	"very-happy-tools-arm64-win32": "0.2.124",
-	"very-happy-tools-x64-win32": "0.2.124"
-};
-var devDependencies = {
-	"@slopus/happy-wire": "workspace:*",
-	"@xterm/addon-serialize": "0.13.0",
-	"@xterm/headless": "5.5.0",
-	"@types/inquirer": "^9.0.9",
-	"@types/node": ">=20",
-	"@types/ws": "^8.18.1",
-	"cross-env": "^10.1.0",
-	dotenv: "^16.6.1",
-	pkgroll: "^2.14.2",
-	"ts-node": "^10",
-	tsx: "^4.20.6",
-	typescript: "5.9.3",
-	vitest: "3.2.6"
-};
-var publishConfig = {
-	registry: "https://registry.npmjs.org"
-};
-var packageManager = "pnpm@10.11.0";
-var packageJson = {
-	name: name,
-	version: version,
-	description: description,
-	author: author,
-	contributors: contributors,
-	license: license,
-	engines: engines,
-	type: type,
-	homepage: homepage,
-	bugs: bugs,
-	repository: repository,
-	bin: bin,
-	main: main,
-	module: module$1,
-	types: types,
-	exports: exports$1,
-	files: files,
-	scripts: scripts,
-	dependencies: dependencies,
-	optionalDependencies: optionalDependencies,
-	devDependencies: devDependencies,
-	publishConfig: publishConfig,
-	packageManager: packageManager
-};
-
-const PRIVATE_DIRECTORY_MODE = 448;
-const PRIVATE_FILE_MODE = 384;
-function ignoreUnsupportedPermissions(error) {
-  if (process.platform !== "win32") throw error;
-}
-function ensurePrivateDirectorySync(path) {
-  node_fs.mkdirSync(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
-  try {
-    node_fs.chmodSync(path, PRIVATE_DIRECTORY_MODE);
-  } catch (error) {
-    ignoreUnsupportedPermissions(error);
-  }
-}
-async function ensurePrivateDirectory(path) {
-  await promises.mkdir(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
-  try {
-    await promises.chmod(path, PRIVATE_DIRECTORY_MODE);
-  } catch (error) {
-    ignoreUnsupportedPermissions(error);
-  }
-}
-function hardenPrivateFileSync(path) {
-  try {
-    node_fs.chmodSync(path, PRIVATE_FILE_MODE);
-  } catch (error) {
-    ignoreUnsupportedPermissions(error);
-  }
-}
-function hardenPrivateDirectoryFilesSync(path$1) {
-  for (const name of node_fs.readdirSync(path$1)) {
-    const candidate = path.join(path$1, name);
-    try {
-      if (node_fs.statSync(candidate).isFile()) hardenPrivateFileSync(candidate);
-    } catch {
-    }
-  }
-}
-async function hardenPrivateFile(path) {
-  try {
-    await promises.chmod(path, PRIVATE_FILE_MODE);
-  } catch (error) {
-    ignoreUnsupportedPermissions(error);
-  }
-}
-function writePrivateFileSync(path, data) {
-  node_fs.writeFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
-  hardenPrivateFileSync(path);
-}
-async function writePrivateFile(path, data) {
-  await promises.writeFile(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
-  await hardenPrivateFile(path);
-}
-function appendPrivateFileSync(path, data) {
-  node_fs.appendFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
-  hardenPrivateFileSync(path);
-}
-
-const DEFAULT_RELAY_URL = "https://veryhappy.dev";
-function normalizeHttpEndpoint(value, source) {
-  const trimmed = value.trim();
-  let parsed;
-  try {
-    parsed = new URL(trimmed);
-  } catch {
-    throw new Error(`${source} must be an absolute http(s) origin`);
-  }
-  const onlyOriginPath = /^\/+$/u.test(parsed.pathname);
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username.length > 0 || parsed.password.length > 0 || !onlyOriginPath || parsed.search.length > 0 || parsed.hash.length > 0) {
-    throw new Error(`${source} must be an http(s) origin without credentials, path, query, or fragment`);
-  }
-  return parsed.origin;
-}
-function resolveHttpEndpoint(environmentValue, settingsValue, environmentName, settingsName) {
-  if (environmentValue !== void 0) {
-    return normalizeHttpEndpoint(environmentValue, environmentName);
-  }
-  if (settingsValue !== void 0) {
-    return normalizeHttpEndpoint(settingsValue, `settings.${settingsName}`);
-  }
-  return DEFAULT_RELAY_URL;
-}
-class Configuration {
-  serverUrl;
-  webappUrl;
-  isDaemonProcess;
-  // Directories and paths (from persistence)
-  happyHomeDir;
-  logsDir;
-  settingsFile;
-  privateKeyFile;
-  daemonStateFile;
-  daemonLockFile;
-  sessionsFile;
-  currentCliVersion;
-  isExperimentalEnabled;
-  disableCaffeinate;
-  constructor() {
-    const args = process.argv.slice(2);
-    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
-    if (process.env.HAPPY_HOME_DIR) {
-      const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, os.homedir());
-      this.happyHomeDir = expandedPath;
-    } else {
-      this.happyHomeDir = path.join(os.homedir(), ".happy");
-    }
-    this.logsDir = path.join(this.happyHomeDir, "logs");
-    this.settingsFile = path.join(this.happyHomeDir, "settings.json");
-    this.privateKeyFile = path.join(this.happyHomeDir, "access.key");
-    this.daemonStateFile = path.join(this.happyHomeDir, "daemon.state.json");
-    this.daemonLockFile = path.join(this.happyHomeDir, "daemon.state.json.lock");
-    this.sessionsFile = path.join(this.happyHomeDir, "sessions.json");
-    try {
-      this.serverUrl = resolveHttpEndpoint(
-        process.env.HAPPY_SERVER_URL,
-        readSettingsStringSync(this.settingsFile, "serverUrl"),
-        "HAPPY_SERVER_URL",
-        "serverUrl"
-      );
-      this.webappUrl = resolveHttpEndpoint(
-        process.env.HAPPY_WEBAPP_URL,
-        readSettingsStringSync(this.settingsFile, "webappUrl"),
-        "HAPPY_WEBAPP_URL",
-        "webappUrl"
-      );
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "invalid client endpoint";
-      process.stderr.write(`[very-happy] Configuration error: ${message}
-`);
-      process.exit(1);
-    }
-    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
-    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
-    this.currentCliVersion = packageJson.version;
-    const variant = process.env.HAPPY_VARIANT || "stable";
-    if (!this.isDaemonProcess && variant === "dev") {
-      console.log("\x1B[33m\u{1F527} DEV MODE\x1B[0m - Data: " + this.happyHomeDir);
-    }
-    ensurePrivateDirectorySync(this.happyHomeDir);
-    ensurePrivateDirectorySync(this.logsDir);
-    for (const privateFile of [
-      this.settingsFile,
-      this.privateKeyFile,
-      this.daemonStateFile,
-      this.daemonLockFile,
-      this.sessionsFile
-    ]) {
-      if (node_fs.existsSync(privateFile)) hardenPrivateFileSync(privateFile);
-    }
-    hardenPrivateDirectoryFilesSync(this.logsDir);
-  }
-}
-function readSettingsStringSync(settingsFile, key) {
-  try {
-    if (!node_fs.existsSync(settingsFile)) return void 0;
-    const raw = JSON.parse(node_fs.readFileSync(settingsFile, "utf8"));
-    const value = raw?.[key];
-    return typeof value === "string" && value.length > 0 ? value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-const configuration = new Configuration();
-
-function sensitiveKey(key) {
-  const normalized = key.toLowerCase().replace(/[_\-\s]/g, "");
-  return /(token|secret|password|authorization|cookie|credential|apikey|privatekey|encryptionkey|accesskey|claimsecret)/.test(normalized);
-}
-function redactLogString(value) {
-  return value.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]").replace(/([?&](?:token|secret|password|api[_-]?key)=)[^&#\s]+/gi, "$1[REDACTED]").replace(/((?:token|secret|password|api[_-]?key)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
-}
-function redactLogValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof value === "string") return redactLogString(value);
-  if (value === null || typeof value !== "object") return value;
-  if (depth >= 6) return "[TRUNCATED]";
-  if (seen.has(value)) return "[CIRCULAR]";
-  seen.add(value);
-  if (value instanceof Error) {
-    const error = value;
-    return {
-      name: error.name,
-      message: redactLogString(error.message),
-      ...typeof error.code === "string" || typeof error.code === "number" ? { code: error.code } : {},
-      ...typeof (error.status ?? error.response?.status) === "number" ? { status: error.status ?? error.response?.status } : {}
-    };
-  }
-  if (Array.isArray(value)) return value.map((item) => redactLogValue(item, depth + 1, seen));
-  const result = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (sensitiveKey(key)) {
-      result[key] = "[REDACTED]";
-    } else if (key === "environmentVariables" && child && typeof child === "object") {
-      result[key] = { names: Object.keys(child).sort() };
-    } else {
-      result[key] = redactLogValue(child, depth + 1, seen);
-    }
-  }
-  return result;
-}
-
-function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
-  return date.toLocaleString("sv-SE", {
-    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
-}
-function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
-  return date.toLocaleTimeString("en-US", {
-    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    hour12: false,
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    fractionalSecondDigits: 3
-  });
-}
-function getSessionLogPath() {
-  const timestamp = createTimestampForFilename();
-  const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
-  return path.join(configuration.logsDir, filename);
-}
-function safeRemoteLogUrl(raw) {
-  if (!raw) return void 0;
-  try {
-    const url = new URL(raw);
-    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
-    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) return void 0;
-    if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") return void 0;
-    return url.origin;
-  } catch {
-    return void 0;
-  }
-}
-class Logger {
-  constructor(logFilePath = getSessionLogPath()) {
-    this.logFilePath = logFilePath;
-    const remoteUrl = safeRemoteLogUrl(process.env.HAPPY_SERVER_URL);
-    const remoteToken = process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING_TOKEN;
-    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && remoteUrl && remoteToken && Buffer.byteLength(remoteToken) >= 32) {
-      this.dangerouslyUnencryptedServerLoggingUrl = remoteUrl;
-      this.dangerouslyUnencryptedServerLoggingToken = remoteToken;
-      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
-    }
-  }
-  dangerouslyUnencryptedServerLoggingUrl;
-  dangerouslyUnencryptedServerLoggingToken;
-  // Use local timezone for simplicity of locating the logs,
-  // in practice you will not need absolute timestamps
-  localTimezoneTimestamp() {
-    return createTimestampForLogEntry();
-  }
-  debug(message, ...args) {
-    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
-  }
-  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
-    if (!process.env.DEBUG) {
-      this.debug(`In production, skipping message inspection`);
-      return;
-    }
-    const truncateStrings = (obj) => {
-      if (typeof obj === "string") {
-        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
-      }
-      if (Array.isArray(obj)) {
-        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
-        if (obj.length > maxArrayLength) {
-          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
-        }
-        return truncatedArray;
-      }
-      if (obj && typeof obj === "object") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-          if (key === "usage") {
-            continue;
-          }
-          result[key] = truncateStrings(value);
-        }
-        return result;
-      }
-      return obj;
-    };
-    const truncatedObject = truncateStrings(redactLogValue(object));
-    const json = JSON.stringify(truncatedObject, null, 2);
-    this.logToFile(`[${this.localTimezoneTimestamp()}]`, redactLogString(message), "\n", json);
-  }
-  info(message, ...args) {
-    this.logToConsole("info", "", message, ...args);
-    this.debug(message, args);
-  }
-  infoDeveloper(message, ...args) {
-    this.debug(message, ...args);
-    if (process.env.DEBUG) {
-      this.logToConsole("info", "[DEV]", message, ...args);
-    }
-  }
-  warn(message, ...args) {
-    this.logToConsole("warn", "", message, ...args);
-    this.debug(`[WARN] ${message}`, ...args);
-  }
-  getLogPath() {
-    return this.logFilePath;
-  }
-  logToConsole(level, prefix, message, ...args) {
-    message = redactLogString(message);
-    args = args.map((arg) => redactLogValue(arg));
-    switch (level) {
-      case "debug": {
-        console.log(chalk.gray(prefix), message, ...args);
-        break;
-      }
-      case "error": {
-        console.error(chalk.red(prefix), message, ...args);
-        break;
-      }
-      case "info": {
-        console.log(chalk.blue(prefix), message, ...args);
-        break;
-      }
-      case "warn": {
-        console.log(chalk.yellow(prefix), message, ...args);
-        break;
-      }
-      default: {
-        this.debug("Unknown log level:", level);
-        console.log(chalk.blue(prefix), message, ...args);
-        break;
-      }
-    }
-  }
-  async sendToRemoteServer(level, message, ...args) {
-    if (!this.dangerouslyUnencryptedServerLoggingUrl) return;
-    try {
-      await fetch(this.dangerouslyUnencryptedServerLoggingUrl + "/logs-combined-from-cli-and-mobile-for-simple-ai-debugging", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.dangerouslyUnencryptedServerLoggingToken}`
-        },
-        body: JSON.stringify({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          level,
-          message: `${redactLogString(message)} ${args.map((raw) => {
-            const safe = redactLogValue(raw);
-            return typeof safe === "object" ? JSON.stringify(safe, null, 2) : String(safe);
-          }).join(" ")}`,
-          source: "cli",
-          platform: process.platform
-        })
-      });
-    } catch (error) {
-    }
-  }
-  logToFile(prefix, message, ...args) {
-    const safeMessage = redactLogString(message);
-    const safeArgs = args.map((arg) => redactLogValue(arg));
-    const logLine = `${prefix} ${safeMessage} ${safeArgs.map(
-      (arg) => typeof arg === "string" ? arg : node_util.inspect(arg, { depth: 5, breakLength: 120 })
-    ).join(" ")}
-`;
-    if (this.dangerouslyUnencryptedServerLoggingUrl) {
-      let level = "info";
-      if (prefix.includes(this.localTimezoneTimestamp())) {
-        level = "debug";
-      }
-      this.sendToRemoteServer(level, safeMessage, ...safeArgs).catch(() => {
-      });
-    }
-    try {
-      appendPrivateFileSync(this.logFilePath, logLine);
-    } catch (appendError) {
-      if (process.env.DEBUG) {
-        console.error("[DEV MODE ONLY THROWING] Failed to append to log file:", appendError);
-        throw appendError;
-      }
-    }
-  }
-}
-let logger = new Logger();
-async function listDaemonLogFiles(limit = 50) {
-  try {
-    const logsDir = configuration.logsDir;
-    if (!node_fs.existsSync(logsDir)) {
-      return [];
-    }
-    const logs = node_fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
-      const fullPath = path.join(logsDir, file);
-      const stats = node_fs.statSync(fullPath);
-      return { file, path: fullPath, modified: stats.mtime };
-    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
-    try {
-      const { readDaemonState } = await Promise.resolve().then(function () { return persistence; });
-      const state = await readDaemonState();
-      if (!state) {
-        return logs;
-      }
-      if (state.daemonLogPath && node_fs.existsSync(state.daemonLogPath)) {
-        const stats = node_fs.statSync(state.daemonLogPath);
-        const persisted = {
-          file: path.basename(state.daemonLogPath),
-          path: state.daemonLogPath,
-          modified: stats.mtime
-        };
-        const idx = logs.findIndex((l) => l.path === persisted.path);
-        if (idx >= 0) {
-          const [found] = logs.splice(idx, 1);
-          logs.unshift(found);
-        } else {
-          logs.unshift(persisted);
-        }
-      }
-    } catch {
-    }
-    return logs.slice(0, Math.max(0, limit));
-  } catch {
-    return [];
-  }
-}
-async function getLatestDaemonLog() {
-  const [latest] = await listDaemonLogFiles(1);
-  return latest || null;
-}
-
 const sessionRoleSchema = z__namespace.enum(["user", "agent"]);
 const sessionTextEventSchema = z__namespace.object({
   t: z__namespace.literal("text"),
@@ -1048,8 +454,36 @@ const ConnectionDiagnosticEventSchema = z.z.object({
 z.z.object({
   events: z.z.array(ConnectionDiagnosticEventSchema).min(1).max(32)
 }).strict();
+const TeamPermissionModeSchema = z.z.enum(["default", "bypassPermissions"]);
+const id = z.z.string().min(1).max(128);
+const text = z.z.string().min(1).max(32e3);
+const TeamActionSchema = z.z.discriminatedUnion("type", [
+  z.z.object({ type: z.z.literal("archive") }),
+  z.z.object({ type: z.z.literal("set-permission-mode"), permissionMode: TeamPermissionModeSchema }),
+  z.z.object({ type: z.z.literal("schedule-create"), name: id, botId: id, body: text, runAt: z.z.number().int().positive().max(864e13), intervalMs: z.z.number().int().min(6e4).max(366 * 864e5).optional() }),
+  z.z.object({ type: z.z.literal("schedule-pause"), scheduleId: id, version: z.z.number().int().positive() }),
+  z.z.object({ type: z.z.literal("schedule-resume"), scheduleId: id, version: z.z.number().int().positive() }),
+  z.z.object({ type: z.z.literal("schedule-cancel"), scheduleId: id, version: z.z.number().int().positive() }),
+  z.z.object({ type: z.z.literal("reconcile-operation"), operationId: id, claimId: id, note: z.z.string().trim().min(1).max(4e3) }),
+  z.z.object({ type: z.z.literal("join"), name: id, sessionId: id, botId: id.optional() }),
+  z.z.object({ type: z.z.literal("delegate"), goal: text, acceptance: z.z.array(text).min(1).max(32), parentTaskId: id.optional(), assigneeBotId: id.optional(), botName: id.optional(), directory: z.z.string().min(1).max(4096).optional(), assistant: z.z.enum(["claude", "codex", "pi-acp"]).optional() }),
+  z.z.object({ type: z.z.literal("message"), taskId: id, body: text, recipientBotId: id.optional() }),
+  z.z.object({ type: z.z.literal("submit"), taskId: id, attemptId: id, goalVersion: z.z.number().int().positive(), result: text }),
+  z.z.object({ type: z.z.literal("accept"), taskId: id, attemptId: id, goalVersion: z.z.number().int().positive() }),
+  z.z.object({ type: z.z.literal("return"), taskId: id, attemptId: id, goalVersion: z.z.number().int().positive(), reason: text }),
+  z.z.object({ type: z.z.literal("cancel"), taskId: id, attemptId: id, goalVersion: z.z.number().int().positive(), reason: text }),
+  z.z.object({ type: z.z.literal("handoff"), taskId: id, attemptId: id, goalVersion: z.z.number().int().positive(), assigneeBotId: id }),
+  z.z.object({ type: z.z.literal("claim-operation"), operationId: id, machineId: id }),
+  z.z.object({ type: z.z.literal("complete-operation"), operationId: id, machineId: id, claimId: id, sessionId: id.optional() }),
+  z.z.object({ type: z.z.literal("fail-operation"), operationId: id, machineId: id, claimId: id, error: text, unknown: z.z.boolean().optional() }),
+  z.z.object({ type: z.z.literal("session-event"), sessionId: id, event: z.z.enum(["idle", "blocked", "exited"]) }),
+  z.z.object({ type: z.z.literal("message-delivered"), messageId: id, recipientBotId: id, generation: z.z.number().int().positive(), sessionId: id })
+]);
+z.z.object({ requestId: id, action: TeamActionSchema });
+z.z.object({ name: id, machineId: id, requestId: id.optional() });
 
 z.z.object({
+  teamsVersion: z.z.number().int().positive().optional(),
   host: z.z.string(),
   platform: z.z.string(),
   happyCliVersion: z.z.string(),
@@ -1324,125 +758,6 @@ const AgentMessageSchema = z.z.object({
 });
 z.z.union([UserMessageSchema, AgentMessageSchema]);
 
-function encodeBase64(buffer, variant = "base64") {
-  if (variant === "base64url") {
-    return encodeBase64Url(buffer);
-  }
-  return Buffer.from(buffer).toString("base64");
-}
-function encodeBase64Url(buffer) {
-  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function decodeBase64(base64, variant = "base64") {
-  if (variant === "base64url") {
-    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
-    return new Uint8Array(Buffer.from(base64Standard, "base64"));
-  }
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function getRandomBytes(size) {
-  return new Uint8Array(node_crypto.randomBytes(size));
-}
-function libsodiumPublicKeyFromSecretKey(seed) {
-  const hashedSeed = new Uint8Array(node_crypto.createHash("sha512").update(seed).digest());
-  const secretKey = hashedSeed.slice(0, 32);
-  return new Uint8Array(tweetnacl.box.keyPair.fromSecretKey(secretKey).publicKey);
-}
-function libsodiumEncryptForPublicKey(data, recipientPublicKey) {
-  const ephemeralKeyPair = tweetnacl.box.keyPair();
-  const nonce = getRandomBytes(tweetnacl.box.nonceLength);
-  const encrypted = tweetnacl.box(data, nonce, recipientPublicKey, ephemeralKeyPair.secretKey);
-  const result = new Uint8Array(ephemeralKeyPair.publicKey.length + nonce.length + encrypted.length);
-  result.set(ephemeralKeyPair.publicKey, 0);
-  result.set(nonce, ephemeralKeyPair.publicKey.length);
-  result.set(encrypted, ephemeralKeyPair.publicKey.length + nonce.length);
-  return result;
-}
-function encryptLegacy(data, secret) {
-  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
-  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
-  const result = new Uint8Array(nonce.length + encrypted.length);
-  result.set(nonce);
-  result.set(encrypted, nonce.length);
-  return result;
-}
-function decryptLegacy(data, secret) {
-  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
-  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
-  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
-  if (!decrypted) {
-    return null;
-  }
-  return JSON.parse(new TextDecoder().decode(decrypted));
-}
-function decryptBlob(bundle, key) {
-  if (bundle.length < tweetnacl.secretbox.nonceLength + 16) {
-    return null;
-  }
-  const nonce = bundle.slice(0, tweetnacl.secretbox.nonceLength);
-  const ciphertext = bundle.slice(tweetnacl.secretbox.nonceLength);
-  const decrypted = tweetnacl.secretbox.open(ciphertext, nonce, key);
-  if (!decrypted) {
-    return null;
-  }
-  return new Uint8Array(decrypted);
-}
-function encryptWithDataKey(data, dataKey) {
-  const nonce = getRandomBytes(12);
-  const cipher = node_crypto.createCipheriv("aes-256-gcm", dataKey, nonce);
-  const plaintext = new TextEncoder().encode(JSON.stringify(data));
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext),
-    cipher.final()
-  ]);
-  const authTag = cipher.getAuthTag();
-  const bundle = new Uint8Array(12 + encrypted.length + 16 + 1);
-  bundle.set([0], 0);
-  bundle.set(nonce, 1);
-  bundle.set(new Uint8Array(encrypted), 13);
-  bundle.set(new Uint8Array(authTag), 13 + encrypted.length);
-  return bundle;
-}
-function decryptWithDataKey(bundle, dataKey) {
-  if (bundle.length < 1) {
-    return null;
-  }
-  if (bundle[0] !== 0) {
-    return null;
-  }
-  if (bundle.length < 12 + 16 + 1) {
-    return null;
-  }
-  const nonce = bundle.slice(1, 13);
-  const authTag = bundle.slice(bundle.length - 16);
-  const ciphertext = bundle.slice(13, bundle.length - 16);
-  try {
-    const decipher = node_crypto.createDecipheriv("aes-256-gcm", dataKey, nonce);
-    decipher.setAuthTag(authTag);
-    const decrypted = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final()
-    ]);
-    return JSON.parse(new TextDecoder().decode(decrypted));
-  } catch (error) {
-    return null;
-  }
-}
-function encrypt(key, variant, data) {
-  if (variant === "legacy") {
-    return encryptLegacy(data, key);
-  } else {
-    return encryptWithDataKey(data, key);
-  }
-}
-function decrypt(key, variant, data) {
-  if (variant === "legacy") {
-    return decryptLegacy(data, key);
-  } else {
-    return decryptWithDataKey(data, key);
-  }
-}
-
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1474,7 +789,7 @@ function createBackoff(opts) {
 }
 let backoff = createBackoff({
   onError: (e, failuresCount) => {
-    logger.debug(`[BACKOFF] retry ${failuresCount}:`, e?.message || e);
+    persistence.logger.debug(`[BACKOFF] retry ${failuresCount}:`, e?.message || e);
   }
 });
 
@@ -1572,7 +887,7 @@ class RpcHandlerManager {
     this.scopePrefix = config.scopePrefix;
     this.encryptionKey = config.encryptionKey;
     this.encryptionVariant = config.encryptionVariant;
-    this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
+    this.logger = config.logger || ((msg, data) => persistence.logger.debug(msg, data));
   }
   /**
    * Register an RPC handler for a specific method
@@ -1600,14 +915,14 @@ class RpcHandlerManager {
       if (!handler) {
         this.logger("[RPC] [ERROR] Method not found", { method: request.method });
         const errorResponse = { error: "Method not found" };
-        const encryptedError = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+        const encryptedError = persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
         return encryptedError;
       }
-      const decryptedParams = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(request.params));
+      const decryptedParams = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(request.params));
       this.logger("[RPC] Calling handler", { method: request.method });
       const result = await handler(decryptedParams);
       this.logger("[RPC] Handler returned", { method: request.method, hasResult: result !== void 0 });
-      const encryptedResponse = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, result));
+      const encryptedResponse = persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, result));
       this.logger("[RPC] Sending encrypted response", { method: request.method, responseLength: encryptedResponse.length });
       return encryptedResponse;
     } catch (error) {
@@ -1615,7 +930,7 @@ class RpcHandlerManager {
       const errorResponse = {
         error: error instanceof Error ? error.message : "Unknown error"
       };
-      return encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+      return persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
     }
   }
   onSocketConnect(socket) {
@@ -1708,14 +1023,14 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-CZIwVSN2.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-P5deH8Ls.cjs', document.baseURI).href))));
 function projectPath() {
-  const path = path$1.resolve(__dirname$1, "..");
-  return path;
+  const path$1 = path.resolve(__dirname$1, "..");
+  return path$1;
 }
 
 function run$1(args, options) {
-  const RUNNER_PATH = path$1.resolve(path$1.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  const RUNNER_PATH = path.resolve(path.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
     const child = spawn.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -1744,9 +1059,9 @@ function run$1(args, options) {
 }
 
 function getBinaryPath() {
-  const platformName = os$1.platform();
+  const platformName = os.platform();
   const binaryName = platformName === "win32" ? "difft.exe" : "difft";
-  return path$1.resolve(path$1.join(projectPath(), "tools", "unpacked", binaryName));
+  return path.resolve(path.join(projectPath(), "tools", "unpacked", binaryName));
 }
 function run(args, options) {
   const binaryPath = getBinaryPath();
@@ -1783,9 +1098,9 @@ function run(args, options) {
 }
 
 function validatePath(targetPath, workingDirectory) {
-  const resolvedTarget = path$1.resolve(workingDirectory, targetPath);
-  const resolvedWorkingDir = path$1.resolve(workingDirectory);
-  if (!resolvedTarget.startsWith(resolvedWorkingDir + path$1.sep) && resolvedTarget !== resolvedWorkingDir) {
+  const resolvedTarget = path.resolve(workingDirectory, targetPath);
+  const resolvedWorkingDir = path.resolve(workingDirectory);
+  if (!resolvedTarget.startsWith(resolvedWorkingDir + path.sep) && resolvedTarget !== resolvedWorkingDir) {
     return {
       valid: false,
       resolvedPath: resolvedTarget,
@@ -1858,9 +1173,9 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
     const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
     await Promise.all(entries.map(async (entry) => {
       if (!entry.isFile() || !/^\..+\.[A-Za-z0-9_-]{8,80}\.part$/.test(entry.name)) return;
-      const path = path$1.join(dir, entry.name);
-      const fileStat = await fs.stat(path).catch(() => null);
-      if (fileStat && fileStat.mtimeMs < cutoff) await fs.unlink(path).catch(() => {
+      const path$1 = path.join(dir, entry.name);
+      const fileStat = await fs.stat(path$1).catch(() => null);
+      if (fileStat && fileStat.mtimeMs < cutoff) await fs.unlink(path$1).catch(() => {
       });
     }));
   };
@@ -1868,12 +1183,12 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
     let tempPath = null;
     try {
       const buffer = decodeUploadBase64(data.content, MAX_USER_UPLOAD_BYTES);
-      const dir = path$1.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+      const dir = path.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
       await fs.mkdir(dir, { recursive: true });
       const name = safeFileName(data.name);
       const token = crypto.randomUUID().replace(/-/g, "").slice(0, 12);
-      const target = path$1.join(dir, uniqueFileName(name, token));
-      tempPath = path$1.join(dir, `.${name}.legacy_${crypto.randomUUID().replace(/-/g, "")}.part`);
+      const target = path.join(dir, uniqueFileName(name, token));
+      tempPath = path.join(dir, `.${name}.legacy_${crypto.randomUUID().replace(/-/g, "")}.part`);
       await fs.writeFile(tempPath, buffer, { flag: "wx" });
       await fs.rename(tempPath, target);
       tempPath = null;
@@ -1894,12 +1209,12 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
         }
         if (active.has(uploadId)) throw new Error("Upload id is already active");
         if (active.size >= MAX_ACTIVE_UPLOADS) throw new Error("Too many active uploads");
-        const dir = path$1.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+        const dir = path.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
         await fs.mkdir(dir, { recursive: true });
         await sweepExpiredFiles(dir);
         const name = safeFileName(data.name);
-        const targetPath = path$1.join(dir, uniqueFileName(name, crypto.randomUUID().replace(/-/g, "").slice(0, 12)));
-        const tempPath = path$1.join(dir, `.${name}.${uploadId}.part`);
+        const targetPath = path.join(dir, uniqueFileName(name, crypto.randomUUID().replace(/-/g, "").slice(0, 12)));
+        const tempPath = path.join(dir, `.${name}.${uploadId}.part`);
         await fs.writeFile(tempPath, Buffer.alloc(0), { flag: "wx" });
         active.set(uploadId, { tempPath, targetPath, totalSize: data.totalSize, received: 0, touchedAt: now() });
         return { success: true, size: 0 };
@@ -1945,7 +1260,7 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
 const execAsync = util.promisify(child_process.exec);
 function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
   rpcHandlerManager.registerHandler("bash", async (data) => {
-    logger.debug("Shell command request:", data.command);
+    persistence.logger.debug("Shell command request:", data.command);
     if (data.cwd && data.cwd !== "/") {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -1961,16 +1276,16 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         windowsHide: true
         // Prevent cmd.exe popup on Windows for every RPC bash call
       };
-      logger.debug("Shell command executing...", { cwd: options.cwd, timeout: options.timeout });
+      persistence.logger.debug("Shell command executing...", { cwd: options.cwd, timeout: options.timeout });
       const { stdout, stderr } = await execAsync(data.command, options);
-      logger.debug("Shell command executed, processing result...");
+      persistence.logger.debug("Shell command executed, processing result...");
       const result = {
         success: true,
         stdout: stdout ? stdout.toString() : "",
         stderr: stderr ? stderr.toString() : "",
         exitCode: 0
       };
-      logger.debug("Shell command result:", {
+      persistence.logger.debug("Shell command result:", {
         success: true,
         exitCode: 0,
         stdoutLen: result.stdout.length,
@@ -1987,7 +1302,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
           exitCode: typeof execError.code === "number" ? execError.code : -1,
           error: "Command timed out"
         };
-        logger.debug("Shell command timed out:", {
+        persistence.logger.debug("Shell command timed out:", {
           success: false,
           exitCode: result2.exitCode,
           error: "Command timed out"
@@ -2001,7 +1316,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         exitCode: typeof execError.code === "number" ? execError.code : 1,
         error: execError.message || "Command failed"
       };
-      logger.debug("Shell command failed:", {
+      persistence.logger.debug("Shell command failed:", {
         success: false,
         exitCode: result.exitCode,
         error: result.error,
@@ -2012,7 +1327,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
     }
   });
   rpcHandlerManager.registerHandler("readFile", async (data) => {
-    logger.debug("Read file request:", data.path);
+    persistence.logger.debug("Read file request:", data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
@@ -2022,12 +1337,12 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       const content = buffer.toString("base64");
       return { success: true, content };
     } catch (error) {
-      logger.debug("Failed to read file:", error);
+      persistence.logger.debug("Failed to read file:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
     }
   });
   rpcHandlerManager.registerHandler("writeFile", async (data) => {
-    logger.debug("Write file request:", data.path);
+    persistence.logger.debug("Write file request:", data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
@@ -2072,15 +1387,15 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       const hash = crypto.createHash("sha256").update(buffer).digest("hex");
       return { success: true, hash };
     } catch (error) {
-      logger.debug("Failed to write file:", error);
+      persistence.logger.debug("Failed to write file:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
     }
   });
-  const uploadHandlers = createUploadFileHandlers(configuration.happyHomeDir);
+  const uploadHandlers = createUploadFileHandlers(persistence.configuration.happyHomeDir);
   rpcHandlerManager.registerHandler("uploadFile", uploadHandlers.uploadFile);
   rpcHandlerManager.registerHandler("uploadFileChunk", uploadHandlers.uploadFileChunk);
   rpcHandlerManager.registerHandler("listDirectory", async (data) => {
-    logger.debug("List directory request:", data.path);
+    persistence.logger.debug("List directory request:", data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
@@ -2090,7 +1405,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       const entries = await fs.readdir(directoryPath, { withFileTypes: true });
       const directoryEntries = await Promise.all(
         entries.map(async (entry) => {
-          const fullPath = path$1.join(directoryPath, entry.name);
+          const fullPath = path.join(directoryPath, entry.name);
           let type = "other";
           let size;
           let modified;
@@ -2104,7 +1419,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
             size = stats.size;
             modified = stats.mtime.getTime();
           } catch (error) {
-            logger.debug(`Failed to stat ${fullPath}:`, error);
+            persistence.logger.debug(`Failed to stat ${fullPath}:`, error);
           }
           return {
             name: entry.name,
@@ -2121,36 +1436,36 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       });
       return { success: true, entries: directoryEntries };
     } catch (error) {
-      logger.debug("Failed to list directory:", error);
+      persistence.logger.debug("Failed to list directory:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
     }
   });
   rpcHandlerManager.registerHandler("getDirectoryTree", async (data) => {
-    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    persistence.logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
-    async function buildTree(path, name, currentDepth) {
+    async function buildTree(path$1, name, currentDepth) {
       try {
-        const stats = await fs.stat(path);
+        const stats = await fs.stat(path$1);
         const node = {
           name,
-          path,
+          path: path$1,
           type: stats.isDirectory() ? "directory" : "file",
           size: stats.size,
           modified: stats.mtime.getTime()
         };
         if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await fs.readdir(path, { withFileTypes: true });
+          const entries = await fs.readdir(path$1, { withFileTypes: true });
           const children = [];
           await Promise.all(
             entries.map(async (entry) => {
               if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${path$1.join(path, entry.name)}`);
+                persistence.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
                 return;
               }
-              const childPath = path$1.join(path, entry.name);
+              const childPath = path.join(path$1, entry.name);
               const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
               if (childNode) {
                 children.push(childNode);
@@ -2166,7 +1481,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         }
         return node;
       } catch (error) {
-        logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
+        persistence.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
         return null;
       }
     }
@@ -2182,12 +1497,12 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       }
       return { success: true, tree };
     } catch (error) {
-      logger.debug("Failed to get directory tree:", error);
+      persistence.logger.debug("Failed to get directory tree:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
     }
   });
   rpcHandlerManager.registerHandler("ripgrep", async (data) => {
-    logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    persistence.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
     if (data.cwd) {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -2204,7 +1519,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         stderr: result.stderr.toString()
       };
     } catch (error) {
-      logger.debug("Failed to run ripgrep:", error);
+      persistence.logger.debug("Failed to run ripgrep:", error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Failed to run ripgrep"
@@ -2212,7 +1527,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
     }
   });
   rpcHandlerManager.registerHandler("difftastic", async (data) => {
-    logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
+    persistence.logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
     if (data.cwd) {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -2229,7 +1544,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         stderr: result.stderr.toString()
       };
     } catch (error) {
-      logger.debug("Failed to run difftastic:", error);
+      persistence.logger.debug("Failed to run difftastic:", error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Failed to run difftastic"
@@ -2312,7 +1627,7 @@ function calculateCost(usage, modelId) {
 }
 
 function hasNetworkConnectivity() {
-  const interfaces = os$1.networkInterfaces();
+  const interfaces = os.networkInterfaces();
   for (const name of Object.keys(interfaces)) {
     for (const iface of interfaces[name] || []) {
       if (!iface.internal && iface.family === "IPv4") return true;
@@ -3326,13 +2641,13 @@ class ApiSessionClient extends node_events.EventEmitter {
       scopePrefix: this.sessionId,
       encryptionKey: this.encryptionKey,
       encryptionVariant: this.encryptionVariant,
-      logger: (msg, data) => logger.debug(msg, data)
+      logger: (msg, data) => persistence.logger.debug(msg, data)
     });
     registerCommonHandlers(this.rpcHandlerManager, this.metadata.path);
     this.socket = this.createControlSocket();
     const controlSocket = this.socket;
     this.socket.on("connect", () => {
-      logger.debug("Socket connected successfully");
+      persistence.logger.debug("Socket connected successfully");
       if (this.reconnectInterval) {
         clearInterval(this.reconnectInterval);
         this.reconnectInterval = null;
@@ -3345,15 +2660,15 @@ class ApiSessionClient extends node_events.EventEmitter {
       callback(await this.rpcHandlerManager.handleRequest(data));
     });
     this.socket.on("disconnect", (reason) => {
-      logger.debug(`[API] Socket disconnected: ${reason}`);
+      persistence.logger.debug(`[API] Socket disconnected: ${reason}`);
       this.rpcHandlerManager.onSocketDisconnect(controlSocket);
       this.startSmartReconnect();
     });
     this.socket.on("connect_error", (error) => {
-      logger.debug("[API] Socket connection error:", error);
+      persistence.logger.debug("[API] Socket connection error:", error);
       this.rpcHandlerManager.onSocketDisconnect(controlSocket);
       if (error.message === "Session archived") {
-        logger.debug("[API] Archived session rejected during reconnect; exiting");
+        persistence.logger.debug("[API] Archived session rejected during reconnect; exiting");
         this.emit("archived");
         return;
       }
@@ -3361,14 +2676,14 @@ class ApiSessionClient extends node_events.EventEmitter {
     });
     this.socket.on("session-archive", ({ sessionId }) => {
       if (sessionId !== this.sessionId) return;
-      logger.debug("[SOCKET] Server archived this session; exiting...");
+      persistence.logger.debug("[SOCKET] Server archived this session; exiting...");
       this.emit("archived");
     });
     this.socket.on("update", (data) => {
       try {
-        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        persistence.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
         if (!data.body) {
-          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          persistence.logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
           return;
         }
         if (data.body.t === "new-message") {
@@ -3386,41 +2701,41 @@ class ApiSessionClient extends node_events.EventEmitter {
             this.lastSeq = messageSeq;
             return;
           }
-          const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.message.content.c));
-          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          const body = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(data.body.message.content.c));
+          persistence.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
           this.routeIncomingMessage(body, localId);
           if (localId) this.rememberRoutedInbound(localId);
           this.lastSeq = messageSeq;
         } else if (data.body.t === "update-session") {
           if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
-            this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.metadata.value));
+            this.metadata = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(data.body.metadata.value));
             this.metadataVersion = data.body.metadata.version;
             const meta = this.metadata;
             if (meta?.lifecycleState === "archiveRequested" || meta?.lifecycleState === "archived") {
               if (this.ignoreArchiveSignal) {
-                logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}) but suppressed for reconnect`);
+                persistence.logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}) but suppressed for reconnect`);
                 this.ignoreArchiveSignal = false;
               } else {
-                logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}), exiting...`);
+                persistence.logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}), exiting...`);
                 this.emit("archived");
               }
             }
           }
           if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
-            this.agentState = data.body.agentState.value ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.agentState.value)) : null;
+            this.agentState = data.body.agentState.value ? persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(data.body.agentState.value)) : null;
             this.agentStateVersion = data.body.agentState.version;
           }
         } else if (data.body.t === "update-machine") {
-          logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
+          persistence.logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
         } else {
           this.emit("message", data.body);
         }
       } catch (error) {
-        logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
+        persistence.logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
       }
     });
     this.socket.on("error", (error) => {
-      logger.debug("[API] Socket error:", error);
+      persistence.logger.debug("[API] Socket error:", error);
     });
     this.socket.on("server-draining", (data) => {
       const parsed = ReleaseDrainNoticeSchema.safeParse(data);
@@ -3430,12 +2745,12 @@ class ApiSessionClient extends node_events.EventEmitter {
     this.socket.connect();
   }
   createControlSocket(handover) {
-    return socket_ioClient.io(configuration.serverUrl, {
+    return socket_ioClient.io(persistence.configuration.serverUrl, {
       auth: {
         token: this.token,
         clientType: "session-scoped",
         sessionId: this.sessionId,
-        happyClient: `cli-coding-session/${configuration.currentCliVersion}`,
+        happyClient: `cli-coding-session/${persistence.configuration.currentCliVersion}`,
         ...handover ? { handoverEpoch: handover.epoch } : {}
       },
       ...handover ? { query: { vh_slot: handover.candidateSlot }, forceNew: true } : {},
@@ -3516,7 +2831,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       this.rpcHandlerManager.onSocketDisconnect(candidate);
       candidate.close();
       if (previous.connected) previous.emit("release-handover-result", { result: "failed", durationMs: Date.now() - startedAt });
-      logger.debug(`[API] Release handover failed: ${error instanceof Error ? error.message : error}`);
+      persistence.logger.debug(`[API] Release handover failed: ${error instanceof Error ? error.message : error}`);
     }
   }
   onUserMessage(callback) {
@@ -3550,7 +2865,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * presigned URL that does not accept extra headers.
    */
   async downloadAttachment(ref) {
-    const requestUrl = `${configuration.serverUrl}/v1/sessions/${this.sessionId}/attachments/request-download`;
+    const requestUrl = `${persistence.configuration.serverUrl}/v1/sessions/${this.sessionId}/attachments/request-download`;
     const requestRes = await axios.post(
       requestUrl,
       { ref },
@@ -3563,7 +2878,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     if (typeof downloadUrl !== "string") {
       throw new Error("request-download returned no downloadUrl");
     }
-    const isServerUrl = downloadUrl.startsWith(configuration.serverUrl);
+    const isServerUrl = downloadUrl.startsWith(persistence.configuration.serverUrl);
     const headers = {};
     if (isServerUrl) {
       headers["Authorization"] = `Bearer ${this.token}`;
@@ -3585,7 +2900,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   async downloadAndDecryptAttachment(ref) {
     const encrypted = await this.downloadAttachment(ref);
     const key = await this.getBlobKey();
-    const decrypted = decryptBlob(encrypted, key);
+    const decrypted = persistence.decryptBlob(encrypted, key);
     return decrypted;
   }
   /**
@@ -3614,7 +2929,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     return {
       "Authorization": `Bearer ${this.token}`,
       "Content-Type": "application/json",
-      "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+      "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
     };
   }
   routeIncomingMessage(message, sourceLocalId) {
@@ -3630,7 +2945,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
     const fileResult = FileEventMessageSchema.safeParse(message);
     if (fileResult.success) {
-      logger.debug(`[API] Received file event: ${fileResult.data.content.data.ev.name} (ref: ${fileResult.data.content.data.ev.ref})`);
+      persistence.logger.debug(`[API] Received file event: ${fileResult.data.content.data.ev.name} (ref: ${fileResult.data.content.data.ev.ref})`);
       if (this.pendingFileEventCallback) {
         this.pendingFileEventCallback(fileResult.data);
       } else {
@@ -3644,12 +2959,12 @@ class ApiSessionClient extends node_events.EventEmitter {
     const skipRouting = this.skipInitialMessages;
     if (skipRouting) {
       this.skipInitialMessages = false;
-      logger.debug("[API] Reconnect mode: skipping existing messages, advancing lastSeq");
+      persistence.logger.debug("[API] Reconnect mode: skipping existing messages, advancing lastSeq");
     }
     let afterSeq = this.lastSeq;
     while (true) {
       const response = await axios.get(
-        `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+        `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
         {
           params: {
             after_seq: afterSeq,
@@ -3676,11 +2991,11 @@ class ApiSessionClient extends node_events.EventEmitter {
           continue;
         }
         try {
-          const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(message.content.c));
+          const body = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(message.content.c));
           this.routeIncomingMessage(body, message.localId);
           if (message.localId) this.rememberRoutedInbound(message.localId);
         } catch (error) {
-          logger.debug("[API] Failed to decrypt fetched message", {
+          persistence.logger.debug("[API] Failed to decrypt fetched message", {
             sessionId: this.sessionId,
             seq: message.seq,
             error
@@ -3690,7 +3005,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       this.lastSeq = Math.max(this.lastSeq, maxSeq);
       const hasMore = !!response.data.hasMore;
       if (hasMore && maxSeq === afterSeq) {
-        logger.debug("[API] fetchMessages pagination stalled, stopping to avoid infinite loop", {
+        persistence.logger.debug("[API] fetchMessages pagination stalled, stopping to avoid infinite loop", {
           sessionId: this.sessionId,
           afterSeq
         });
@@ -3709,7 +3024,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       const batchSize = Math.min(this.pendingOutbox.length, ApiSessionClient.MAX_OUTBOX_BATCH_SIZE);
       const batch = this.pendingOutbox.slice(0, batchSize);
       const response = await axios.post(
-        `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+        `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
         {
           messages: batch
         },
@@ -3744,7 +3059,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     if (!machineId || this.relaySocket?.connected) return;
     try {
       const response = await fetch(
-        `${configuration.serverUrl}/v1/relays/sessions/${encodeURIComponent(this.sessionId)}/machines/${encodeURIComponent(machineId)}`,
+        `${persistence.configuration.serverUrl}/v1/relays/sessions/${encodeURIComponent(this.sessionId)}/machines/${encodeURIComponent(machineId)}`,
         { headers: this.authHeaders(), cache: "no-store" }
       );
       if (!response.ok) return;
@@ -3763,7 +3078,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       relaySocket.on("connect", () => {
         if (this.relaySocket !== relaySocket) return;
         this.rpcHandlerManager.onSocketConnect(relaySocket);
-        logger.debug(`[API] Session connected to regional relay ${assignment.relayId}`);
+        persistence.logger.debug(`[API] Session connected to regional relay ${assignment.relayId}`);
       });
       relaySocket.on("rpc-request", async (data, callback) => {
         callback(await this.rpcHandlerManager.handleRequest(data));
@@ -3785,7 +3100,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         for (const item of batch) this.rememberDirectInbound(item.localId);
         try {
           const persisted = await axios.post(
-            `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+            `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
             { messages: batch },
             { headers: this.authHeaders(), timeout: 6e4 }
           );
@@ -3797,7 +3112,7 @@ class ApiSessionClient extends node_events.EventEmitter {
           this.lastSeq = stored.reduce((max, message) => Math.max(max, message.seq), this.lastSeq);
           for (const item of batch) {
             if (this.routedInboundLocalIds.has(item.localId)) continue;
-            const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(item.content));
+            const body = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(item.content));
             this.routeIncomingMessage(body, item.localId);
             this.rememberRoutedInbound(item.localId);
           }
@@ -3811,7 +3126,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         if (this.relaySocket === relaySocket) this.rpcHandlerManager.onSocketDisconnect(relaySocket);
       });
     } catch (error) {
-      logger.debug(`[API] Session regional relay unavailable: ${error instanceof Error ? error.message : error}`);
+      persistence.logger.debug(`[API] Session regional relay unavailable: ${error instanceof Error ? error.message : error}`);
     }
   }
   pushCommittedMessagesToRelay(batch, messages) {
@@ -3831,7 +3146,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
   }
   enqueueMessage(content, invalidate = true, localId) {
-    const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const encrypted = persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, content));
     this.pendingOutbox.push({
       content: encrypted,
       // Deterministic localIds (terminal mirror, B-105) ride the server's
@@ -3873,7 +3188,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       while (!reachedBoundary && pages < MAX_SCAN_PAGES) {
         pages += 1;
         const response = await axios.get(
-          `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+          `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
           {
             params: { before_seq: beforeSeq, limit: 100 },
             headers: this.authHeaders(),
@@ -3885,9 +3200,9 @@ class ApiSessionClient extends node_events.EventEmitter {
         const records = messages.map((message) => {
           let body = null;
           try {
-            body = message.content?.t === "encrypted" ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(message.content.c)) : null;
+            body = message.content?.t === "encrypted" ? persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(message.content.c)) : null;
           } catch (error) {
-            logger.debug("[API] Failed to decrypt during undelivered scan:", error);
+            persistence.logger.debug("[API] Failed to decrypt during undelivered scan:", error);
           }
           return { seq: message.seq, localId: message.localId, body };
         });
@@ -3900,11 +3215,11 @@ class ApiSessionClient extends node_events.EventEmitter {
         beforeSeq = oldest;
       }
     } catch (error) {
-      logger.debug("[API] cancelUndeliveredQueuedInputs scan failed:", error);
+      persistence.logger.debug("[API] cancelUndeliveredQueuedInputs scan failed:", error);
       return;
     }
     if (!reachedBoundary) {
-      logger.debug("[API] cancelUndeliveredQueuedInputs found no turn boundary; leaving messages as-is");
+      persistence.logger.debug("[API] cancelUndeliveredQueuedInputs found no turn boundary; leaving messages as-is");
       return;
     }
     undelivered.reverse();
@@ -3926,7 +3241,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         const eventId = typeof body.uuid === "string" ? body.uuid : typeof body.message.id === "string" ? body.message.id : void 0;
         this.sendUsageData(body.message.usage, body.message.model, eventId);
       } catch (error) {
-        logger.debug("[SOCKET] Failed to send usage data:", error);
+        persistence.logger.debug("[SOCKET] Failed to send usage data:", error);
       }
     }
     if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
@@ -3993,7 +3308,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         sentFrom: "cli"
       }
     };
-    logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
+    persistence.logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
     this.enqueueMessage(content);
   }
   sendSessionEvent(event, id) {
@@ -4012,7 +3327,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    */
   keepAlive(thinking, mode) {
     if (process.env.DEBUG) {
-      logger.debug(`[API] Sending keep alive message: ${thinking}`);
+      persistence.logger.debug(`[API] Sending keep alive message: ${thinking}`);
     }
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
@@ -4041,11 +3356,11 @@ class ApiSessionClient extends node_events.EventEmitter {
         // The frame object, NOT a JSON string: `encrypt` serializes
         // internally, so pre-stringifying would double-encode and
         // escape every quote in the streamed text.
-        payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, frame)),
+        payload: persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, frame)),
         enc: true
       });
     } catch (error) {
-      logger.debug(`[API] Failed to relay stream frame: ${error}`);
+      persistence.logger.debug(`[API] Failed to relay stream frame: ${error}`);
     }
   }
   /**
@@ -4062,12 +3377,12 @@ class ApiSessionClient extends node_events.EventEmitter {
    * Returns delivery info for the MCP tool to report back to the model.
    */
   pushClipboard(text) {
-    const prepared = limits.prepareClipboardText(text);
+    const prepared = persistence.prepareClipboardText(text);
     if (!this.socket.connected) {
       return { delivered: false, truncated: prepared.truncated, totalBytes: prepared.totalBytes };
     }
     this.socket.emit("clipboard-push", {
-      payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, prepared.text)),
+      payload: persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, prepared.text)),
       enc: true,
       truncated: prepared.truncated,
       totalBytes: prepared.totalBytes
@@ -4093,7 +3408,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       return { delivered: false, error: "not connected to the server" };
     }
     this.socket.emit("file-preview-push", {
-      payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, path)),
+      payload: persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, path)),
       enc: true,
       mode
     });
@@ -4133,7 +3448,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         output: this.claudeUsageTotals.costOutput
       }
     };
-    logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
+    persistence.logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
     this.socket.emit("usage-report", usageReport);
   }
   /** Save a provider's cumulative session snapshot under one upsert key. */
@@ -4148,7 +3463,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       // The Web treats this sentinel as unknown, not as real $0.00.
       cost: { total: 0 }
     };
-    logger.debugLargeJson("[SOCKET] Sending agent usage snapshot:", usageReport);
+    persistence.logger.debugLargeJson("[SOCKET] Sending agent usage snapshot:", usageReport);
     this.socket.emit("usage-report", usageReport);
     return true;
   }
@@ -4181,15 +3496,15 @@ class ApiSessionClient extends node_events.EventEmitter {
       let rateRefusals = 0;
       await backoff(async () => {
         let updated = handler(this.metadata);
-        const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) });
+        const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, updated)) });
         if (answer.result === "success") {
-          this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
+          this.metadata = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(answer.metadata));
           this.metadataVersion = answer.version;
           rateRefusals = 0;
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.metadataVersion) {
             this.metadataVersion = answer.version;
-            this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
+            this.metadata = persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(answer.metadata));
           }
           throw new Error("Metadata version mismatch");
         } else if (answer.result === "error") {
@@ -4200,7 +3515,7 @@ class ApiSessionClient extends node_events.EventEmitter {
               code: answer.error,
               attempt: rateRefusals,
               sleep: delay,
-              log: (message) => logger.debug(message)
+              log: (message) => persistence.logger.debug(message)
             });
           }
           throw new Error("Metadata update failed");
@@ -4213,21 +3528,21 @@ class ApiSessionClient extends node_events.EventEmitter {
    * @param handler - Handler function that returns the updated agent state
    */
   updateAgentState(handler) {
-    logger.debugLargeJson("Updating agent state", this.agentState);
+    persistence.logger.debugLargeJson("Updating agent state", this.agentState);
     this.agentStateLock.inLock(async () => {
       let rateRefusals = 0;
       await backoff(async () => {
         let updated = handler(this.agentState || {});
-        const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
+        const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
         if (answer.result === "success") {
-          this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
+          this.agentState = answer.agentState ? persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(answer.agentState)) : null;
           this.agentStateVersion = answer.version;
           rateRefusals = 0;
-          logger.debug("Agent state updated", this.agentState);
+          persistence.logger.debug("Agent state updated", this.agentState);
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.agentStateVersion) {
             this.agentStateVersion = answer.version;
-            this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
+            this.agentState = answer.agentState ? persistence.decrypt(this.encryptionKey, this.encryptionVariant, persistence.decodeBase64(answer.agentState)) : null;
           }
           throw new Error("Agent state version mismatch");
         } else if (answer.result === "error") {
@@ -4238,7 +3553,7 @@ class ApiSessionClient extends node_events.EventEmitter {
               code: answer.error,
               attempt: rateRefusals,
               sleep: delay,
-              log: (message) => logger.debug(message)
+              log: (message) => persistence.logger.debug(message)
             });
           }
           throw new Error("Agent state update failed");
@@ -4267,7 +3582,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     });
   }
   async close() {
-    logger.debug("[API] socket.close() called");
+    persistence.logger.debug("[API] socket.close() called");
     this.sendSync.stop();
     this.receiveSync.stop();
     if (this.reconnectInterval) {
@@ -4287,14 +3602,14 @@ class ApiSessionClient extends node_events.EventEmitter {
         return;
       }
       if (!shouldReconnect()) {
-        logger.debug("[API] Still not ready to reconnect");
+        persistence.logger.debug("[API] Still not ready to reconnect");
         return;
       }
-      logger.debug("[API] Attempting reconnect");
+      persistence.logger.debug("[API] Attempting reconnect");
       this.socket.connect();
     }, 3e3);
     if (shouldReconnect()) {
-      logger.debug("[API] Network up + lid open \u2014 reconnecting in 1s");
+      persistence.logger.debug("[API] Network up + lid open \u2014 reconnecting in 1s");
       setTimeout(() => {
         if (!this.socket.connected) this.socket.connect();
       }, 1e3);
@@ -4445,12 +3760,12 @@ function normalizeFsPath(input, homeDir) {
   if (p === "~") {
     p = homeDir;
   } else if (p.startsWith("~/")) {
-    p = path.join(homeDir, p.slice(2));
+    p = path$1.join(homeDir, p.slice(2));
   }
-  if (!path.isAbsolute(p)) {
-    p = path.join(homeDir, p);
+  if (!path$1.isAbsolute(p)) {
+    p = path$1.join(homeDir, p);
   }
-  return path.resolve(p);
+  return path$1.resolve(p);
 }
 function isBinaryContent(bytes) {
   const n = Math.min(bytes.length, BINARY_SNIFF_BYTES);
@@ -4490,13 +3805,13 @@ function fsError(error) {
   if (error instanceof Error) return error;
   return new Error("fs-failed");
 }
-async function fsList(inputPath, homeDir = os.homedir()) {
-  const path$1 = normalizeFsPath(inputPath, homeDir);
+async function fsList(inputPath, homeDir = os$1.homedir()) {
+  const path = normalizeFsPath(inputPath, homeDir);
   let dirents;
   try {
-    const st = await promises.stat(path$1);
+    const st = await promises.stat(path);
     if (!st.isDirectory()) throw new Error("not-a-directory");
-    dirents = await promises.readdir(path$1, { withFileTypes: true });
+    dirents = await promises.readdir(path, { withFileTypes: true });
   } catch (error) {
     throw fsError(error);
   }
@@ -4504,7 +3819,7 @@ async function fsList(inputPath, homeDir = os.homedir()) {
     dirents.map(async (d) => {
       const entry = { name: d.name, type: entryTypeOf(d) };
       try {
-        const s = await promises.lstat(path.join(path$1, d.name));
+        const s = await promises.lstat(path$1.join(path, d.name));
         entry.size = s.size;
         entry.mtimeMs = Math.round(s.mtimeMs);
       } catch {
@@ -4515,12 +3830,12 @@ async function fsList(inputPath, homeDir = os.homedir()) {
   entries.sort(compareFsEntries);
   const truncated = entries.length > FS_LIST_MAX_ENTRIES;
   return {
-    path: path$1,
+    path,
     entries: truncated ? entries.slice(0, FS_LIST_MAX_ENTRIES) : entries,
     truncated
   };
 }
-async function fsRead(inputPath, options = {}, homeDir = os.homedir()) {
+async function fsRead(inputPath, options = {}, homeDir = os$1.homedir()) {
   const path = normalizeFsPath(inputPath, homeDir);
   const limit = clampReadLimit(options.maxBytes);
   const offset = clampReadOffset(options.offset);
@@ -4552,400 +3867,15 @@ async function fsRead(inputPath, options = {}, homeDir = os.homedir()) {
 }
 function registerFsHandlers(rpcHandlerManager) {
   rpcHandlerManager.registerHandler("fs-list", async (params) => {
-    logger.debug("[FS RPC] fs-list", params?.path);
+    persistence.logger.debug("[FS RPC] fs-list", params?.path);
     return fsList(params?.path);
   });
   rpcHandlerManager.registerHandler("fs-read", async (params) => {
-    logger.debug("[FS RPC] fs-read", params?.path);
+    persistence.logger.debug("[FS RPC] fs-read", params?.path);
     return fsRead(params?.path, { maxBytes: params?.maxBytes, allowBinary: params?.allowBinary === true, offset: params?.offset });
   });
 }
 
-const DEFAULT_SERVER_URL = "https://veryhappy.dev";
-const LEGACY_CLOUD_SERVER_URL = "https://happy.mereith.com";
-const CLOUD_SERVER_URLS = [DEFAULT_SERVER_URL, LEGACY_CLOUD_SERVER_URL];
-function sameRelay(left, right) {
-  try {
-    return new URL(left).origin === new URL(right).origin;
-  } catch {
-    return left.replace(/\/+$/, "") === right.replace(/\/+$/, "");
-  }
-}
-function credentialRelayProblem(credentialServerUrl, configuredServerUrl) {
-  if (credentialServerUrl) {
-    return sameRelay(credentialServerUrl, configuredServerUrl) ? void 0 : `Credentials belong to ${credentialServerUrl}, but the active relay is ${configuredServerUrl}.`;
-  }
-  if (CLOUD_SERVER_URLS.some((cloudUrl) => sameRelay(configuredServerUrl, cloudUrl))) {
-    return void 0;
-  }
-  return `These credentials predate relay tracking, so they cannot be safely reused with ${configuredServerUrl}.`;
-}
-
-const SandboxConfigSchema = z__namespace.object({
-  enabled: z__namespace.boolean().default(false),
-  workspaceRoot: z__namespace.string().optional(),
-  sessionIsolation: z__namespace.enum(["strict", "workspace", "custom"]).default("workspace"),
-  customWritePaths: z__namespace.array(z__namespace.string()).default([]),
-  denyReadPaths: z__namespace.array(z__namespace.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
-  extraWritePaths: z__namespace.array(z__namespace.string()).default(["/tmp"]),
-  denyWritePaths: z__namespace.array(z__namespace.string()).default([".env"]),
-  networkMode: z__namespace.enum(["blocked", "allowed", "custom"]).default("allowed"),
-  allowedDomains: z__namespace.array(z__namespace.string()).default([]),
-  deniedDomains: z__namespace.array(z__namespace.string()).default([]),
-  allowLocalBinding: z__namespace.boolean().default(true)
-});
-const SUPPORTED_SCHEMA_VERSION = 2;
-const defaultSettings = {
-  schemaVersion: SUPPORTED_SCHEMA_VERSION,
-  onboardingCompleted: false,
-  sandboxConfig: void 0
-};
-function migrateSettings(raw, fromVersion) {
-  let migrated = { ...raw };
-  return migrated;
-}
-async function readSettingsOutcome() {
-  if (!node_fs.existsSync(configuration.settingsFile)) {
-    return { kind: "absent" };
-  }
-  try {
-    return { kind: "ok", settings: await parseSettingsFile() };
-  } catch (error) {
-    return { kind: "unreadable", error: error?.message ?? String(error) };
-  }
-}
-async function readSettings() {
-  const outcome = await readSettingsOutcome();
-  if (outcome.kind === "ok") return outcome.settings;
-  if (outcome.kind === "unreadable") {
-    logger.warn(`Failed to read settings: ${outcome.error}`);
-  }
-  return { ...defaultSettings };
-}
-async function parseSettingsFile() {
-  const content = await promises.readFile(configuration.settingsFile, "utf8");
-  const raw = JSON.parse(content);
-  const schemaVersion = raw.schemaVersion ?? 1;
-  if (schemaVersion > SUPPORTED_SCHEMA_VERSION) {
-    logger.warn(
-      `\u26A0\uFE0F Settings schema v${schemaVersion} > supported v${SUPPORTED_SCHEMA_VERSION}. Update happy-cli for full functionality.`
-    );
-  }
-  const migrated = migrateSettings(raw);
-  if (migrated.sandboxConfig !== void 0) {
-    try {
-      migrated.sandboxConfig = SandboxConfigSchema.parse(migrated.sandboxConfig);
-    } catch (error) {
-      logger.warn(`\u26A0\uFE0F Invalid sandbox config - skipping. Error: ${error.message}`);
-      migrated.sandboxConfig = void 0;
-    }
-  }
-  return { ...defaultSettings, ...migrated };
-}
-async function writeSettings(settings) {
-  await ensurePrivateDirectory(configuration.happyHomeDir);
-  const settingsWithVersion = {
-    ...settings,
-    schemaVersion: settings.schemaVersion ?? SUPPORTED_SCHEMA_VERSION
-  };
-  await writePrivateFile(configuration.settingsFile, JSON.stringify(settingsWithVersion, null, 2));
-}
-async function updateSettings(updater) {
-  const LOCK_RETRY_INTERVAL_MS = 100;
-  const MAX_LOCK_ATTEMPTS = 50;
-  const STALE_LOCK_TIMEOUT_MS = 1e4;
-  const lockFile = configuration.settingsFile + ".lock";
-  const tmpFile = configuration.settingsFile + ".tmp";
-  let fileHandle;
-  let attempts = 0;
-  while (attempts < MAX_LOCK_ATTEMPTS) {
-    try {
-      fileHandle = await promises.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY, PRIVATE_FILE_MODE);
-      break;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        attempts++;
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
-        try {
-          const stats = await promises.stat(lockFile);
-          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
-            await promises.unlink(lockFile).catch(() => {
-            });
-          }
-        } catch {
-        }
-      } else {
-        throw err;
-      }
-    }
-  }
-  if (!fileHandle) {
-    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
-  }
-  try {
-    const outcome = await readSettingsOutcome();
-    if (outcome.kind === "unreadable") {
-      throw new Error(
-        `Settings file ${configuration.settingsFile} exists but could not be read (${outcome.error}). Refusing to overwrite it \u2014 fix or remove the file (a removed file is recreated with defaults).`
-      );
-    }
-    const current = outcome.kind === "ok" ? outcome.settings : { ...defaultSettings };
-    const updated = await updater(current);
-    await ensurePrivateDirectory(configuration.happyHomeDir);
-    await writePrivateFile(tmpFile, JSON.stringify(updated, null, 2));
-    await promises.rename(tmpFile, configuration.settingsFile);
-    await hardenPrivateFile(configuration.settingsFile);
-    return updated;
-  } finally {
-    await fileHandle.close();
-    await promises.unlink(lockFile).catch(() => {
-    });
-  }
-}
-const credentialsSchema = z__namespace.object({
-  token: z__namespace.string(),
-  authServerUrl: z__namespace.string().optional(),
-  secret: z__namespace.string().base64().nullish(),
-  // Legacy
-  encryption: z__namespace.object({
-    publicKey: z__namespace.string().base64(),
-    machineKey: z__namespace.string().base64()
-  }).nullish()
-});
-async function readCredentials() {
-  if (!node_fs.existsSync(configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await promises.readFile(configuration.privateKeyFile, "utf8");
-    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
-    if (credentials.secret) {
-      return {
-        token: credentials.token,
-        authServerUrl: credentials.authServerUrl,
-        encryption: {
-          type: "legacy",
-          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
-        }
-      };
-    } else if (credentials.encryption) {
-      return {
-        token: credentials.token,
-        authServerUrl: credentials.authServerUrl,
-        encryption: {
-          type: "dataKey",
-          publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, "base64")),
-          machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, "base64"))
-        }
-      };
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-async function readCredentialsForConfiguredRelay() {
-  const credentials = await readCredentials();
-  if (!credentials) return null;
-  const relayProblem = credentialRelayProblem(credentials.authServerUrl, configuration.serverUrl);
-  if (relayProblem) {
-    throw new Error(
-      `${relayProblem} Use a separate HAPPY_HOME_DIR for this relay, or run \`very-happy auth login --force\` before making relay requests.`
-    );
-  }
-  return credentials;
-}
-async function writeCredentialsLegacy(credentials) {
-  await ensurePrivateDirectory(configuration.happyHomeDir);
-  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token,
-    authServerUrl: configuration.serverUrl
-  }, null, 2));
-}
-async function writeCredentialsDataKey(credentials) {
-  await ensurePrivateDirectory(configuration.happyHomeDir);
-  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
-    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
-    token: credentials.token,
-    authServerUrl: configuration.serverUrl
-  }, null, 2));
-}
-async function clearCredentials() {
-  if (node_fs.existsSync(configuration.privateKeyFile)) {
-    await promises.unlink(configuration.privateKeyFile);
-  }
-}
-async function clearMachineId() {
-  await updateSettings((settings) => ({
-    ...settings,
-    machineId: void 0
-  }));
-}
-async function readDaemonState() {
-  try {
-    if (!node_fs.existsSync(configuration.daemonStateFile)) {
-      return null;
-    }
-    const content = await promises.readFile(configuration.daemonStateFile, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
-    return null;
-  }
-}
-function writeDaemonState(state) {
-  writePrivateFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2));
-}
-async function clearDaemonState() {
-  if (node_fs.existsSync(configuration.daemonStateFile)) {
-    await promises.unlink(configuration.daemonStateFile);
-  }
-  if (node_fs.existsSync(configuration.daemonLockFile)) {
-    try {
-      await promises.unlink(configuration.daemonLockFile);
-    } catch {
-    }
-  }
-}
-async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      const fileHandle = await promises.open(
-        configuration.daemonLockFile,
-        node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY,
-        PRIVATE_FILE_MODE
-      );
-      await fileHandle.writeFile(String(process.pid));
-      return fileHandle;
-    } catch (error) {
-      if (error.code === "EEXIST") {
-        try {
-          const lockPid = node_fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
-          if (lockPid && !isNaN(Number(lockPid))) {
-            try {
-              process.kill(Number(lockPid), 0);
-            } catch {
-              node_fs.unlinkSync(configuration.daemonLockFile);
-              continue;
-            }
-          }
-        } catch {
-        }
-      }
-      if (attempt === maxAttempts) {
-        return null;
-      }
-      const delayMs = attempt * delayIncrementMs;
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-  }
-  return null;
-}
-async function releaseDaemonLock(lockHandle) {
-  try {
-    await lockHandle.close();
-  } catch {
-  }
-  try {
-    if (node_fs.existsSync(configuration.daemonLockFile)) {
-      node_fs.unlinkSync(configuration.daemonLockFile);
-    }
-  } catch {
-  }
-}
-const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
-function readPersistedSessions() {
-  try {
-    if (!node_fs.existsSync(configuration.sessionsFile)) return {};
-    const data = JSON.parse(node_fs.readFileSync(configuration.sessionsFile, "utf-8"));
-    if (!data?.sessions || typeof data.sessions !== "object") return {};
-    const now = Date.now();
-    const sessions = {};
-    for (const [id, session] of Object.entries(data.sessions)) {
-      if (now - session.savedAt < SESSION_MAX_AGE_MS) {
-        sessions[id] = session;
-      }
-    }
-    return sessions;
-  } catch {
-    return {};
-  }
-}
-function readTrackedClaudeSessionIds() {
-  try {
-    if (!node_fs.existsSync(configuration.sessionsFile)) return [];
-    const data = JSON.parse(node_fs.readFileSync(configuration.sessionsFile, "utf-8"));
-    if (!data?.sessions || typeof data.sessions !== "object") return [];
-    const ids = /* @__PURE__ */ new Set();
-    for (const session of Object.values(data.sessions)) {
-      const metadata = (session ?? {}).metadata;
-      for (const id of [metadata?.claudeSessionId, metadata?.importedFromClaudeSessionId]) {
-        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
-      }
-    }
-    return [...ids];
-  } catch {
-    return [];
-  }
-}
-function persistSession(sessionId, session) {
-  try {
-    const existing = readPersistedSessions();
-    existing[sessionId] = session;
-    const tmpFile = configuration.sessionsFile + ".tmp";
-    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
-    node_fs.renameSync(tmpFile, configuration.sessionsFile);
-    hardenPrivateFileSync(configuration.sessionsFile);
-  } catch (error) {
-    logger.debug(`[PERSISTENCE] Failed to persist session ${sessionId}:`, error);
-  }
-}
-function deletePersistedSessions(sessionIds) {
-  try {
-    const existing = readPersistedSessions();
-    let changed = false;
-    for (const id of sessionIds) {
-      if (id in existing) {
-        delete existing[id];
-        changed = true;
-      }
-    }
-    if (!changed) return;
-    const tmpFile = configuration.sessionsFile + ".tmp";
-    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
-    node_fs.renameSync(tmpFile, configuration.sessionsFile);
-    hardenPrivateFileSync(configuration.sessionsFile);
-  } catch (error) {
-    logger.debug(`[PERSISTENCE] Failed to delete persisted sessions:`, error);
-  }
-}
-
-var persistence = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SUPPORTED_SCHEMA_VERSION: SUPPORTED_SCHEMA_VERSION,
-  SandboxConfigSchema: SandboxConfigSchema,
-  acquireDaemonLock: acquireDaemonLock,
-  clearCredentials: clearCredentials,
-  clearDaemonState: clearDaemonState,
-  clearMachineId: clearMachineId,
-  deletePersistedSessions: deletePersistedSessions,
-  persistSession: persistSession,
-  readCredentials: readCredentials,
-  readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay,
-  readDaemonState: readDaemonState,
-  readPersistedSessions: readPersistedSessions,
-  readSettings: readSettings,
-  readSettingsOutcome: readSettingsOutcome,
-  readTrackedClaudeSessionIds: readTrackedClaudeSessionIds,
-  releaseDaemonLock: releaseDaemonLock,
-  updateSettings: updateSettings,
-  writeCredentialsDataKey: writeCredentialsDataKey,
-  writeCredentialsLegacy: writeCredentialsLegacy,
-  writeDaemonState: writeDaemonState,
-  writeSettings: writeSettings
-});
-
 const TODO_LIST_MAX_ITEMS = 500;
 const TODO_TITLE_MAX_CHARS = 500;
 const FIELD_MAX_CHARS = 200;
@@ -5011,7 +3941,7 @@ function buildProviderArgv(config, verb, operand) {
 const DEFAULT_TIMEOUT_MS = 2e4;
 const MAX_STDOUT_BYTES = 2 * 1024 * 1024;
 async function readProviderConfig() {
-  const settings = await readSettings();
+  const settings = await persistence.readSettings();
   const raw = settings?.todoProvider;
   if (!raw || typeof raw !== "object") return null;
   const cfg = raw;
@@ -5090,7 +4020,7 @@ function registerTodoHandlers(manager) {
     if ("error" in parsed) {
       throw new Error(`bad-output: ${parsed.error}`);
     }
-    logger.debug(`[todo] list \u2192 ${parsed.items.length} items (dropped ${parsed.dropped})`);
+    persistence.logger.debug(`[todo] list \u2192 ${parsed.items.length} items (dropped ${parsed.dropped})`);
     return { ...parsed, machineConfigured: true };
   });
   manager.registerHandler("todo-complete", async (params) => {
@@ -5304,14 +4234,14 @@ function scrubTmuxClientEnv(env) {
 }
 
 function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || path$1.join(os$1.homedir(), ".claude");
 }
 function getClaudeProjectsRoot() {
-  return path.join(getClaudeConfigDir(), "projects");
+  return path$1.join(getClaudeConfigDir(), "projects");
 }
 function getProjectPath(workingDirectory) {
-  const projectId = path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  return path.join(getClaudeProjectsRoot(), projectId);
+  const projectId = path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return path$1.join(getClaudeProjectsRoot(), projectId);
 }
 
 var xtermHeadless = {};
@@ -9656,18 +8586,18 @@ class ControlClient {
     });
     this.child.stdout.on("data", (chunk) => this.consume(this.decoder.push(chunk)));
     this.child.stderr.on("data", (chunk) => {
-      logger.debug(`[CONTROL ${tmuxSession}] stderr: ${chunk.toString("utf8").trim()}`);
+      persistence.logger.debug(`[CONTROL ${tmuxSession}] stderr: ${chunk.toString("utf8").trim()}`);
     });
     this.child.stdin.on("error", (e) => {
-      logger.debug(`[CONTROL ${tmuxSession}] stdin error (session gone?): ${e}`);
+      persistence.logger.debug(`[CONTROL ${tmuxSession}] stdin error (session gone?): ${e}`);
     });
     this.child.stdout.on("error", (e) => {
-      logger.debug(`[CONTROL ${tmuxSession}] stdout error: ${e}`);
+      persistence.logger.debug(`[CONTROL ${tmuxSession}] stdout error: ${e}`);
     });
     this.child.stderr.on("error", () => {
     });
     this.child.on("error", (e) => {
-      logger.debug(`[CONTROL ${tmuxSession}] spawn error: ${e}`);
+      persistence.logger.debug(`[CONTROL ${tmuxSession}] spawn error: ${e}`);
       this.failAll(new Error(`control client failed: ${e}`));
     });
     this.child.on("exit", (code, signal) => {
@@ -9704,7 +8634,7 @@ class ControlClient {
         if (!ev.solicited) continue;
         const pending = this.queue.shift();
         if (!pending) {
-          logger.debug(`[CONTROL ${this.tmuxSession}] unmatched block cmd=${ev.cmdNum}`);
+          persistence.logger.debug(`[CONTROL ${this.tmuxSession}] unmatched block cmd=${ev.cmdNum}`);
           continue;
         }
         clearTimeout(pending.timer);
@@ -9713,7 +8643,7 @@ class ControlClient {
           try {
             pending.onBlock?.(ev.body);
           } catch (e) {
-            logger.debug(`[CONTROL ${this.tmuxSession}] onBlock threw: ${e}`);
+            persistence.logger.debug(`[CONTROL ${this.tmuxSession}] onBlock threw: ${e}`);
           }
           pending.resolve(ev.body);
         }
@@ -9723,7 +8653,7 @@ class ControlClient {
         this.handlers.onNotification(ev.name, ev.args);
         continue;
       }
-      logger.debug(`[CONTROL ${this.tmuxSession}] protocol error ${ev.reason}: ${ev.detail}`);
+      persistence.logger.debug(`[CONTROL ${this.tmuxSession}] protocol error ${ev.reason}: ${ev.detail}`);
     }
   }
   failAll(err) {
@@ -9784,7 +8714,7 @@ class ControlClient {
     try {
       this.child.stdin.write(text);
     } catch (e) {
-      logger.debug(`[CONTROL ${this.tmuxSession}] write failed (session gone?): ${e}`);
+      persistence.logger.debug(`[CONTROL ${this.tmuxSession}] write failed (session gone?): ${e}`);
     }
   }
   /** SIGTERM → grace → SIGKILL (rule 3). Resolves once the child is gone. */
@@ -9794,7 +8724,7 @@ class ControlClient {
     this.stopping = true;
     return new Promise((resolve) => {
       const killer = setTimeout(() => {
-        logger.debug(`[CONTROL ${this.tmuxSession}] SIGTERM did not land in ${graceMs}ms \u2014 SIGKILL`);
+        persistence.logger.debug(`[CONTROL ${this.tmuxSession}] SIGTERM did not land in ${graceMs}ms \u2014 SIGKILL`);
         try {
           this.child.kill("SIGKILL");
         } catch {
@@ -10389,14 +9319,14 @@ function sendTerminalNotification(opts) {
       headers: {
         "Authorization": `Bearer ${opts.token}`,
         "Content-Type": "application/json",
-        "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+        "X-Happy-Client": `cli-daemon/${persistence.configuration.currentCliVersion}`
       },
       timeout: 15e3
     }
   ).then(() => {
-    logger.debug(`[WEB TERMINAL] notify sent (event=${opts.event}, link=${opts.link})`);
+    persistence.logger.debug(`[WEB TERMINAL] notify sent (event=${opts.event}, link=${opts.link})`);
   }).catch((error) => {
-    logger.debug("[WEB TERMINAL] notify failed:", error);
+    persistence.logger.debug("[WEB TERMINAL] notify failed:", error);
   });
 }
 
@@ -10543,7 +9473,7 @@ function pruneTombstones(map, now, ttlMs = TOMBSTONE_TTL_MS) {
   return out;
 }
 function tombstoneFile() {
-  return path.join(configuration.happyHomeDir, "terminal-tombstones.json");
+  return path$1.join(persistence.configuration.happyHomeDir, "terminal-tombstones.json");
 }
 function loadTombstones() {
   try {
@@ -10555,14 +9485,14 @@ function loadTombstones() {
 }
 function saveTombstones(map) {
   try {
-    node_fs.mkdirSync(configuration.happyHomeDir, { recursive: true });
+    node_fs.mkdirSync(persistence.configuration.happyHomeDir, { recursive: true });
     node_fs.writeFileSync(tombstoneFile(), JSON.stringify(pruneTombstones(map, Date.now())));
   } catch (e) {
-    logger.debug(`[WEB TERMINAL] tombstone save failed: ${e}`);
+    persistence.logger.debug(`[WEB TERMINAL] tombstone save failed: ${e}`);
   }
 }
 function closedTerminalsFile() {
-  return path.join(configuration.happyHomeDir, "closed-terminals.json");
+  return path$1.join(persistence.configuration.happyHomeDir, "closed-terminals.json");
 }
 function loadClosedTerminals() {
   try {
@@ -10573,14 +9503,14 @@ function loadClosedTerminals() {
 }
 function saveClosedTerminals(list) {
   try {
-    node_fs.mkdirSync(configuration.happyHomeDir, { recursive: true });
+    node_fs.mkdirSync(persistence.configuration.happyHomeDir, { recursive: true });
     node_fs.writeFileSync(closedTerminalsFile(), JSON.stringify(list));
   } catch (e) {
-    logger.debug(`[WEB TERMINAL] closed-terminals save failed: ${e}`);
+    persistence.logger.debug(`[WEB TERMINAL] closed-terminals save failed: ${e}`);
   }
 }
 function liveTerminalsFile() {
-  return path.join(configuration.happyHomeDir, "live-terminals.json");
+  return path$1.join(persistence.configuration.happyHomeDir, "live-terminals.json");
 }
 function loadLiveSnapshot() {
   try {
@@ -10591,10 +9521,10 @@ function loadLiveSnapshot() {
 }
 function saveLiveSnapshot(map) {
   try {
-    node_fs.mkdirSync(configuration.happyHomeDir, { recursive: true });
+    node_fs.mkdirSync(persistence.configuration.happyHomeDir, { recursive: true });
     node_fs.writeFileSync(liveTerminalsFile(), JSON.stringify(serializeLiveSnapshot(map)));
   } catch (e) {
-    logger.debug(`[WEB TERMINAL] live-terminals save failed: ${e}`);
+    persistence.logger.debug(`[WEB TERMINAL] live-terminals save failed: ${e}`);
   }
 }
 const TERMINAL_OPEN_TIMEOUT = "terminal-open-timeout";
@@ -10855,7 +9785,7 @@ function tmuxSupportsEnvFlag() {
 }
 const PASTE_FILE_TTL_MS = 5e3;
 function pasteSpoolDir() {
-  const dir = path.join(configuration.happyHomeDir, "paste-spool");
+  const dir = path$1.join(persistence.configuration.happyHomeDir, "paste-spool");
   try {
     node_fs.mkdirSync(dir, { recursive: true, mode: 448 });
   } catch {
@@ -10906,7 +9836,7 @@ function ptyEnv() {
     if (typeof v === "string") env[k] = v;
   }
   scrubTmuxClientEnv(env);
-  const local = `${os.homedir()}/.local/bin`;
+  const local = `${os$1.homedir()}/.local/bin`;
   if (!(env.PATH || "").split(":").includes(local)) {
     env.PATH = `${local}:${env.PATH || ""}`;
   }
@@ -11382,7 +10312,7 @@ class WebTerminalManager {
     try {
       this.emit("terminal-activity", { terminals: updates });
     } catch (e) {
-      logger.debug(`[WEB TERMINAL] activity emit failed: ${e}`);
+      persistence.logger.debug(`[WEB TERMINAL] activity emit failed: ${e}`);
     }
   }
   /** Seed the change signature from a list the caller already delivered by
@@ -11472,7 +10402,7 @@ class WebTerminalManager {
       this.lastListSignature = sig;
       cb(list);
     } catch (e) {
-      logger.debug(`[WEB TERMINAL] list track tick failed: ${e}`);
+      persistence.logger.debug(`[WEB TERMINAL] list track tick failed: ${e}`);
     }
   }
   /** Closed-record diff (B-084): a terminal id that was in the last observed
@@ -11500,7 +10430,7 @@ class WebTerminalManager {
         next.set(id, info);
         continue;
       }
-      persisted ??= readPersistedSessions();
+      persisted ??= persistence.readPersistedSessions();
       const mirror = pickMirrorForTerminal(persisted, id);
       this.closedTerminals = appendClosedTerminal(this.closedTerminals, {
         id,
@@ -11518,11 +10448,11 @@ class WebTerminalManager {
         closedAt: now
       });
       changed = true;
-      logger.debug(`[WEB TERMINAL] recorded closed terminal ${id}`);
+      persistence.logger.debug(`[WEB TERMINAL] recorded closed terminal ${id}`);
       try {
         this.onTerminalClosedCb?.(id);
       } catch (e) {
-        logger.debug(`[WEB TERMINAL] terminal-closed callback failed: ${e}`);
+        persistence.logger.debug(`[WEB TERMINAL] terminal-closed callback failed: ${e}`);
       }
     }
     const pruned = pruneClosedAgainstLive(this.closedTerminals, liveIds);
@@ -11554,7 +10484,7 @@ class WebTerminalManager {
     for (const [id, info] of snapshot) {
       if (liveIds.has(id)) continue;
       if (this.closedTerminals.some((r) => r.id === id)) continue;
-      persisted ??= readPersistedSessions();
+      persisted ??= persistence.readPersistedSessions();
       const mirror = pickMirrorForTerminal(persisted, id);
       this.closedTerminals = appendClosedTerminal(this.closedTerminals, {
         id,
@@ -11583,7 +10513,7 @@ class WebTerminalManager {
     }
     if (recorded > 0) {
       saveClosedTerminals(this.closedTerminals);
-      logger.debug(`[WEB TERMINAL] daemon gap: archived ${recorded} terminal(s) from the persisted snapshot`);
+      persistence.logger.debug(`[WEB TERMINAL] daemon gap: archived ${recorded} terminal(s) from the persisted snapshot`);
     }
     if (candidates.length > 0) void this.autoRestore(candidates, liveIds);
   }
@@ -11601,7 +10531,7 @@ class WebTerminalManager {
     this.autoRestoreDone = true;
     try {
       if (!isTmuxAvailable()) return;
-      const settings = await readSettings();
+      const settings = await persistence.readSettings();
       const config = resolveAutoRestoreConfig(settings);
       const selection = selectAutoRestore(candidates, {
         now: Date.now(),
@@ -11617,7 +10547,7 @@ class WebTerminalManager {
       });
       for (const plan of selection.plans) {
         if (this.shuttingDown) {
-          logger.debug("[WEB TERMINAL] auto-restore aborted: daemon shutting down");
+          persistence.logger.debug("[WEB TERMINAL] auto-restore aborted: daemon shutting down");
           return;
         }
         const ok = this.restoreOneTerminal(plan);
@@ -11630,15 +10560,15 @@ class WebTerminalManager {
       }
       const line = autoRestoreSummary(selection);
       if (line) {
-        logger.info(`[WEB TERMINAL] auto-restore: ${line}`);
+        persistence.logger.info(`[WEB TERMINAL] auto-restore: ${line}`);
         try {
           this.onAutoRestoreSummaryCb?.(line);
         } catch (e) {
-          logger.debug(`[WEB TERMINAL] auto-restore report failed: ${e}`);
+          persistence.logger.debug(`[WEB TERMINAL] auto-restore report failed: ${e}`);
         }
       }
     } catch (e) {
-      logger.debug(`[WEB TERMINAL] auto-restore failed: ${e}`);
+      persistence.logger.debug(`[WEB TERMINAL] auto-restore failed: ${e}`);
     }
   }
   /**
@@ -11684,17 +10614,17 @@ class WebTerminalManager {
           return false;
         }
       },
-      conversationExists: (cwd, claudeSessionId) => node_fs.existsSync(path.join(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
+      conversationExists: (cwd, claudeSessionId) => node_fs.existsSync(path$1.join(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
       // B-273: only consulted for records that were attach terminals.
       // Unbounded: the panel's 50-row cap must not hide a restore target.
       userSessions: record.attachTmux ? this.listUserTmuxSessions(Infinity) : [],
       attachSocket: process.env[VH_TMUX_SOCKET_ENV],
-      homeDir: os.homedir()
+      homeDir: os$1.homedir()
     });
     if (plan.kind === "already-live") return { type: "success", terminalId };
     if (plan.kind === "error") return { type: "error", reason: plan.reason };
     if (!this.createDetachedTerminal(plan)) return { type: "error", reason: "create-failed" };
-    logger.info(`[WEB TERMINAL] restored closed terminal ${terminalId} in ${plan.cwd}${plan.attachTmux ? ` (attached tmux session ${plan.attachTmux})` : plan.command ? " (conversation resumed)" : ""}`);
+    persistence.logger.info(`[WEB TERMINAL] restored closed terminal ${terminalId} in ${plan.cwd}${plan.attachTmux ? ` (attached tmux session ${plan.attachTmux})` : plan.command ? " (conversation resumed)" : ""}`);
     this.kickListRefresh();
     return { type: "success", terminalId };
   }
@@ -11716,7 +10646,7 @@ class WebTerminalManager {
       "-e",
       `VH_TERMINAL_ID=${plan.terminalId}`,
       "-e",
-      `VH_HAPPY_HOME_DIR=${configuration.happyHomeDir}`
+      `VH_HAPPY_HOME_DIR=${persistence.configuration.happyHomeDir}`
     ] : [];
     const { cols, rows } = coldCreateGeometry(plan);
     const created = node_child_process.spawnSync(
@@ -11730,7 +10660,7 @@ class WebTerminalManager {
       { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env }
     ).status === 0;
     if (!live) {
-      logger.debug(`[WEB TERMINAL] auto-restore: tmux create failed for ${plan.terminalId}`);
+      persistence.logger.debug(`[WEB TERMINAL] auto-restore: tmux create failed for ${plan.terminalId}`);
       return false;
     }
     if (plan.title) {
@@ -11767,7 +10697,7 @@ class WebTerminalManager {
         node_child_process.spawnSync("tmux", tmuxArgs(argv), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
       }
     }
-    logger.info(`[WEB TERMINAL] cold-created ${plan.terminalId} in ${plan.cwd}`);
+    persistence.logger.info(`[WEB TERMINAL] cold-created ${plan.terminalId} in ${plan.cwd}`);
     return true;
   }
   /** Mirror the in-memory cache to disk, but only when something a restart
@@ -11801,7 +10731,7 @@ class WebTerminalManager {
       try {
         this.onNotify({ terminalId: item.id, title: item.title || "Terminal", event });
       } catch (e) {
-        logger.debug(`[WEB TERMINAL] notify callback failed: ${e}`);
+        persistence.logger.debug(`[WEB TERMINAL] notify callback failed: ${e}`);
       }
     }
   }
@@ -11815,7 +10745,7 @@ class WebTerminalManager {
     this.snapshots.sweep(now);
     for (const [id, session] of [...this.terminals]) {
       if (session.subscribers === 0 && now - session.lastTouch > SESSION_IDLE_MS) {
-        logger.debug(`[WEB TERMINAL] reaping orphaned idle session ${id} (idle ${Math.round((now - session.lastTouch) / 6e4)}m)`);
+        persistence.logger.debug(`[WEB TERMINAL] reaping orphaned idle session ${id} (idle ${Math.round((now - session.lastTouch) / 6e4)}m)`);
         this.detach(id);
       }
     }
@@ -11841,8 +10771,8 @@ class WebTerminalManager {
       }
       const victimId = unwatchedVictim ?? anyVictim;
       if (!victimId) break;
-      if (!unwatchedVictim) logger.debug(`[WEB TERMINAL] pty cap reached with all sessions claiming watchers; force-evicting LRU ${victimId}`);
-      else logger.debug(`[WEB TERMINAL] pty cap reached (${this.terminals.size}); evicting LRU ${victimId}`);
+      if (!unwatchedVictim) persistence.logger.debug(`[WEB TERMINAL] pty cap reached with all sessions claiming watchers; force-evicting LRU ${victimId}`);
+      else persistence.logger.debug(`[WEB TERMINAL] pty cap reached (${this.terminals.size}); evicting LRU ${victimId}`);
       this.detach(victimId);
     }
   }
@@ -11867,7 +10797,7 @@ class WebTerminalManager {
   async open(opts) {
     const cols = Math.max(2, Math.floor(opts.cols ?? 80));
     const rows = Math.max(2, Math.floor(opts.rows ?? 24));
-    const cwd = opts.cwd && opts.cwd.length > 0 ? opts.cwd : os.homedir();
+    const cwd = opts.cwd && opts.cwd.length > 0 ? opts.cwd : os$1.homedir();
     const id = opts.terminalId && /^[a-zA-Z0-9_-]{1,64}$/.test(opts.terminalId) ? opts.terminalId : node_crypto.randomBytes(5).toString("hex");
     const lines = opts.streamMode === "lines";
     const existing = this.terminals.get(id);
@@ -11878,7 +10808,7 @@ class WebTerminalManager {
       this.applyResize(existing, cols, rows);
       if (opts.fromSeq !== void 0 && existing.ringCovers(opts.fromSeq)) {
         const chunks = existing.chunksAfter(opts.fromSeq);
-        logger.debug(`[WEB TERMINAL] re-subscribed ${id} (subs=${existing.subscribers}, mode=replay, seq=${existing.seq})`);
+        persistence.logger.debug(`[WEB TERMINAL] re-subscribed ${id} (subs=${existing.subscribers}, mode=replay, seq=${existing.seq})`);
         return {
           terminalId: id,
           tmuxSession: existing.tmuxSession,
@@ -11897,7 +10827,7 @@ class WebTerminalManager {
         return { ...await this.linesSnapshotResponse(id, existing), ...echo2 };
       }
       const state = existing.subscribeState(opts.fromSeq);
-      logger.debug(`[WEB TERMINAL] re-subscribed ${id} (subs=${existing.subscribers}, mode=${state.mode}, seq=${state.seq})`);
+      persistence.logger.debug(`[WEB TERMINAL] re-subscribed ${id} (subs=${existing.subscribers}, mode=${state.mode}, seq=${state.seq})`);
       return { terminalId: id, tmuxSession: existing.tmuxSession, ...state, ...echo2 };
     }
     if (opts.attachOnly || opts.resub) {
@@ -11914,7 +10844,7 @@ class WebTerminalManager {
         { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() }
       ).status === 0;
       if (!alive) {
-        logger.debug(`[WEB TERMINAL] refused stale-client resurrection of tombstoned ${id}`);
+        persistence.logger.debug(`[WEB TERMINAL] refused stale-client resurrection of tombstoned ${id}`);
         throw new Error("terminal-gone");
       }
     }
@@ -11936,7 +10866,7 @@ class WebTerminalManager {
         "-e",
         `VH_TERMINAL_ID=${id}`,
         "-e",
-        `VH_HAPPY_HOME_DIR=${configuration.happyHomeDir}`
+        `VH_HAPPY_HOME_DIR=${persistence.configuration.happyHomeDir}`
       ] : [];
       const attachOnly = !!(opts.attachOnly || opts.resub);
       const attachTarget = !attachOnly && opts.attachTmux ? this.resolveAttachTarget(opts.attachTmux) : void 0;
@@ -12022,7 +10952,7 @@ class WebTerminalManager {
         ).status === 0;
         if (!alive) {
           if (attachTarget) throw new Error("tmux-unavailable");
-          logger.info(`[WEB TERMINAL] tmux session creation unavailable; using direct PTY for ${id}`);
+          persistence.logger.info(`[WEB TERMINAL] tmux session creation unavailable; using direct PTY for ${id}`);
           tmuxSession = void 0;
         }
       }
@@ -12060,11 +10990,11 @@ class WebTerminalManager {
             created.announcedRows = size.rows;
             const marker = created.ingest(geometryMarker(size.cols, size.rows));
             this.emit("terminal-output", { terminalId: id, data: marker.data, seq: marker.seq });
-            logger.debug(`[WEB TERMINAL] ${id} pane geometry \u2192 ${size.cols}x${size.rows} (seq=${marker.seq})`);
+            persistence.logger.debug(`[WEB TERMINAL] ${id} pane geometry \u2192 ${size.cols}x${size.rows} (seq=${marker.seq})`);
             return;
           }
           if (name === "exit") {
-            logger.debug(`[WEB TERMINAL] control client for ${id} got %exit (${args2})`);
+            persistence.logger.debug(`[WEB TERMINAL] control client for ${id} got %exit (${args2})`);
           }
         },
         onExit: (code) => {
@@ -12113,7 +11043,7 @@ class WebTerminalManager {
     if (attachedTmux) session.attachedTmux = attachedTmux;
     this.terminals.set(id, session);
     session.onTitleChange(() => this.kickListRefresh());
-    logger.debug(`[WEB TERMINAL] opened ${id} (${tmuxSession ? "control" : "pty"}) ${cols}x${rows} cwd=${cwd}`);
+    persistence.logger.debug(`[WEB TERMINAL] opened ${id} (${tmuxSession ? "control" : "pty"}) ${cols}x${rows} cwd=${cwd}`);
     this.kickListRefresh();
     const echo = attachedTmux ? { attachedTmux } : {};
     if (session.transport.kind !== "control") {
@@ -12147,7 +11077,7 @@ class WebTerminalManager {
         } catch {
         }
       }
-      logger.debug(`[WEB TERMINAL] ${tmuxSession} attaches user tmux session ${attachTarget.id} (${attachTarget.name})`);
+      persistence.logger.debug(`[WEB TERMINAL] ${tmuxSession} attaches user tmux session ${attachTarget.id} (${attachTarget.name})`);
       return { id: attachTarget.id, name: attachTarget.name };
     }
     const startup = normalizeStartupCommand(startupCommand);
@@ -12156,7 +11086,7 @@ class WebTerminalManager {
         for (const a of startupInjectionArgs(tmuxSession, startup)) {
           node_child_process.spawnSync("tmux", tmuxArgs(a), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env });
         }
-        logger.debug(`[WEB TERMINAL] injected startup command into new session ${tmuxSession}`);
+        persistence.logger.debug(`[WEB TERMINAL] injected startup command into new session ${tmuxSession}`);
       } catch {
       }
     }
@@ -12206,7 +11136,7 @@ class WebTerminalManager {
       );
       this.lastUserSessionsProbe = { status: r.status, error: r.error?.message, stderr: (r.stderr || "").toString().trim() || void 0, stdoutBytes: typeof r.stdout === "string" ? r.stdout.length : 0 };
       if (r.status !== 0 || typeof r.stdout !== "string") {
-        logger.debug(`[WEB TERMINAL] list-tmux-sessions failed: ${JSON.stringify(this.lastUserSessionsProbe)}`);
+        persistence.logger.debug(`[WEB TERMINAL] list-tmux-sessions failed: ${JSON.stringify(this.lastUserSessionsProbe)}`);
         return [];
       }
       return parseUserSessions(r.stdout, max);
@@ -12253,7 +11183,7 @@ class WebTerminalManager {
     try {
       bodies = await client.send(requests, CAPTURE_TIMEOUT_MS);
     } catch (e) {
-      logger.debug(`[WEB TERMINAL] capture batch failed for ${session.id}: ${e}`);
+      persistence.logger.debug(`[WEB TERMINAL] capture batch failed for ${session.id}: ${e}`);
       if (fresh) {
         this.terminals.delete(session.id);
         session.dispose();
@@ -12277,7 +11207,7 @@ class WebTerminalManager {
   }
   /** Build the lines-mode open response from a completed capture. */
   linesResponse(id, session, restored) {
-    logger.debug(`[WEB TERMINAL] lines open ${id}: seq=${restored.seqAtAnchor} small=${restored.small.length}B full=${restored.full.length}B pages=${restored.totalPages} alt=${restored.alternateOn}`);
+    persistence.logger.debug(`[WEB TERMINAL] lines open ${id}: seq=${restored.seqAtAnchor} small=${restored.small.length}B full=${restored.full.length}B pages=${restored.totalPages} alt=${restored.alternateOn}`);
     return {
       terminalId: id,
       tmuxSession: session.tmuxSession,
@@ -12332,7 +11262,7 @@ class WebTerminalManager {
     const target = session.paneId ?? `=${session.tmuxSession}:`;
     const { commands, dropped } = encodeTerminalWrite(text, target, { normalizeKeyNames: true });
     if (dropped) {
-      logger.debug(`[WEB TERMINAL] dropped terminal auto-reply for ${terminalId}`);
+      persistence.logger.debug(`[WEB TERMINAL] dropped terminal auto-reply for ${terminalId}`);
       return;
     }
     if (commands.length === 0) return;
@@ -12393,7 +11323,7 @@ class WebTerminalManager {
       try {
         session.transport.pty.resize(c, r);
       } catch (e) {
-        logger.debug(`[WEB TERMINAL] resize ${session.id} failed: ${e}`);
+        persistence.logger.debug(`[WEB TERMINAL] resize ${session.id} failed: ${e}`);
       }
     } else if (c !== session.cols || r !== session.rows) {
       session.transport.client.sendFireAndForget([
@@ -12414,7 +11344,7 @@ class WebTerminalManager {
     if (!session) return;
     session.subscribers = Math.max(0, session.subscribers - 1);
     session.lastTouch = Date.now();
-    logger.debug(`[WEB TERMINAL] unsubscribed ${terminalId} (subs=${session.subscribers})`);
+    persistence.logger.debug(`[WEB TERMINAL] unsubscribed ${terminalId} (subs=${session.subscribers})`);
   }
   /** Detach the pty (its single tmux client) without killing the tmux session.
    *  Used by the reaper / cap eviction. Reopening the id respawns a pty and
@@ -12426,7 +11356,7 @@ class WebTerminalManager {
     this.snapshots.drop(terminalId);
     this.captureInFlight.delete(terminalId);
     session.dispose();
-    logger.debug(`[WEB TERMINAL] detached ${terminalId} (tmux session survives)`);
+    persistence.logger.debug(`[WEB TERMINAL] detached ${terminalId} (tmux session survives)`);
   }
   /** Stop every live session (test teardown / daemon shutdown). Control
    *  clients get the SIGTERM→SIGKILL discipline, so no tmux child is left
@@ -12450,20 +11380,20 @@ class WebTerminalManager {
     const killed = node_child_process.spawnSync("tmux", tmuxArgs(["kill-session", "-t", target]), { stdio: "ignore", env: ptyEnv() });
     const verified = node_child_process.spawnSync("tmux", tmuxArgs(["has-session", "-t", target]), { stdio: "ignore", env: ptyEnv() });
     if (!tmuxKillVerified(killed, verified)) {
-      logger.debug(`[WEB TERMINAL] failed to verify tmux session removal ${target}`);
+      persistence.logger.debug(`[WEB TERMINAL] failed to verify tmux session removal ${target}`);
       return false;
     }
     if (opts?.alsoAttached && info?.attachTmux) {
       const matches = this.listUserTmuxSessions(Infinity).filter((s) => s.name === info.attachTmux);
       if (matches.length === 1) {
         node_child_process.spawnSync("tmux", tmuxArgs(["kill-session", "-t", matches[0].id]), { stdio: "ignore", timeout: TMUX_PROBE_TIMEOUT_MS, env: ptyEnv() });
-        logger.info(`[WEB TERMINAL] killed attached user tmux session ${matches[0].id} (${info.attachTmux}) with ${terminalId}`);
+        persistence.logger.info(`[WEB TERMINAL] killed attached user tmux session ${matches[0].id} (${info.attachTmux}) with ${terminalId}`);
       } else {
-        logger.debug(`[WEB TERMINAL] alsoAttached: no unique session named ${info.attachTmux} (${matches.length} matches)`);
+        persistence.logger.debug(`[WEB TERMINAL] alsoAttached: no unique session named ${info.attachTmux} (${matches.length} matches)`);
       }
     }
     if (info) {
-      const mirror = pickMirrorForTerminal(readPersistedSessions(), terminalId);
+      const mirror = pickMirrorForTerminal(persistence.readPersistedSessions(), terminalId);
       this.recordClosed({
         id: terminalId,
         title: info.title,
@@ -12482,13 +11412,13 @@ class WebTerminalManager {
     try {
       this.onTerminalClosedCb?.(terminalId);
     } catch (e) {
-      logger.debug(`[WEB TERMINAL] terminal-closed callback failed: ${e}`);
+      persistence.logger.debug(`[WEB TERMINAL] terminal-closed callback failed: ${e}`);
     }
     this.detach(terminalId);
     this.tombstones[terminalId] = Date.now();
     saveTombstones(this.tombstones);
     this.notifyTracker.remove(terminalId);
-    logger.debug(`[WEB TERMINAL] killed session vh-${terminalId}`);
+    persistence.logger.debug(`[WEB TERMINAL] killed session vh-${terminalId}`);
     this.kickListRefresh();
     return true;
   }
@@ -12526,7 +11456,7 @@ class WebTerminalManager {
         { encoding: "utf8", env }
       );
       if (r.status !== 0 || !r.stdout) return [];
-      const hostname = os.hostname();
+      const hostname = os$1.hostname();
       const out = [];
       for (const line of r.stdout.split("\n")) {
         const s = parseSessionListLine(line);
@@ -12758,7 +11688,7 @@ class WebTerminalManager {
 
 const TMUX_TIMEOUT_MS = 3e3;
 const VH_LIST_SESSIONS_FORMAT = LIST_SESSIONS_FORMAT;
-function parseVhTerminals(stdout, hostname = os.hostname()) {
+function parseVhTerminals(stdout, hostname = os$1.hostname()) {
   const out = [];
   for (const line of stdout.split("\n")) {
     const s = parseSessionListLine(line);
@@ -12897,7 +11827,7 @@ function decideBackfill(messages, maxLines) {
 }
 
 function detectCLIAvailability() {
-  const isWindows = os$1.platform() === "win32";
+  const isWindows = os.platform() === "win32";
   if (isWindows) {
     return detectWindows();
   }
@@ -12922,14 +11852,14 @@ function commandExistsWindows(name) {
 const SAFE_COMMAND_NAME = /^[A-Za-z0-9._-]+$/;
 function commandOnPath(name) {
   if (!SAFE_COMMAND_NAME.test(name)) return false;
-  return os$1.platform() === "win32" ? commandExistsWindows(name) : commandExists(name);
+  return os.platform() === "win32" ? commandExistsWindows(name) : commandExists(name);
 }
 function detectPosix() {
   const claude = commandExists("claude");
   const codex = commandExists("codex");
   const gemini = commandExists("gemini");
   const openclawCommand = commandExists("openclaw");
-  const openclawConfig = fs$1.existsSync(path$1.join(os$1.homedir(), ".openclaw", "openclaw.json"));
+  const openclawConfig = fs$1.existsSync(path.join(os.homedir(), ".openclaw", "openclaw.json"));
   const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
   const openclaw = openclawCommand || openclawConfig || openclawEnv;
   const pi = commandExists("pi") && commandExists("pi-acp");
@@ -12941,7 +11871,7 @@ function detectWindows() {
   const codex = checkCommand("codex");
   const gemini = checkCommand("gemini");
   const openclawCommand = checkCommand("openclaw");
-  const openclawConfig = fs$1.existsSync(path$1.join(process.env.USERPROFILE || os$1.homedir(), ".openclaw", "openclaw.json"));
+  const openclawConfig = fs$1.existsSync(path.join(process.env.USERPROFILE || os.homedir(), ".openclaw", "openclaw.json"));
   const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
   const openclaw = openclawCommand || openclawConfig || openclawEnv;
   const pi = checkCommand("pi") && checkCommand("pi-acp");
@@ -12984,10 +11914,10 @@ function deriveContentKeyPair(secret) {
     secretKey: keyPair.secretKey
   };
 }
-function getLocalHappyAgentCredentialPath(happyHomeDir = configuration.happyHomeDir) {
-  return path.join(happyHomeDir, "agent.key");
+function getLocalHappyAgentCredentialPath(happyHomeDir = persistence.configuration.happyHomeDir) {
+  return path$1.join(happyHomeDir, "agent.key");
 }
-function readLocalHappyAgentCredentials(happyHomeDir = configuration.happyHomeDir, serverUrl = configuration.serverUrl) {
+function readLocalHappyAgentCredentials(happyHomeDir = persistence.configuration.happyHomeDir, serverUrl = persistence.configuration.serverUrl) {
   const credentialPath = getLocalHappyAgentCredentialPath(happyHomeDir);
   if (!node_fs.existsSync(credentialPath)) {
     return null;
@@ -12995,8 +11925,8 @@ function readLocalHappyAgentCredentials(happyHomeDir = configuration.happyHomeDi
   try {
     const parsed = AgentCredentialsSchema.parse(JSON.parse(node_fs.readFileSync(credentialPath, "utf8")));
     if (!parsed.authServerUrl) return null;
-    if (credentialRelayProblem(parsed.authServerUrl, serverUrl)) return null;
-    const secret = decodeBase64(parsed.secret);
+    if (persistence.credentialRelayProblem(parsed.authServerUrl, serverUrl)) return null;
+    const secret = persistence.decodeBase64(parsed.secret);
     return {
       token: parsed.token,
       authServerUrl: parsed.authServerUrl,
@@ -13007,10 +11937,10 @@ function readLocalHappyAgentCredentials(happyHomeDir = configuration.happyHomeDi
     return null;
   }
 }
-function hasLocalHappyAgentAuth(happyHomeDir = configuration.happyHomeDir) {
+function hasLocalHappyAgentAuth(happyHomeDir = persistence.configuration.happyHomeDir) {
   return readLocalHappyAgentCredentials(happyHomeDir) !== null;
 }
-function detectResumeSupport(happyHomeDir = configuration.happyHomeDir) {
+function detectResumeSupport(happyHomeDir = persistence.configuration.happyHomeDir) {
   const happyAgentAuthenticated = hasLocalHappyAgentAuth(happyHomeDir);
   return {
     rpcAvailable: happyAgentAuthenticated,
@@ -13043,7 +11973,7 @@ async function listClaudeProjectDirs(projectsRoot) {
   }
   const dirs = [];
   for (const name of names) {
-    const full = path.join(projectsRoot, name);
+    const full = path$1.join(projectsRoot, name);
     try {
       if ((await promises.stat(full)).isDirectory()) dirs.push(full);
     } catch {
@@ -13064,11 +11994,11 @@ async function collectCandidates(projectDirs, exclude) {
       if (!name.endsWith(".jsonl")) continue;
       const id = name.slice(0, -".jsonl".length);
       if (!UUID_RE$1.test(id) || exclude.has(id.toLowerCase())) continue;
-      const path$1 = path.join(dir, name);
+      const path = path$1.join(dir, name);
       try {
-        const s = await promises.stat(path$1);
+        const s = await promises.stat(path);
         if (!s.isFile() || s.size === 0) continue;
-        out.push({ path: path$1, id, updatedAt: s.mtimeMs, sizeBytes: s.size });
+        out.push({ path, id, updatedAt: s.mtimeMs, sizeBytes: s.size });
       } catch {
       }
     }
@@ -13213,7 +12143,7 @@ class ForkSourceMissingError extends Error {
   }
 }
 function jsonlPath(projectDir, sessionId) {
-  return path.join(projectDir, `${sessionId}.jsonl`);
+  return path$1.join(projectDir, `${sessionId}.jsonl`);
 }
 function isUserPrompt(parsed) {
   if (!parsed || parsed.type !== "user") return false;
@@ -13236,10 +12166,10 @@ function userPromptText(parsed) {
 async function discardForkedSession(projectDir, claudeSessionId) {
   try {
     await promises.unlink(jsonlPath(projectDir, claudeSessionId));
-    logger.debug(`[CLAUDE FORK] Discarded unused fork ${claudeSessionId}`);
+    persistence.logger.debug(`[CLAUDE FORK] Discarded unused fork ${claudeSessionId}`);
   } catch (error) {
     if (error.code !== "ENOENT") {
-      logger.debug(`[CLAUDE FORK] Failed to discard fork ${claudeSessionId}:`, error);
+      persistence.logger.debug(`[CLAUDE FORK] Failed to discard fork ${claudeSessionId}:`, error);
     }
   }
 }
@@ -13255,7 +12185,7 @@ async function forkSession(projectDir, sourceClaudeSessionId) {
     }
     throw error;
   }
-  logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}`);
+  persistence.logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}`);
   return newId;
 }
 async function forkAndTruncateSession(projectDir, sourceClaudeSessionId, cutAfterUuid) {
@@ -13277,7 +12207,7 @@ async function forkAndTruncateSession(projectDir, sourceClaudeSessionId, cutAfte
       try {
         parsed = JSON.parse(line);
       } catch {
-        logger.debug(`[CLAUDE FORK] Skipped malformed JSON line during truncation copy`);
+        persistence.logger.debug(`[CLAUDE FORK] Skipped malformed JSON line during truncation copy`);
       }
       if (foundMarker && parsed && isUserPrompt(parsed)) {
         break;
@@ -13309,7 +12239,7 @@ async function forkAndTruncateSession(projectDir, sourceClaudeSessionId, cutAfte
     throw new ForkTruncateUuidNotFoundError(cutAfterUuid, src);
   }
   await promises.rename(tempDst, finalDst);
-  logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}, cut after ${cutAfterUuid}`);
+  persistence.logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}, cut after ${cutAfterUuid}`);
   return newId;
 }
 async function listClaudeRewindPoints(projectDir, claudeSessionId) {
@@ -13446,11 +12376,11 @@ function errorLogMetadata(error) {
 }
 
 function expandPath(pathValue, sessionPath) {
-  const expandedHome = pathValue.replace(/^~(?=\/|$)/, os.homedir());
-  if (path.isAbsolute(expandedHome)) {
+  const expandedHome = pathValue.replace(/^~(?=\/|$)/, os$1.homedir());
+  if (path$1.isAbsolute(expandedHome)) {
     return expandedHome;
   }
-  return path.resolve(sessionPath, expandedHome);
+  return path$1.resolve(sessionPath, expandedHome);
 }
 function resolvePaths(paths, sessionPath) {
   return paths.map((pathValue) => expandPath(pathValue, sessionPath));
@@ -13472,10 +12402,10 @@ function buildSandboxRuntimeConfig(sandboxConfig, sessionPath) {
   const allowWrite = (() => {
     switch (sandboxConfig.sessionIsolation) {
       case "strict":
-        return uniquePaths([path.resolve(sessionPath), ...extraWritePaths, ...sharedAgentStatePaths]);
+        return uniquePaths([path$1.resolve(sessionPath), ...extraWritePaths, ...sharedAgentStatePaths]);
       case "workspace": {
-        const workspaceRoot = sandboxConfig.workspaceRoot ? expandPath(sandboxConfig.workspaceRoot, sessionPath) : path.resolve(sessionPath);
-        return uniquePaths([workspaceRoot, path.resolve(sessionPath), ...extraWritePaths, ...sharedAgentStatePaths]);
+        const workspaceRoot = sandboxConfig.workspaceRoot ? expandPath(sandboxConfig.workspaceRoot, sessionPath) : path$1.resolve(sessionPath);
+        return uniquePaths([workspaceRoot, path$1.resolve(sessionPath), ...extraWritePaths, ...sharedAgentStatePaths]);
       }
       case "custom":
         return uniquePaths([
@@ -13837,9 +12767,9 @@ class CodexAppServerClient {
         command = wrapped.command;
         args = wrapped.args;
         this.sandboxEnabled = true;
-        logger.info(`[CodexAppServer] Sandbox enabled`);
+        persistence.logger.info(`[CodexAppServer] Sandbox enabled`);
       } catch (error) {
-        logger.warn("[CodexAppServer] Failed to initialize sandbox; continuing without.", error);
+        persistence.logger.warn("[CodexAppServer] Failed to initialize sandbox; continuing without.", error);
         this.sandboxCleanup = null;
       }
     }
@@ -13856,7 +12786,7 @@ class CodexAppServerClient {
     if (this.sandboxEnabled) {
       env.CODEX_SANDBOX = "seatbelt";
     }
-    logger.debug(`[CodexAppServer] Spawning: ${command} ${args.join(" ")}`);
+    persistence.logger.debug(`[CodexAppServer] Spawning: ${command} ${args.join(" ")}`);
     const epoch = ++this.processEpoch;
     const proc = spawn.spawn(command, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -13865,12 +12795,12 @@ class CodexAppServerClient {
     });
     this.process = proc;
     proc.on("error", (err) => {
-      logger.debug("[CodexAppServer] Process error:", err);
+      persistence.logger.debug("[CodexAppServer] Process error:", err);
     });
     proc.on("exit", (code, signal) => {
-      logger.debug(`[CodexAppServer] Process exited: code=${code} signal=${signal}`);
+      persistence.logger.debug(`[CodexAppServer] Process exited: code=${code} signal=${signal}`);
       if (this.process !== proc || this.processEpoch !== epoch) {
-        logger.debug("[CodexAppServer] Ignoring stale process exit");
+        persistence.logger.debug("[CodexAppServer] Ignoring stale process exit");
         return;
       }
       this.connected = false;
@@ -13884,7 +12814,7 @@ class CodexAppServerClient {
     proc.stderr?.on("data", (chunk) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       const text = chunk.toString().trim();
-      if (text) logger.debug("[CodexAppServer:stderr]", contentLogMetadata(text));
+      if (text) persistence.logger.debug("[CodexAppServer:stderr]", contentLogMetadata(text));
     });
     this.readline = node_readline.createInterface({ input: proc.stdout });
     this.readline.on("line", (line) => {
@@ -13895,7 +12825,7 @@ class CodexAppServerClient {
       clientInfo: {
         name: "happy-codex",
         title: "Happy Codex Client",
-        version: packageJson.version
+        version: persistence.packageJson.version
       },
       capabilities: {
         experimentalApi: true
@@ -13904,14 +12834,14 @@ class CodexAppServerClient {
     await this.request("initialize", initParams);
     this.notify("initialized");
     this.connected = true;
-    logger.debug("[CodexAppServer] Connected and initialized");
+    persistence.logger.debug("[CodexAppServer] Connected and initialized");
   }
   async disconnectInternal(opts) {
     if (!this.connected && !this.process) return;
     const proc = this.process;
     const pid = proc?.pid;
     const epoch = this.processEpoch;
-    logger.debug(`[CodexAppServer] Disconnecting; pid=${pid ?? "none"}`);
+    persistence.logger.debug(`[CodexAppServer] Disconnecting; pid=${pid ?? "none"}`);
     this.readline?.close();
     this.readline = null;
     try {
@@ -13952,7 +12882,7 @@ class CodexAppServerClient {
       this.sandboxCleanup = null;
     }
     this.sandboxEnabled = false;
-    logger.debug("[CodexAppServer] Disconnected");
+    persistence.logger.debug("[CodexAppServer] Disconnected");
   }
   async disconnect() {
     await this.disconnectInternal();
@@ -13990,7 +12920,7 @@ class CodexAppServerClient {
     this._threadId = result.thread.id;
     this._turnId = null;
     this.rememberThreadDefaults(opts);
-    logger.debug("[CodexAppServer] Thread started:", this._threadId);
+    persistence.logger.debug("[CodexAppServer] Thread started:", this._threadId);
     return { threadId: result.thread.id, model: result.model };
   }
   async resumeThread(opts) {
@@ -14021,7 +12951,7 @@ class CodexAppServerClient {
       sandbox: opts?.sandbox ?? defaults.sandbox,
       mcpServers: opts?.mcpServers ?? defaults.mcpServers
     });
-    logger.debug("[CodexAppServer] Thread resumed:", this._threadId);
+    persistence.logger.debug("[CodexAppServer] Thread resumed:", this._threadId);
     return { threadId: result.thread.id, model: result.model };
   }
   async forkThread(opts) {
@@ -14049,7 +12979,7 @@ class CodexAppServerClient {
       sandbox: opts.sandbox ?? defaults.sandbox,
       mcpServers: opts.mcpServers ?? defaults.mcpServers
     });
-    logger.debug("[CodexAppServer] Thread forked:", opts.threadId, "->", this._threadId);
+    persistence.logger.debug("[CodexAppServer] Thread forked:", opts.threadId, "->", this._threadId);
     return { threadId: result.thread.id, model: result.model, thread: result.thread };
   }
   async readThread(opts) {
@@ -14084,7 +13014,7 @@ class CodexAppServerClient {
       await this.resumeThread({ threadId });
       return true;
     } catch (error) {
-      logger.warn("[CodexAppServer] Failed to resume thread after reconnect", error);
+      persistence.logger.warn("[CodexAppServer] Failed to resume thread after reconnect", error);
       this._threadId = null;
       this.threadDefaults = null;
       return false;
@@ -14111,7 +13041,7 @@ class CodexAppServerClient {
     const pending = this.pendingTurnCompletion;
     if (!pending) return;
     if (pending.turnId && turnId && pending.turnId !== turnId) {
-      logger.debug(
+      persistence.logger.debug(
         `[CodexAppServer] Ignoring ${source} for turn ${turnId}; awaiting ${pending.turnId}`
       );
       return;
@@ -14150,7 +13080,7 @@ class CodexAppServerClient {
     if (!shouldForceRestart) {
       return { hadActiveTurn: true, aborted: false, forcedRestart: false, resumedThread: false };
     }
-    logger.warn(`[CodexAppServer] interrupt did not settle turn in ${gracePeriodMs}ms; force-restarting app-server`);
+    persistence.logger.warn(`[CodexAppServer] interrupt did not settle turn in ${gracePeriodMs}ms; force-restarting app-server`);
     const pendingTurnId = this.pendingTurnCompletion?.turnId ?? this._turnId;
     if (this.pendingTurnCompletion) {
       this.eventHandler?.({
@@ -14224,7 +13154,7 @@ class CodexAppServerClient {
       };
       timer = setTimeout(() => {
         if (this.pendingTurnCompletion) {
-          logger.warn(`[CodexAppServer] Turn timed out after ${timeoutMs}ms \u2014 treating as abort`);
+          persistence.logger.warn(`[CodexAppServer] Turn timed out after ${timeoutMs}ms \u2014 treating as abort`);
           this.resolvePendingTurn(true);
         }
       }, timeoutMs);
@@ -14243,7 +13173,7 @@ class CodexAppServerClient {
   async interruptTurn() {
     if (!this._threadId) return;
     if (!this._turnId) {
-      logger.debug("[CodexAppServer] interruptTurn: no active turnId, skipping");
+      persistence.logger.debug("[CodexAppServer] interruptTurn: no active turnId, skipping");
       return;
     }
     const params = {
@@ -14254,7 +13184,7 @@ class CodexAppServerClient {
       try {
         await this.request("turn/interrupt", params);
       } catch (err) {
-        logger.debug("[CodexAppServer] interruptTurn error (may be expected):", err);
+        persistence.logger.debug("[CodexAppServer] interruptTurn error (may be expected):", err);
       } finally {
         this.pendingInterrupt = null;
       }
@@ -14267,7 +13197,7 @@ class CodexAppServerClient {
     return this._threadId !== null;
   }
   clearThreadState() {
-    logger.debug(
+    persistence.logger.debug(
       `[CodexAppServer] Clearing thread state: thread=${this._threadId ?? "none"} turn=${this._turnId ?? "none"}`
     );
     this.resolvePendingTurn(true);
@@ -14306,7 +13236,7 @@ class CodexAppServerClient {
       });
       const msg = { jsonrpc: "2.0", id, method, params };
       const line = JSON.stringify(msg) + "\n";
-      logger.debug(`[CodexAppServer] \u2192 ${method} (id=${id})`);
+      persistence.logger.debug(`[CodexAppServer] \u2192 ${method} (id=${id})`);
       this.process.stdin.write(line);
     });
   }
@@ -14314,13 +13244,13 @@ class CodexAppServerClient {
     if (!this.process?.stdin?.writable) return;
     const msg = { jsonrpc: "2.0", method, params };
     this.process.stdin.write(JSON.stringify(msg) + "\n");
-    logger.debug(`[CodexAppServer] \u2192 ${method} (notification)`);
+    persistence.logger.debug(`[CodexAppServer] \u2192 ${method} (notification)`);
   }
   respond(id, result) {
     if (!this.process?.stdin?.writable) return;
     const msg = { jsonrpc: "2.0", id, result };
     this.process.stdin.write(JSON.stringify(msg) + "\n");
-    logger.debug(`[CodexAppServer] \u2192 response (id=${id})`);
+    persistence.logger.debug(`[CodexAppServer] \u2192 response (id=${id})`);
   }
   handleLine(line, sourceEpoch = this.processEpoch) {
     if (sourceEpoch !== this.processEpoch) {
@@ -14331,14 +13261,14 @@ class CodexAppServerClient {
     try {
       msg = JSON.parse(line);
     } catch {
-      logger.debug("[CodexAppServer] Non-JSON line received:", contentLogMetadata(line));
+      persistence.logger.debug("[CodexAppServer] Non-JSON line received:", contentLogMetadata(line));
       return;
     }
     if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
       if (pending) {
         if (pending.epoch !== sourceEpoch) {
-          logger.debug(`[CodexAppServer] Ignoring response from stale epoch for id=${msg.id}`);
+          persistence.logger.debug(`[CodexAppServer] Ignoring response from stale epoch for id=${msg.id}`);
           return;
         }
         this.pending.delete(msg.id);
@@ -14352,7 +13282,7 @@ class CodexAppServerClient {
     }
     if (msg.id != null && msg.method) {
       this.handleServerRequest(msg.id, msg.method, msg.params).catch((err) => {
-        logger.debug("[CodexAppServer] Error handling server request:", errorLogMetadata(err));
+        persistence.logger.debug("[CodexAppServer] Error handling server request:", errorLogMetadata(err));
       });
       return;
     }
@@ -14360,7 +13290,7 @@ class CodexAppServerClient {
       this.handleNotification(msg.method, msg.params);
       return;
     }
-    logger.debug("[CodexAppServer] Unhandled message:", contentLogMetadata(msg));
+    persistence.logger.debug("[CodexAppServer] Unhandled message:", contentLogMetadata(msg));
   }
   /**
    * Map our internal ReviewDecision to the wire format the server expects.
@@ -14472,7 +13402,7 @@ class CodexAppServerClient {
       this.respond(id, { decision: this.mapDecisionToWire(decision, legacy) });
       return;
     }
-    logger.debug(`[CodexAppServer] Unknown server request: ${method}`);
+    persistence.logger.debug(`[CodexAppServer] Unknown server request: ${method}`);
     this.respond(id, {});
   }
   async handleApproval(params) {
@@ -14480,7 +13410,7 @@ class CodexAppServerClient {
       try {
         return await this.approvalHandler(params);
       } catch (err) {
-        logger.debug("[CodexAppServer] Approval handler error:", err);
+        persistence.logger.debug("[CodexAppServer] Approval handler error:", err);
         return "denied";
       }
     }
@@ -14514,11 +13444,11 @@ class CodexAppServerClient {
       return;
     }
     if (this.handleRawNotification(method, params)) {
-      logger.debug(`[CodexAppServer] Raw notification: ${method}`);
+      persistence.logger.debug(`[CodexAppServer] Raw notification: ${method}`);
       return;
     }
     if (method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed") {
-      logger.debug(`[CodexAppServer] Lifecycle notification: ${method}`);
+      persistence.logger.debug(`[CodexAppServer] Lifecycle notification: ${method}`);
       if (method === "turn/started") {
         const turnId = this.extractTurnId(params);
         if (turnId) {
@@ -14537,10 +13467,10 @@ class CodexAppServerClient {
       return;
     }
     if (method === "mcpServer/startupStatus/updated") {
-      logger.debug(`[CodexAppServer] mcpServer startup status:`, params);
+      persistence.logger.debug(`[CodexAppServer] mcpServer startup status:`, params);
       return;
     }
-    logger.debug(`[CodexAppServer] Notification: ${method}`);
+    persistence.logger.debug(`[CodexAppServer] Notification: ${method}`);
   }
 }
 
@@ -14819,7 +13749,7 @@ class ApiMachineClient {
       scopePrefix: this.machine.id,
       encryptionKey: this.machine.encryptionKey,
       encryptionVariant: this.machine.encryptionVariant,
-      logger: (msg, data) => logger.debug(msg, data)
+      logger: (msg, data) => persistence.logger.debug(msg, data)
     });
     registerCommonHandlers(this.rpcHandlerManager, process.cwd());
     registerFsHandlers(this.rpcHandlerManager);
@@ -14877,7 +13807,7 @@ class ApiMachineClient {
     if (this.relaySocket?.connected) this.relaySocket.emit(event, out);
   }, (n) => {
     sendTerminalNotification({
-      baseUrl: configuration.serverUrl,
+      baseUrl: persistence.configuration.serverUrl,
       token: this.token,
       title: n.title,
       message: terminalNotifyMessage(n.event),
@@ -14907,12 +13837,12 @@ class ApiMachineClient {
    * Encrypted with the per-machine key; the server relays without reading.
    */
   pushClipboard(text) {
-    const prepared = limits.prepareClipboardText(text);
+    const prepared = persistence.prepareClipboardText(text);
     if (!this.socket?.connected) {
       return { delivered: false, truncated: prepared.truncated, totalBytes: prepared.totalBytes, error: "daemon is not connected to the server" };
     }
     this.socket.emit("clipboard-push", {
-      payload: encodeBase64(encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, prepared.text)),
+      payload: persistence.encodeBase64(persistence.encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, prepared.text)),
       enc: true,
       truncated: prepared.truncated,
       totalBytes: prepared.totalBytes
@@ -14923,7 +13853,7 @@ class ApiMachineClient {
    *  as the live output stream) → base64 ciphertext. Used for both live output
    *  and the open-terminal snapshot/replay payloads. */
   encTerminalData(dataBase64) {
-    return encodeBase64(encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, dataBase64));
+    return persistence.encodeBase64(persistence.encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, dataBase64));
   }
   setCliUpdateRetryHandler(handler) {
     this.rpcHandlerManager.registerHandler("cli-update-retry", (params) => handler(params && typeof params === "object" ? params.version : void 0));
@@ -14933,7 +13863,7 @@ class ApiMachineClient {
   setCliUpdateState(state) {
     this.cliUpdateState = state;
     if (!this.socket?.connected) return;
-    this.cliUpdatePushChain = this.cliUpdatePushChain.then(() => this.updateDaemonState((current) => withCurrentCliUpdateState(current, this.cliUpdateState))).catch((error) => logger.debug("[API MACHINE] Failed to publish CLI update policy:", error));
+    this.cliUpdatePushChain = this.cliUpdatePushChain.then(() => this.updateDaemonState((current) => withCurrentCliUpdateState(current, this.cliUpdateState))).catch((error) => persistence.logger.debug("[API MACHINE] Failed to publish CLI update policy:", error));
   }
   /**
    * B-276: publish the daemon-context Claude auth preflight into daemonState
@@ -14950,7 +13880,7 @@ class ApiMachineClient {
       status: current?.status ?? "running",
       claudeAuth: state
     }))).then(() => this.machine.daemonState?.claudeAuth?.checkedAt === state.checkedAt && this.machine.daemonState?.claudeAuth?.daemonPid === state.daemonPid).catch((error) => {
-      logger.debug("[API MACHINE] Failed to publish Claude auth state:", error);
+      persistence.logger.debug("[API MACHINE] Failed to publish Claude auth state:", error);
       return false;
     });
     this.cliUpdatePushChain = attempt.then(() => void 0);
@@ -14987,17 +13917,17 @@ class ApiMachineClient {
     this.listTrackedSessionIds = listTrackedSessionIds ?? null;
     this.rpcHandlerManager.registerHandler("spawn-happy-session", async (params) => {
       const { directory, sessionId, machineId, approvedNewDirectoryCreation, agent, environmentVariables, token, resumeClaudeSessionId, resumeCodexThreadId, parentSessionId, forkedFromMessageId, importedFromClaudeSessionId, variant, forceNew, permissionMode } = params || {};
-      logger.debug("[API MACHINE] Spawning session:", summarizeSpawnSessionForLog(params));
+      persistence.logger.debug("[API MACHINE] Spawning session:", summarizeSpawnSessionForLog(params));
       if (!directory && variant !== "assistant") {
         throw new Error("Directory is required");
       }
       const result = await spawnSession({ directory: directory || "", sessionId, machineId, approvedNewDirectoryCreation, agent, environmentVariables, token, resumeClaudeSessionId, resumeCodexThreadId, parentSessionId, forkedFromMessageId, importedFromClaudeSessionId: typeof importedFromClaudeSessionId === "string" ? importedFromClaudeSessionId : void 0, variant: variant === "assistant" ? "assistant" : void 0, forceNew: forceNew === true, permissionMode: typeof permissionMode === "string" ? permissionMode : void 0 });
       switch (result.type) {
         case "success":
-          logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
+          persistence.logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
           return { type: "success", sessionId: result.sessionId };
         case "requestToApproveDirectoryCreation":
-          logger.debug(`[API MACHINE] Requesting directory creation approval for: ${result.directory}`);
+          persistence.logger.debug(`[API MACHINE] Requesting directory creation approval for: ${result.directory}`);
           return { type: "requestToApproveDirectoryCreation", directory: result.directory };
         case "error":
           throw new Error(result.errorMessage);
@@ -15045,7 +13975,7 @@ class ApiMachineClient {
         await discardForkedSession(projectDir, newClaudeSessionId);
         return result;
       }
-      logger.debug(`[API MACHINE] Imported Claude conversation ${claudeSessionId} as session ${result.sessionId}`);
+      persistence.logger.debug(`[API MACHINE] Imported Claude conversation ${claudeSessionId} as session ${result.sessionId}`);
       return { type: "success", sessionId: result.sessionId, newClaudeSessionId };
     });
     this.syncResumeSessionRpcRegistration();
@@ -15170,7 +14100,7 @@ class ApiMachineClient {
       if (!success) {
         throw new Error("Session not found or failed to stop");
       }
-      logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
+      persistence.logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
       return { message: "Session stopped" };
     });
     this.rpcHandlerManager.registerHandler("claude-fork-session", async (params) => {
@@ -15247,7 +14177,7 @@ class ApiMachineClient {
       const projectDirs = typeof directory === "string" ? [getProjectPath(directory)] : await listClaudeProjectDirs(getClaudeProjectsRoot());
       const excludeIds = [
         ...Array.isArray(exclude) ? exclude.filter((id) => typeof id === "string" && UUID_RE.test(id)) : [],
-        ...readTrackedClaudeSessionIds()
+        ...persistence.readTrackedClaudeSessionIds()
       ];
       const result = await listClaudeSessionHistory({
         projectDirs,
@@ -15318,9 +14248,9 @@ class ApiMachineClient {
       }));
     });
     this.rpcHandlerManager.registerHandler("stop-daemon", () => {
-      logger.debug("[API MACHINE] Received stop-daemon RPC request");
+      persistence.logger.debug("[API MACHINE] Received stop-daemon RPC request");
       setTimeout(() => {
-        logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
+        persistence.logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
         requestShutdown();
       }, 100);
       return { message: "Daemon stop request acknowledged, starting shutdown sequence..." };
@@ -15403,7 +14333,7 @@ class ApiMachineClient {
   wireAutoRestoreReport() {
     this.webTerminal.setOnAutoRestoreSummary((line) => {
       sendTerminalNotification({
-        baseUrl: configuration.serverUrl,
+        baseUrl: persistence.configuration.serverUrl,
         token: this.token,
         title: "Terminals restored",
         message: line,
@@ -15439,7 +14369,7 @@ class ApiMachineClient {
     try {
       this.mirrorListObserver?.(terminals);
     } catch (err) {
-      logger.debug("[API MACHINE] mirror list observer failed:", err);
+      persistence.logger.debug("[API MACHINE] mirror list observer failed:", err);
     }
     this.latestTerminalList = terminals;
     if (!this.socket?.connected) return;
@@ -15458,9 +14388,9 @@ class ApiMachineClient {
         // Read at write time — same freshness rule as the list.
         closedTerminals: this.webTerminal.getClosedTerminals()
       }));
-      logger.debug(`[API MACHINE] Pushed terminal list (${list.length} terminals)`);
+      persistence.logger.debug(`[API MACHINE] Pushed terminal list (${list.length} terminals)`);
     }).catch((err) => {
-      logger.debug("[API MACHINE] Terminal list push failed:", err);
+      persistence.logger.debug("[API MACHINE] Terminal list push failed:", err);
     });
   }
   /**
@@ -15474,18 +14404,18 @@ class ApiMachineClient {
       const updated = handler(this.machine.metadata);
       const answer = await this.socket.emitWithAck("machine-update-metadata", {
         machineId: this.machine.id,
-        metadata: encodeBase64(encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, updated)),
+        metadata: persistence.encodeBase64(persistence.encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, updated)),
         expectedVersion: this.machine.metadataVersion
       });
       if (answer.result === "success") {
-        this.machine.metadata = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(answer.metadata));
+        this.machine.metadata = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(answer.metadata));
         this.machine.metadataVersion = answer.version;
         rateRefusals = 0;
-        logger.debug("[API MACHINE] Metadata updated successfully");
+        persistence.logger.debug("[API MACHINE] Metadata updated successfully");
       } else if (answer.result === "version-mismatch") {
         if (answer.version > this.machine.metadataVersion) {
           this.machine.metadataVersion = answer.version;
-          this.machine.metadata = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(answer.metadata));
+          this.machine.metadata = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(answer.metadata));
         }
         throw new Error("Metadata version mismatch");
       } else if (answer.result === "error") {
@@ -15496,7 +14426,7 @@ class ApiMachineClient {
             code: answer.error,
             attempt: rateRefusals,
             sleep: delay,
-            log: (message) => logger.debug(message)
+            log: (message) => persistence.logger.debug(message)
           });
         }
         throw new Error("Machine metadata update failed");
@@ -15513,18 +14443,18 @@ class ApiMachineClient {
       const updated = handler(this.machine.daemonState);
       const answer = await this.socket.emitWithAck("machine-update-state", {
         machineId: this.machine.id,
-        daemonState: encodeBase64(encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, updated)),
+        daemonState: persistence.encodeBase64(persistence.encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, updated)),
         expectedVersion: this.machine.daemonStateVersion
       });
       if (answer.result === "success") {
-        this.machine.daemonState = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(answer.daemonState));
+        this.machine.daemonState = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(answer.daemonState));
         this.machine.daemonStateVersion = answer.version;
         rateRefusals = 0;
-        logger.debug("[API MACHINE] Daemon state updated successfully");
+        persistence.logger.debug("[API MACHINE] Daemon state updated successfully");
       } else if (answer.result === "version-mismatch") {
         if (answer.version > this.machine.daemonStateVersion) {
           this.machine.daemonStateVersion = answer.version;
-          this.machine.daemonState = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(answer.daemonState));
+          this.machine.daemonState = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(answer.daemonState));
         }
         throw new Error("Daemon state version mismatch");
       } else if (answer.result === "error") {
@@ -15535,7 +14465,7 @@ class ApiMachineClient {
             code: answer.error,
             attempt: rateRefusals,
             sleep: delay,
-            log: (message) => logger.debug(message)
+            log: (message) => persistence.logger.debug(message)
           });
         }
         throw new Error("Daemon state update failed");
@@ -15543,8 +14473,8 @@ class ApiMachineClient {
     });
   }
   connect() {
-    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
-    logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
+    const serverUrl = persistence.configuration.serverUrl.replace(/^http/, "ws");
+    persistence.logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
     this.socket = this.createControlSocket();
     const controlSocket = this.socket;
     this.bindRealtimeHandlers(controlSocket, "control");
@@ -15553,7 +14483,7 @@ class ApiMachineClient {
       this.activateControlSocket(controlSocket);
     });
     controlSocket.on("disconnect", (reason) => {
-      logger.debug(`[API MACHINE] Disconnected from server \u2014 reason: ${reason}`);
+      persistence.logger.debug(`[API MACHINE] Disconnected from server \u2014 reason: ${reason}`);
       this.rpcHandlerManager.onSocketDisconnect(controlSocket);
       if (!this.relaySocket?.connected) this.webTerminal.resetSubscribers();
       this.stopKeepAlive();
@@ -15562,14 +14492,14 @@ class ApiMachineClient {
     this.bindControlDataHandlers(controlSocket);
   }
   createControlSocket(handover) {
-    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
+    const serverUrl = persistence.configuration.serverUrl.replace(/^http/, "ws");
     return socket_ioClient.io(serverUrl, {
       transports: ["websocket"],
       auth: {
         token: this.token,
         clientType: "machine-scoped",
         machineId: this.machine.id,
-        happyClient: `cli-daemon/${configuration.currentCliVersion}`,
+        happyClient: `cli-daemon/${persistence.configuration.currentCliVersion}`,
         ...handover ? { handoverEpoch: handover.epoch } : {}
       },
       ...handover ? { query: { vh_slot: handover.candidateSlot }, forceNew: true } : {},
@@ -15579,7 +14509,7 @@ class ApiMachineClient {
     });
   }
   activateControlSocket(socket, rpcAlreadyRegistered = false) {
-    logger.debug("[API MACHINE] Connected to server");
+    persistence.logger.debug("[API MACHINE] Connected to server");
     if (this.reconnectInterval) {
       clearInterval(this.reconnectInterval);
       this.reconnectInterval = null;
@@ -15625,25 +14555,25 @@ class ApiMachineClient {
       if (data.body.t === "update-machine" && data.body.machineId === this.machine.id) {
         const update = data.body;
         if (update.metadata) {
-          logger.debug("[API MACHINE] Received external metadata update");
-          this.machine.metadata = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(update.metadata.value));
+          persistence.logger.debug("[API MACHINE] Received external metadata update");
+          this.machine.metadata = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(update.metadata.value));
           this.machine.metadataVersion = update.metadata.version;
         }
         if (update.daemonState) {
-          logger.debug("[API MACHINE] Received external daemon state update");
-          this.machine.daemonState = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(update.daemonState.value));
+          persistence.logger.debug("[API MACHINE] Received external daemon state update");
+          this.machine.daemonState = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(update.daemonState.value));
           this.machine.daemonStateVersion = update.daemonState.version;
         }
       } else {
-        logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
+        persistence.logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
       }
     });
     socket.on("connect_error", (error) => {
-      logger.debug(`[API MACHINE] Connection error: ${error.message}`);
+      persistence.logger.debug(`[API MACHINE] Connection error: ${error.message}`);
       if (this.socket === socket) this.startSmartReconnect();
     });
     socket.io.on("error", (error) => {
-      logger.debug("[API MACHINE] Socket error:", error);
+      persistence.logger.debug("[API MACHINE] Socket error:", error);
     });
     socket.on("server-draining", (data) => {
       if (this.socket !== socket) return;
@@ -15713,7 +14643,7 @@ class ApiMachineClient {
       this.rpcHandlerManager.onSocketDisconnect(candidate);
       candidate.close();
       if (previous.connected) previous.emit("release-handover-result", { result: "failed", durationMs: Date.now() - startedAt });
-      logger.debug(`[API MACHINE] Release handover failed: ${error instanceof Error ? error.message : error}`);
+      persistence.logger.debug(`[API MACHINE] Release handover failed: ${error instanceof Error ? error.message : error}`);
     }
   }
   startKeepAlive() {
@@ -15724,7 +14654,7 @@ class ApiMachineClient {
         time: Date.now()
       };
       if (process.env.DEBUG) {
-        logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
+        persistence.logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
       }
       this.socket.emit("machine-alive", payload);
       void this.refreshRelayConnection();
@@ -15746,15 +14676,15 @@ class ApiMachineClient {
           cliAvailability: newAvailability,
           resumeSupport: { ...newResumeSupport, rpcAvailable: !!this.resumeSessionHandler }
         })).catch((err) => {
-          logger.debug("[API MACHINE] Failed to update machine capabilities:", err);
+          persistence.logger.debug("[API MACHINE] Failed to update machine capabilities:", err);
         });
       }
     }, 2e4);
-    logger.debug("[API MACHINE] Keep-alive started (20s interval)");
+    persistence.logger.debug("[API MACHINE] Keep-alive started (20s interval)");
   }
   bindRpcRequestHandler(socket, transport) {
     socket.on("rpc-request", async (data, callback) => {
-      logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
+      persistence.logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
       callback(await this.rpcHandlerManager.handleRequest(data));
     });
   }
@@ -15762,7 +14692,7 @@ class ApiMachineClient {
     socket.on("terminal-input", (data) => {
       let payload = data.data;
       if (data.enc) {
-        const dec = decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, decodeBase64(data.data));
+        const dec = persistence.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, persistence.decodeBase64(data.data));
         if (typeof dec !== "string") return;
         payload = dec;
       }
@@ -15773,7 +14703,7 @@ class ApiMachineClient {
     socket.on("session-archive", (data) => {
       if (typeof data?.sessionId !== "string") return;
       const stopped = this.stopSessionHandler?.(data.sessionId) ?? false;
-      logger.debug(`[API MACHINE] Server archived session ${data.sessionId}; local process stopped=${stopped}`);
+      persistence.logger.debug(`[API MACHINE] Server archived session ${data.sessionId}; local process stopped=${stopped}`);
     });
   }
   unbindMachineCommandHandlers(socket) {
@@ -15793,12 +14723,12 @@ class ApiMachineClient {
     if (tracked.length === 0) return;
     try {
       for (let offset = 0; offset < tracked.length; offset += 500) {
-        const response = await fetch(`${configuration.serverUrl}/v1/sessions/archive-status`, {
+        const response = await fetch(`${persistence.configuration.serverUrl}/v1/sessions/archive-status`, {
           method: "POST",
           headers: {
             "Authorization": `Bearer ${this.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-daemon/${persistence.configuration.currentCliVersion}`
           },
           body: JSON.stringify({ sessionIds: tracked.slice(offset, offset + 500) })
         });
@@ -15811,14 +14741,14 @@ class ApiMachineClient {
         }
       }
     } catch (error) {
-      logger.debug(`[API MACHINE] Archived-session reconciliation failed: ${error instanceof Error ? error.message : error}`);
+      persistence.logger.debug(`[API MACHINE] Archived-session reconciliation failed: ${error instanceof Error ? error.message : error}`);
     }
   }
   async refreshRelayConnection() {
     if (this.relayRefreshInFlight) return this.relayRefreshInFlight;
     this.relayRefreshInFlight = (async () => {
       const selected = await discoverAndClaimRelay({
-        controlUrl: configuration.serverUrl,
+        controlUrl: persistence.configuration.serverUrl,
         token: this.token,
         machineId: this.machine.id,
         connectedRelayId: this.relaySocket?.connected ? this.relayAssignment?.relayId : void 0,
@@ -15832,7 +14762,7 @@ class ApiMachineClient {
       const previousUrl = this.relayAssignment?.url;
       this.relayAssignment = selected.assignment;
       const probe = selected.probes.find((item) => item.relayId === selected.assignment.relayId);
-      logger.debug(`[API MACHINE] Regional relay selected: ${selected.assignment.relayId} (${selected.assignment.region}), RTT ${probe ? Math.round(probe.rttMs) : "unknown"}ms`);
+      persistence.logger.debug(`[API MACHINE] Regional relay selected: ${selected.assignment.relayId} (${selected.assignment.region}), RTT ${probe ? Math.round(probe.rttMs) : "unknown"}ms`);
       if (this.relaySocket && previousUrl === selected.assignment.url) {
         this.relaySocket.auth = { token: selected.assignment.token };
         if (this.relaySocket.connected) return;
@@ -15856,7 +14786,7 @@ class ApiMachineClient {
         this.rpcHandlerManager.onSocketConnect(relaySocket);
         this.syncResumeSessionRpcRegistration();
         this.syncRestartSessionRpcRegistration();
-        logger.debug(`[API MACHINE] Connected to regional relay ${selected.assignment.relayId}`);
+        persistence.logger.debug(`[API MACHINE] Connected to regional relay ${selected.assignment.relayId}`);
       });
       relaySocket.on("disconnect", () => {
         this.relaySwitchTracker = null;
@@ -15877,14 +14807,14 @@ class ApiMachineClient {
         return;
       }
       if (!shouldReconnect()) {
-        logger.debug("[API MACHINE] Still not ready to reconnect");
+        persistence.logger.debug("[API MACHINE] Still not ready to reconnect");
         return;
       }
-      logger.debug("[API MACHINE] Attempting reconnect");
+      persistence.logger.debug("[API MACHINE] Attempting reconnect");
       this.socket.connect();
     }, 3e3);
     if (shouldReconnect()) {
-      logger.debug("[API MACHINE] Network up + lid open \u2014 reconnecting in 1s");
+      persistence.logger.debug("[API MACHINE] Network up + lid open \u2014 reconnecting in 1s");
       setTimeout(() => {
         if (!this.socket.connected) this.socket.connect();
       }, 1e3);
@@ -15894,11 +14824,11 @@ class ApiMachineClient {
     if (this.keepAliveInterval) {
       clearInterval(this.keepAliveInterval);
       this.keepAliveInterval = null;
-      logger.debug("[API MACHINE] Keep-alive stopped");
+      persistence.logger.debug("[API MACHINE] Keep-alive stopped");
     }
   }
   shutdown() {
-    logger.debug("[API MACHINE] Shutting down");
+    persistence.logger.debug("[API MACHINE] Shutting down");
     this.webTerminal.stopListTracking();
     this.stopKeepAlive();
     if (this.reconnectInterval) {
@@ -15907,13 +14837,13 @@ class ApiMachineClient {
     }
     if (this.socket) {
       this.socket.close();
-      logger.debug("[API MACHINE] Socket closed");
+      persistence.logger.debug("[API MACHINE] Socket closed");
     }
     if (this.relaySocket) {
       this.rpcHandlerManager.onSocketDisconnect(this.relaySocket);
       this.relaySocket.close();
       this.relaySocket = null;
-      logger.debug("[API MACHINE] Regional relay socket closed");
+      persistence.logger.debug("[API MACHINE] Regional relay socket closed");
     }
   }
 }
@@ -15983,24 +14913,24 @@ class PushNotificationClient {
             headers: {
               "Authorization": `Bearer ${this.token}`,
               "Content-Type": "application/json",
-              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+              "X-Happy-Client": `cli-daemon/${persistence.configuration.currentCliVersion}`
             }
           }
         );
-        logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+        persistence.logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
         response.data.tokens.forEach((token, index) => {
-          logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+          persistence.logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
         });
         return response.data.tokens;
       } catch (error) {
-        logger.debug(`[PUSH] [ERROR] Failed to fetch push tokens (attempt ${attempt}/${maxAttempts}):`, error);
+        persistence.logger.debug(`[PUSH] [ERROR] Failed to fetch push tokens (attempt ${attempt}/${maxAttempts}):`, error);
         if (attempt < maxAttempts) {
           const delay = 1e3 * Math.pow(2, attempt - 1);
           await new Promise((resolve) => setTimeout(resolve, delay));
         }
       }
     }
-    logger.debug("[PUSH] [ERROR] All push token fetch attempts failed");
+    persistence.logger.debug("[PUSH] [ERROR] All push token fetch attempts failed");
     return [];
   }
   /**
@@ -16008,7 +14938,7 @@ class PushNotificationClient {
    * @param messages - Array of push messages to send
    */
   async sendPushNotifications(messages) {
-    logger.debug(`Sending ${messages.length} push notifications`);
+    persistence.logger.debug(`Sending ${messages.length} push notifications`);
     const validMessages = messages.filter((message) => {
       if (Array.isArray(message.to)) {
         return message.to.every((token) => expoServerSdk.Expo.isExpoPushToken(token));
@@ -16016,7 +14946,7 @@ class PushNotificationClient {
       return expoServerSdk.Expo.isExpoPushToken(message.to);
     });
     if (validMessages.length === 0) {
-      logger.debug("No valid Expo push tokens found");
+      persistence.logger.debug("No valid Expo push tokens found");
       return;
     }
     const chunks = this.expo.chunkPushNotifications(validMessages);
@@ -16030,7 +14960,7 @@ class PushNotificationClient {
           const errors = ticketChunk.filter((ticket) => ticket.status === "error");
           if (errors.length > 0) {
             const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
-            logger.debug("[PUSH] Some notifications failed:", errorDetails);
+            persistence.logger.debug("[PUSH] Some notifications failed:", errorDetails);
           }
           if (errors.length === ticketChunk.length) {
             throw new Error("All push notifications in chunk failed");
@@ -16039,7 +14969,7 @@ class PushNotificationClient {
         } catch (error) {
           const elapsed = Date.now() - startTime;
           if (elapsed >= timeout) {
-            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            persistence.logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
             break;
           }
           attempt++;
@@ -16047,13 +14977,13 @@ class PushNotificationClient {
           const remainingTime = timeout - elapsed;
           const waitTime = Math.min(delay, remainingTime);
           if (waitTime > 0) {
-            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            persistence.logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
             await new Promise((resolve) => setTimeout(resolve, waitTime));
           }
         }
       }
     }
-    logger.debug(`Push notifications sent successfully`);
+    persistence.logger.debug(`Push notifications sent successfully`);
   }
   /**
    * Send a push notification to all registered devices for the user
@@ -16062,25 +14992,25 @@ class PushNotificationClient {
    * @param data - Additional data to send with the notification
    */
   sendToAllDevices(title, body, data) {
-    logger.debug("[PUSH] sendToAllDevices called:", {
+    persistence.logger.debug("[PUSH] sendToAllDevices called:", {
       title: contentLogMetadata(title),
       body: contentLogMetadata(body),
       dataKeyCount: data ? Object.keys(data).length : 0
     });
     (async () => {
       try {
-        logger.debug("[PUSH] Fetching push tokens...");
+        persistence.logger.debug("[PUSH] Fetching push tokens...");
         const tokens = await this.fetchPushTokens();
-        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        persistence.logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
         tokens.forEach((token, index) => {
-          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
+          persistence.logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
         });
         if (tokens.length === 0) {
-          logger.debug("No push tokens found for user");
+          persistence.logger.debug("No push tokens found for user");
           return;
         }
         const messages = tokens.map((token, index) => {
-          logger.debug(`[PUSH] Creating message ${index + 1} for token`);
+          persistence.logger.debug(`[PUSH] Creating message ${index + 1} for token`);
           return {
             to: token.token,
             title,
@@ -16093,11 +15023,11 @@ class PushNotificationClient {
             priority: "high"
           };
         });
-        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        persistence.logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
         await this.sendPushNotifications(messages);
-        logger.debug("[PUSH] Push notifications sent successfully");
+        persistence.logger.debug("[PUSH] Push notifications sent successfully");
       } catch (error) {
-        logger.debug("[PUSH] Error sending to all devices:", error);
+        persistence.logger.debug("[PUSH] Error sending to all devices:", error);
       }
     })();
   }
@@ -16119,7 +15049,7 @@ class PushNotificationClient {
     };
     const sessionId = typeof params.data?.sessionId === "string" ? params.data.sessionId : null;
     if (!sessionId) {
-      logger.debug("[PUSH] sendSessionNotification: missing sessionId, falling back to direct send");
+      persistence.logger.debug("[PUSH] sendSessionNotification: missing sessionId, falling back to direct send");
       this.sendToAllDevices(title, body, payloadData);
       return;
     }
@@ -16137,14 +15067,14 @@ class PushNotificationClient {
             headers: {
               "Authorization": `Bearer ${this.token}`,
               "Content-Type": "application/json",
-              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+              "X-Happy-Client": `cli-daemon/${persistence.configuration.currentCliVersion}`
             },
             timeout: 15e3
           }
         );
-        logger.debug(`[PUSH] sendSessionNotification dispatched via server (kind=${params.kind})`);
+        persistence.logger.debug(`[PUSH] sendSessionNotification dispatched via server (kind=${params.kind})`);
       } catch (error) {
-        logger.debug("[PUSH] sendSessionNotification failed:", error);
+        persistence.logger.debug("[PUSH] sendSessionNotification failed:", error);
       }
     })();
   }
@@ -16162,7 +15092,7 @@ function startOfflineReconnection(config) {
       validateStatus: (status) => status < 500,
       // 4xx = server is up, 5xx = server error
       headers: {
-        "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+        "X-Happy-Client": `cli-daemon/${persistence.configuration.currentCliVersion}`
       }
     });
   };
@@ -16178,16 +15108,16 @@ function startOfflineReconnection(config) {
       if (cancelled) return;
       reconnected = true;
       config.onNotify("\u2705 Reconnected! Session syncing in background.");
-      logger.debug("[OfflineReconnection] Successfully reconnected");
+      persistence.logger.debug("[OfflineReconnection] Successfully reconnected");
     } catch (e) {
       if (axios.isAxiosError(e) && e.response?.status === 401) {
-        logger.debug("[OfflineReconnection] Authentication error, stopping retries");
+        persistence.logger.debug("[OfflineReconnection] Authentication error, stopping retries");
         config.onNotify("\u274C Authentication failed. Please re-authenticate with `very-happy auth`.");
         return;
       }
       failureCount++;
       const delay = retryDelayMs(failureCount);
-      logger.debug(`[OfflineReconnection] Attempt ${failureCount} failed, retrying in ${delay}ms`);
+      persistence.logger.debug(`[OfflineReconnection] Attempt ${failureCount} failed, retrying in ${delay}ms`);
       if (!cancelled) {
         timeoutId = setTimeout(attemptReconnect, delay);
       }
@@ -16281,7 +15211,7 @@ const connectionState = new OfflineState();
 
 function accountBoxPublicKeyFromCredentials(credential) {
   if (credential.encryption.type === "legacy") {
-    return libsodiumPublicKeyFromSecretKey(credential.encryption.secret);
+    return persistence.libsodiumPublicKeyFromSecretKey(credential.encryption.secret);
   }
   return credential.encryption.publicKey;
 }
@@ -16348,7 +15278,7 @@ class NotificationProducer {
     const now = Date.now();
     const last = this.lastEmittedAt.get(repeatKey);
     if (last !== void 0 && now - last < DEDUP_WINDOW_MS) {
-      logger.debug(`[notif] Suppressing duplicate ${notifType} for ${this.sessionId}`);
+      persistence.logger.debug(`[notif] Suppressing duplicate ${notifType} for ${this.sessionId}`);
       return;
     }
     this.lastEmittedAt.set(repeatKey, now);
@@ -16361,10 +15291,10 @@ class NotificationProducer {
     let enc;
     try {
       const plaintext = new TextEncoder().encode(JSON.stringify(body));
-      const bundle = libsodiumEncryptForPublicKey(plaintext, this.accountBoxPubKey);
-      enc = encodeBase64(bundle);
+      const bundle = persistence.libsodiumEncryptForPublicKey(plaintext, this.accountBoxPubKey);
+      enc = persistence.encodeBase64(bundle);
     } catch (err) {
-      logger.debug("[notif] Failed to encrypt notification body:", err);
+      persistence.logger.debug("[notif] Failed to encrypt notification body:", err);
       return;
     }
     void this.post(notifType, enc, repeatKey);
@@ -16372,7 +15302,7 @@ class NotificationProducer {
   async post(notifType, enc, repeatKey) {
     try {
       await axios.post(
-        `${configuration.serverUrl}/v1/feed`,
+        `${persistence.configuration.serverUrl}/v1/feed`,
         {
           notifType,
           sessionId: this.sessionId,
@@ -16383,14 +15313,14 @@ class NotificationProducer {
           headers: {
             "Authorization": `Bearer ${this.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 5e3
         }
       );
-      logger.debug(`[notif] Posted ${notifType} for session ${this.sessionId}`);
+      persistence.logger.debug(`[notif] Posted ${notifType} for session ${this.sessionId}`);
     } catch (err) {
-      logger.debug(`[notif] Failed to post ${notifType}:`, err);
+      persistence.logger.debug(`[notif] Failed to post ${notifType}:`, err);
     }
   }
   /** Short, human-friendly label for the project/session for use in titles. */
@@ -16428,7 +15358,7 @@ class ApiClient {
   pushClient;
   constructor(credential) {
     this.credential = credential;
-    this.pushClient = new PushNotificationClient(credential.token, configuration.serverUrl);
+    this.pushClient = new PushNotificationClient(credential.token, persistence.configuration.serverUrl);
   }
   /**
    * Create a new session or load existing one with the given tag
@@ -16438,9 +15368,9 @@ class ApiClient {
     let encryptionKey;
     let encryptionVariant;
     if (this.credential.encryption.type === "dataKey") {
-      encryptionKey = getRandomBytes(32);
+      encryptionKey = persistence.getRandomBytes(32);
       encryptionVariant = "dataKey";
-      let encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
+      let encryptedDataKey = persistence.libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
       dataEncryptionKey.set([0], 0);
       dataEncryptionKey.set(encryptedDataKey, 1);
@@ -16450,38 +15380,38 @@ class ApiClient {
     }
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/sessions`,
+        `${persistence.configuration.serverUrl}/v1/sessions`,
         {
           tag: opts.tag,
-          metadata: encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.metadata)),
-          agentState: opts.state ? encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.state)) : null,
-          dataEncryptionKey: dataEncryptionKey ? encodeBase64(dataEncryptionKey) : null
+          metadata: persistence.encodeBase64(persistence.encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          agentState: opts.state ? persistence.encodeBase64(persistence.encrypt(encryptionKey, encryptionVariant, opts.state)) : null,
+          dataEncryptionKey: dataEncryptionKey ? persistence.encodeBase64(dataEncryptionKey) : null
         },
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 6e4
           // 1 minute timeout for very bad network connections
         }
       );
-      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      persistence.logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
       let raw = response.data.session;
       let session = {
         id: raw.id,
         seq: raw.seq,
-        metadata: decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)),
+        metadata: persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(raw.metadata)),
         metadataVersion: raw.metadataVersion,
-        agentState: raw.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.agentState)) : null,
+        agentState: raw.agentState ? persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(raw.agentState)) : null,
         agentStateVersion: raw.agentStateVersion,
         encryptionKey,
         encryptionVariant
       };
       return session;
     } catch (error) {
-      logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      persistence.logger.debug("[API] [ERROR] Failed to get or create session:", error);
       if (error && typeof error === "object" && "code" in error) {
         const errorCode = error.code;
         if (isNetworkError(errorCode)) {
@@ -16489,7 +15419,7 @@ class ApiClient {
             operation: "Session creation",
             caller: "api.getOrCreateSession",
             errorCode,
-            url: `${configuration.serverUrl}/v1/sessions`
+            url: `${persistence.configuration.serverUrl}/v1/sessions`
           });
           return null;
         }
@@ -16499,7 +15429,7 @@ class ApiClient {
         connectionState.fail({
           operation: "Session creation",
           errorCode: "404",
-          url: `${configuration.serverUrl}/v1/sessions`
+          url: `${persistence.configuration.serverUrl}/v1/sessions`
         });
         return null;
       }
@@ -16509,7 +15439,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Session creation",
             errorCode: String(status),
-            url: `${configuration.serverUrl}/v1/sessions`,
+            url: `${persistence.configuration.serverUrl}/v1/sessions`,
             details: ["Server encountered an error, will retry automatically"]
           });
           return null;
@@ -16529,7 +15459,7 @@ class ApiClient {
     if (this.credential.encryption.type === "dataKey") {
       encryptionVariant = "dataKey";
       encryptionKey = this.credential.encryption.machineKey;
-      let encryptedDataKey = libsodiumEncryptForPublicKey(this.credential.encryption.machineKey, this.credential.encryption.publicKey);
+      let encryptedDataKey = persistence.libsodiumEncryptForPublicKey(this.credential.encryption.machineKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
       dataEncryptionKey.set([0], 0);
       dataEncryptionKey.set(encryptedDataKey, 1);
@@ -16548,32 +15478,32 @@ class ApiClient {
     });
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/machines`,
+        `${persistence.configuration.serverUrl}/v1/machines`,
         {
           id: opts.machineId,
-          metadata: encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.metadata)),
-          daemonState: opts.daemonState ? encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.daemonState)) : void 0,
-          dataEncryptionKey: dataEncryptionKey ? encodeBase64(dataEncryptionKey) : void 0
+          metadata: persistence.encodeBase64(persistence.encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          daemonState: opts.daemonState ? persistence.encodeBase64(persistence.encrypt(encryptionKey, encryptionVariant, opts.daemonState)) : void 0,
+          dataEncryptionKey: dataEncryptionKey ? persistence.encodeBase64(dataEncryptionKey) : void 0
         },
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 6e4
           // 1 minute timeout for very bad network connections
         }
       );
       const raw = response.data.machine;
-      logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
+      persistence.logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
       const machine = {
         id: raw.id,
         encryptionKey,
         encryptionVariant,
-        metadata: raw.metadata ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)) : null,
+        metadata: raw.metadata ? persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(raw.metadata)) : null,
         metadataVersion: raw.metadataVersion || 0,
-        daemonState: raw.daemonState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.daemonState)) : null,
+        daemonState: raw.daemonState ? persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(raw.daemonState)) : null,
         daemonStateVersion: raw.daemonStateVersion || 0
       };
       return machine;
@@ -16583,7 +15513,7 @@ class ApiClient {
           operation: "Machine registration",
           caller: "api.getOrCreateMachine",
           errorCode: error.code,
-          url: `${configuration.serverUrl}/v1/machines`
+          url: `${persistence.configuration.serverUrl}/v1/machines`
         });
         return createMinimalMachine();
       }
@@ -16614,7 +15544,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Machine registration",
             errorCode: "429",
-            url: `${configuration.serverUrl}/v1/machines`,
+            url: `${persistence.configuration.serverUrl}/v1/machines`,
             details: ["Relay write quota is cooling down; realtime connection will retry automatically"]
           });
           return createMinimalMachine();
@@ -16623,7 +15553,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Machine registration",
             errorCode: String(status),
-            url: `${configuration.serverUrl}/v1/machines`,
+            url: `${persistence.configuration.serverUrl}/v1/machines`,
             details: ["Server encountered an error, will retry automatically"]
           });
           return createMinimalMachine();
@@ -16632,7 +15562,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Machine registration",
             errorCode: "404",
-            url: `${configuration.serverUrl}/v1/machines`
+            url: `${persistence.configuration.serverUrl}/v1/machines`
           });
           return createMinimalMachine();
         }
@@ -16671,11 +15601,11 @@ class ApiClient {
   async kvGet(key) {
     try {
       const response = await axios.get(
-        `${configuration.serverUrl}/v1/kv/${encodeURIComponent(key)}`,
+        `${persistence.configuration.serverUrl}/v1/kv/${encodeURIComponent(key)}`,
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 5e3,
           validateStatus: (s) => s === 200 || s === 404
@@ -16684,7 +15614,7 @@ class ApiClient {
       if (response.status === 404) return null;
       return response.data;
     } catch (error) {
-      logger.debug(`[API] kvGet(${key}) failed:`, error);
+      persistence.logger.debug(`[API] kvGet(${key}) failed:`, error);
       return null;
     }
   }
@@ -16695,7 +15625,7 @@ class ApiClient {
   async registerVendorToken(vendor, apiKey) {
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/connect/${vendor}/register`,
+        `${persistence.configuration.serverUrl}/v1/connect/${vendor}/register`,
         {
           token: JSON.stringify(apiKey)
         },
@@ -16703,7 +15633,7 @@ class ApiClient {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 5e3
         }
@@ -16711,9 +15641,9 @@ class ApiClient {
       if (response.status !== 200 && response.status !== 201) {
         throw new Error(`Server returned status ${response.status}`);
       }
-      logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
+      persistence.logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
     } catch (error) {
-      logger.debug(`[API] [ERROR] Failed to register vendor token:`, redactLogValue(error));
+      persistence.logger.debug(`[API] [ERROR] Failed to register vendor token:`, persistence.redactLogValue(error));
       throw new Error(`Failed to register vendor token: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -16724,24 +15654,24 @@ class ApiClient {
   async getVendorToken(vendor) {
     try {
       const response = await axios.get(
-        `${configuration.serverUrl}/v1/connect/${vendor}/token`,
+        `${persistence.configuration.serverUrl}/v1/connect/${vendor}/token`,
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
             "Content-Type": "application/json",
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 5e3
         }
       );
       if (response.status === 404) {
-        logger.debug(`[API] No vendor token found for ${vendor}`);
+        persistence.logger.debug(`[API] No vendor token found for ${vendor}`);
         return null;
       }
       if (response.status !== 200) {
         throw new Error(`Server returned status ${response.status}`);
       }
-      logger.debug(`[API] Raw vendor token response:`, {
+      persistence.logger.debug(`[API] Raw vendor token response:`, {
         status: response.status,
         dataKeys: Object.keys(response.data || {}),
         hasToken: "token" in (response.data || {}),
@@ -16753,37 +15683,37 @@ class ApiClient {
           try {
             tokenData = JSON.parse(response.data.token);
           } catch (parseError) {
-            logger.debug(`[API] Failed to parse token as JSON, using as string:`, parseError);
+            persistence.logger.debug(`[API] Failed to parse token as JSON, using as string:`, parseError);
             tokenData = response.data.token;
           }
         } else if (response.data.token !== null) {
           tokenData = response.data.token;
         } else {
-          logger.debug(`[API] Token is null for ${vendor}, treating as not found`);
+          persistence.logger.debug(`[API] Token is null for ${vendor}, treating as not found`);
           return null;
         }
       } else if (response.data && typeof response.data === "object") {
         if (response.data.token === null && Object.keys(response.data).length === 1) {
-          logger.debug(`[API] Response contains only null token for ${vendor}, treating as not found`);
+          persistence.logger.debug(`[API] Response contains only null token for ${vendor}, treating as not found`);
           return null;
         }
         tokenData = response.data;
       }
       if (tokenData === null || tokenData && typeof tokenData === "object" && tokenData.token === null && Object.keys(tokenData).length === 1) {
-        logger.debug(`[API] Token data is null for ${vendor}`);
+        persistence.logger.debug(`[API] Token data is null for ${vendor}`);
         return null;
       }
-      logger.debug(`[API] Vendor token for ${vendor} retrieved successfully`, {
+      persistence.logger.debug(`[API] Vendor token for ${vendor} retrieved successfully`, {
         tokenDataType: typeof tokenData,
         tokenDataKeys: tokenData && typeof tokenData === "object" ? Object.keys(tokenData) : "not an object"
       });
       return tokenData;
     } catch (error) {
       if (error.response?.status === 404) {
-        logger.debug(`[API] No vendor token found for ${vendor}`);
+        persistence.logger.debug(`[API] No vendor token found for ${vendor}`);
         return null;
       }
-      logger.debug(`[API] [ERROR] Failed to get vendor token:`, redactLogValue(error));
+      persistence.logger.debug(`[API] [ERROR] Failed to get vendor token:`, persistence.redactLogValue(error));
       return null;
     }
   }
@@ -16801,19 +15731,19 @@ class ApiClient {
   async deactivateSession(sessionId) {
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/sessions/${sessionId}/archive`,
+        `${persistence.configuration.serverUrl}/v1/sessions/${sessionId}/archive`,
         {},
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 3e3
         }
       );
       return response.status >= 200 && response.status < 300;
     } catch (error) {
-      logger.debug("[API] deactivateSession failed:", error);
+      persistence.logger.debug("[API] deactivateSession failed:", error);
       return false;
     }
   }
@@ -16832,11 +15762,11 @@ class ApiClient {
     for (let attempt = 0; attempt < attempts; attempt += 1) {
       try {
         const response = await axios.get(
-          `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
+          `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
           {
             headers: {
               "Authorization": `Bearer ${this.credential.token}`,
-              "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+              "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
             },
             timeout: opts?.timeoutMs ?? 4e3,
             validateStatus: () => true
@@ -16850,17 +15780,17 @@ class ApiClient {
           if (!row || typeof row.seq !== "number" || typeof row.metadata !== "string") {
             return { ok: false, reason: "unsupported" };
           }
-          const metadata = decrypt(encryptionKey, encryptionVariant, decodeBase64(row.metadata));
+          const metadata = persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(row.metadata));
           if (!metadata) return { ok: false, reason: "unavailable" };
-          const agentState = row.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(row.agentState)) : null;
+          const agentState = row.agentState ? persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(row.agentState)) : null;
           return {
             ok: true,
             session: { seq: row.seq, metadata, metadataVersion: row.metadataVersion, agentState, agentStateVersion: row.agentStateVersion }
           };
         }
-        logger.debug(`[API] getSession ${sessionId}: status ${response.status} (attempt ${attempt + 1}/${attempts})`);
+        persistence.logger.debug(`[API] getSession ${sessionId}: status ${response.status} (attempt ${attempt + 1}/${attempts})`);
       } catch (error) {
-        logger.debug(`[API] getSession ${sessionId} failed (attempt ${attempt + 1}/${attempts}):`, error);
+        persistence.logger.debug(`[API] getSession ${sessionId} failed (attempt ${attempt + 1}/${attempts}):`, error);
       }
       const delayMs = delays[Math.min(attempt, delays.length - 1)];
       if (attempt < attempts - 1 && delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
@@ -16873,12 +15803,12 @@ class ApiClient {
   async reactivateSession(sessionId) {
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/sessions/${sessionId}/unarchive`,
+        `${persistence.configuration.serverUrl}/v1/sessions/${sessionId}/unarchive`,
         {},
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
-            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            "X-Happy-Client": `cli-coding-session/${persistence.configuration.currentCliVersion}`
           },
           timeout: 3e3,
           validateStatus: (status) => status >= 200 && status < 300 || status === 404
@@ -16886,7 +15816,7 @@ class ApiClient {
       );
       return response.status >= 200 && response.status < 300 || response.status === 404;
     } catch (error) {
-      logger.debug("[API] reactivateSession failed:", error);
+      persistence.logger.debug("[API] reactivateSession failed:", error);
       return false;
     }
   }
@@ -16970,67 +15900,36 @@ exports.MAX_CHAT_ATTACHMENT_SOURCE_BYTES = MAX_CHAT_ATTACHMENT_SOURCE_BYTES;
 exports.MIRROR_BACKFILL_LINES_DEFAULT = MIRROR_BACKFILL_LINES_DEFAULT;
 exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.STREAM_DELTA_MAX_CHARS = STREAM_DELTA_MAX_CHARS;
-exports.SandboxConfigSchema = SandboxConfigSchema;
 exports.TITLE_PROMPT_PREFIX = TITLE_PROMPT_PREFIX;
-exports.acquireDaemonLock = acquireDaemonLock;
 exports.api = api;
-exports.clearCredentials = clearCredentials;
-exports.clearDaemonState = clearDaemonState;
-exports.clearMachineId = clearMachineId;
 exports.commandOnPath = commandOnPath;
 exports.compareExactVersions = compareExactVersions;
-exports.configuration = configuration;
 exports.connectionState = connectionState;
 exports.contentLogMetadata = contentLogMetadata;
 exports.createEnvelope = createEnvelope;
-exports.credentialRelayProblem = credentialRelayProblem;
 exports.decideBackfill = decideBackfill;
 exports.decideMirrorBinding = decideMirrorBinding;
-exports.decodeBase64 = decodeBase64;
-exports.decrypt = decrypt;
-exports.decryptLegacy = decryptLegacy;
-exports.decryptWithDataKey = decryptWithDataKey;
 exports.delay = delay;
-exports.deletePersistedSessions = deletePersistedSessions;
 exports.deriveLocalCliUpdateSummary = deriveLocalCliUpdateSummary;
 exports.detectCLIAvailability = detectCLIAvailability;
 exports.detectResumeSupport = detectResumeSupport;
-exports.encodeBase64 = encodeBase64;
-exports.encodeBase64Url = encodeBase64Url;
-exports.encrypt = encrypt;
-exports.ensurePrivateDirectory = ensurePrivateDirectory;
-exports.ensurePrivateDirectorySync = ensurePrivateDirectorySync;
 exports.errorLogMetadata = errorLogMetadata;
 exports.extractCompleteLines = extractCompleteLines;
 exports.fetchCliUpdateState = fetchCliUpdateState;
-exports.getLatestDaemonLog = getLatestDaemonLog;
 exports.getLocalHappyAgentCredentialPath = getLocalHappyAgentCredentialPath;
 exports.getProjectPath = getProjectPath;
-exports.hardenPrivateFile = hardenPrivateFile;
-exports.hardenPrivateFileSync = hardenPrivateFileSync;
 exports.initializeSandbox = initializeSandbox;
 exports.isClaudeSessionId = isClaudeSessionId;
 exports.isValidSessionId = isValidSessionId;
 exports.isValidTerminalId = isValidTerminalId;
 exports.listVhTerminals = listVhTerminals;
-exports.logger = logger;
 exports.mirrorLineKey = mirrorLineKey;
 exports.mirrorLocalId = mirrorLocalId;
-exports.packageJson = packageJson;
 exports.parseExactVersion = parseExactVersion;
 exports.parseTerminalHookPayload = parseTerminalHookPayload;
-exports.persistSession = persistSession;
-exports.persistence = persistence;
 exports.projectPath = projectPath;
-exports.readCredentials = readCredentials;
-exports.readCredentialsForConfiguredRelay = readCredentialsForConfiguredRelay;
-exports.readDaemonState = readDaemonState;
 exports.readLocalHappyAgentCredentials = readLocalHappyAgentCredentials;
-exports.readPersistedSessions = readPersistedSessions;
-exports.readSettings = readSettings;
-exports.readSettingsOutcome = readSettingsOutcome;
 exports.readVhTerminal = readVhTerminal;
-exports.releaseDaemonLock = releaseDaemonLock;
 exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
 exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;
@@ -17039,10 +15938,4 @@ exports.startOfflineReconnection = startOfflineReconnection;
 exports.streamKeyOf = streamKeyOf;
 exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;
 exports.tmuxArgs = tmuxArgs;
-exports.updateSettings = updateSettings;
 exports.wrapCommand = wrapCommand;
-exports.writeCredentialsDataKey = writeCredentialsDataKey;
-exports.writeCredentialsLegacy = writeCredentialsLegacy;
-exports.writeDaemonState = writeDaemonState;
-exports.writePrivateFileSync = writePrivateFileSync;
-exports.writeSettings = writeSettings;