@zonease/happy 0.6.38 → 0.6.40

package/dist/{types-DvTsFaqR.cjs → api-C7FyJfZ1.cjs}

@@ -1,1050 +1,35 @@
 'use strict';
 
 var axios = require('axios');
-var chalk = require('chalk');
-var fs$1 = require('fs');
-var fs = require('node:fs');
-var os = require('node:os');
-var path = require('node:path');
+var logger = require('./persistence-CBTtC_dm.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
-var cuid2 = require('@paralleldrive/cuid2');
+require('./index-CDTNgfUf.cjs');
+var time = require('./time-Bj2HRkKH.cjs');
 var node_crypto = require('node:crypto');
-var tweetnacl = require('tweetnacl');
+var fs = require('node:fs');
+var path = require('node:path');
 var node_child_process = require('node:child_process');
 var promises = require('node:fs/promises');
+var os = require('node:os');
 var node_util = require('node:util');
 var child_process = require('child_process');
 var util = require('util');
-var fs$2 = require('fs/promises');
+var fs$1 = require('fs/promises');
 var path$1 = require('path');
-var url = require('url');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
 var node_module = require('node:module');
 var WebSocket = require('ws');
 var crypto = require('crypto');
+var tweetnacl = require('tweetnacl');
 var base64 = require('@stablelib/base64');
 var node_readline = require('node:readline');
 var expoServerSdk = require('expo-server-sdk');
+var sessionKeyCache = require('./sessionKeyCache-CDmexJ9p.cjs');
+var chalk = require('chalk');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
-
-const DEBUG_TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true"]);
-function isDebug() {
-  return DEBUG_TRUE_VALUES.has(process.env.DEBUG?.toLowerCase() ?? "");
-}
-
-var name = "@zonease/happy";
-var version = "0.6.38";
-var description = "Mobile and Web client for Claude Code, Codex, and Gemini";
-var author = "ZonEaseTech";
-var license = "MIT";
-var type = "module";
-var homepage = "https://github.com/ZonEaseTech/happy-wfs";
-var bugs = "https://github.com/ZonEaseTech/happy-wfs/issues";
-var repository = {
-	type: "git",
-	url: "git+https://github.com/ZonEaseTech/happy-wfs.git",
-	directory: "packages/happy-cli"
-};
-var bin = {
-	happy: "./bin/happy.mjs",
-	"happy-mcp": "./bin/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",
-	"package.json"
-];
-var scripts = {
-	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
-	typecheck: "tsc --noEmit",
-	build: "shx rm -rf dist && tsc --noEmit && pkgroll",
-	test: "$npm_execpath run build && vitest run",
-	"test:integration": "$npm_execpath run build && vitest run --config vitest.integration.config.ts",
-	start: "$npm_execpath run build && node ./bin/happy.mjs",
-	dev: "tsx src/index.ts",
-	"dev:local-server": "$npm_execpath run build && tsx --env-file .env.dev-local-server src/index.ts",
-	"dev:integration-test-env": "$npm_execpath run build && tsx --env-file .env.integration-test src/index.ts",
-	prepublishOnly: "$npm_execpath run build && $npm_execpath test",
-	release: "$npm_execpath install && release-it",
-	postinstall: "node scripts/unpack-tools.cjs",
-	"// ==== Dev/Stable Variant Management ====": "",
-	stable: "node scripts/env-wrapper.cjs stable",
-	"dev:variant": "node scripts/env-wrapper.cjs dev",
-	"// ==== Stable Version Quick Commands ====": "",
-	"stable:daemon:start": "node scripts/env-wrapper.cjs stable daemon start",
-	"stable:daemon:stop": "node scripts/env-wrapper.cjs stable daemon stop",
-	"stable:daemon:status": "node scripts/env-wrapper.cjs stable daemon status",
-	"stable:auth": "node scripts/env-wrapper.cjs stable auth",
-	"// ==== Development Version Quick Commands ====": "",
-	"dev:daemon:start": "node scripts/env-wrapper.cjs dev daemon start",
-	"dev:daemon:stop": "node scripts/env-wrapper.cjs dev daemon stop",
-	"dev:daemon:status": "node scripts/env-wrapper.cjs dev daemon status",
-	"dev:auth": "node scripts/env-wrapper.cjs dev auth",
-	"// ==== Setup ====": "",
-	"setup:dev": "node scripts/setup-dev.cjs",
-	doctor: "node scripts/env-wrapper.cjs stable doctor",
-	"// ==== Development Linking ====": "",
-	"link:dev": "node scripts/link-dev.cjs",
-	"unlink:dev": "node scripts/link-dev.cjs unlink"
-};
-var dependencies = {
-	"@agentclientprotocol/sdk": "^0.14.1",
-	"@paralleldrive/cuid2": "^2.2.2",
-	"@modelcontextprotocol/sdk": "^1.25.3",
-	"@stablelib/base64": "^2.0.1",
-	"@stablelib/hex": "^2.0.1",
-	"@types/cross-spawn": "^6.0.6",
-	"@types/http-proxy": "^1.17.17",
-	"@types/qrcode-terminal": "^0.12.2",
-	"@types/react": "^19.2.7",
-	"@types/tmp": "^0.2.6",
-	"@types/ws": "^8.18.1",
-	ai: "^5.0.107",
-	axios: "^1.13.2",
-	chalk: "^5.6.2",
-	"cross-spawn": "^7.0.6",
-	"expo-server-sdk": "^3.15.0",
-	fastify: "^5.6.2",
-	"fastify-type-provider-zod": "4.0.2",
-	"http-proxy": "^1.18.1",
-	"http-proxy-middleware": "^3.0.5",
-	ink: "^6.5.1",
-	open: "^10.2.0",
-	"ps-list": "^8.1.1",
-	"qrcode-terminal": "^0.12.0",
-	react: "^19.2.0",
-	"socket.io-client": "^4.8.1",
-	tar: "^7.5.2",
-	tmp: "^0.2.5",
-	tweetnacl: "^1.0.3",
-	ws: "^8.19.0",
-	zod: "3.25.76"
-};
-var devDependencies = {
-	"@eslint/compat": "^1",
-	"@types/node": ">=20",
-	"cross-env": "^10.1.0",
-	dotenv: "^16.6.1",
-	eslint: "^9",
-	"eslint-config-prettier": "^10",
-	pkgroll: "^2.14.2",
-	"release-it": "^19.0.6",
-	shx: "^0.3.3",
-	"ts-node": "^10",
-	tsx: "^4.20.6",
-	typescript: "5.9.3",
-	vitest: "^3.2.4",
-	"happy-wire": "*"
-};
-var resolutions = {
-	"whatwg-url": "14.2.0",
-	"parse-path": "7.0.3",
-	"@types/parse-path": "7.0.3"
-};
-var publishConfig = {
-	registry: "https://registry.npmjs.org",
-	access: "public"
-};
-var packageManager = "yarn@1.22.22";
-var optionalDependencies = {
-	"node-pty": "^1.0.0",
-	"@zonease/happy-tools-arm64-darwin": "1.0.0",
-	"@zonease/happy-tools-x64-darwin": "1.0.0",
-	"@zonease/happy-tools-arm64-linux": "1.0.0",
-	"@zonease/happy-tools-x64-linux": "1.0.0",
-	"@zonease/happy-tools-x64-win32": "1.0.0",
-	"@zonease/happy-tools-arm64-win32": "1.0.0"
-};
-var packageJson = {
-	name: name,
-	version: version,
-	description: description,
-	author: author,
-	license: license,
-	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,
-	devDependencies: devDependencies,
-	resolutions: resolutions,
-	publishConfig: publishConfig,
-	packageManager: packageManager,
-	optionalDependencies: optionalDependencies
-};
-
-class Configuration {
-  serverUrl;
-  webappUrl;
-  isDaemonProcess;
-  // Directories and paths (from persistence)
-  happyHomeDir;
-  logsDir;
-  settingsFile;
-  privateKeyFile;
-  daemonStateFile;
-  daemonLockFile;
-  sessionKeysDir;
-  currentCliVersion;
-  isExperimentalEnabled;
-  disableCaffeinate;
-  constructor() {
-    this.serverUrl = process.env.HAPPY_SERVER_URL || "https://api-happy.zonease.org";
-    this.webappUrl = process.env.HAPPY_WEBAPP_URL || "https://happy.zonease.org";
-    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.sessionKeysDir = path.join(this.happyHomeDir, "session-keys");
-    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 (variant === "dev" && !this.happyHomeDir.includes("dev")) {
-      console.warn('\u26A0\uFE0F  WARNING: HAPPY_VARIANT=dev but HAPPY_HOME_DIR does not contain "dev"');
-      console.warn(`   Current: ${this.happyHomeDir}`);
-      console.warn(`   Expected: Should contain "dev" (e.g., ~/.happy-dev)`);
-    }
-    if (!this.isDaemonProcess && variant === "dev") {
-      console.log("\x1B[33m\u{1F527} DEV MODE\x1B[0m - Data: " + this.happyHomeDir);
-    }
-    if (!fs.existsSync(this.happyHomeDir)) {
-      fs.mkdirSync(this.happyHomeDir, { recursive: true });
-    }
-    if (!fs.existsSync(this.logsDir)) {
-      fs.mkdirSync(this.logsDir, { recursive: true });
-    }
-  }
-}
-const configuration = new Configuration();
-
-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);
-}
-class Logger {
-  constructor(logFilePath = getSessionLogPath()) {
-    this.logFilePath = logFilePath;
-    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.HAPPY_SERVER_URL) {
-      this.dangerouslyUnencryptedServerLoggingUrl = process.env.HAPPY_SERVER_URL;
-      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
-    }
-  }
-  dangerouslyUnencryptedServerLoggingUrl;
-  // 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 (!isDebug()) {
-      this.debug(`In production, skipping message inspection`);
-    }
-    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(object);
-    const json = JSON.stringify(truncatedObject, null, 2);
-    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
-  }
-  info(message, ...args) {
-    this.logToConsole("info", "", message, ...args);
-    this.debug(message, args);
-  }
-  infoDeveloper(message, ...args) {
-    this.debug(message, ...args);
-    if (isDebug()) {
-      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) {
-    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" },
-        body: JSON.stringify({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          level,
-          message: `${message} ${args.map(
-            (a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)
-          ).join(" ")}`,
-          source: "cli",
-          platform: process.platform
-        })
-      });
-    } catch (error) {
-    }
-  }
-  logToFile(prefix, message, ...args) {
-    const logLine = `${prefix} ${message} ${args.map((arg) => {
-      if (typeof arg === "string") return arg;
-      if (arg instanceof Error) return `${arg.message}
-${arg.stack ?? ""}`;
-      return JSON.stringify(arg);
-    }).join(" ")}
-`;
-    if (this.dangerouslyUnencryptedServerLoggingUrl) {
-      let level = "info";
-      if (prefix.includes(this.localTimezoneTimestamp())) {
-        level = "debug";
-      }
-      this.sendToRemoteServer(level, message, ...args).catch(() => {
-      });
-    }
-    try {
-      fs$1.appendFileSync(this.logFilePath, logLine);
-    } catch (appendError) {
-      if (isDebug()) {
-        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 (!fs.existsSync(logsDir)) {
-      return [];
-    }
-    const logs = fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
-      const fullPath = path.join(logsDir, file);
-      const stats = 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 && fs.existsSync(state.daemonLogPath)) {
-        const stats = 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"),
-  text: z__namespace.string(),
-  thinking: z__namespace.boolean().optional()
-});
-const sessionServiceMessageEventSchema = z__namespace.object({
-  t: z__namespace.literal("service"),
-  text: z__namespace.string()
-});
-const sessionToolCallStartEventSchema = z__namespace.object({
-  t: z__namespace.literal("tool-call-start"),
-  call: z__namespace.string(),
-  name: z__namespace.string(),
-  title: z__namespace.string(),
-  description: z__namespace.string(),
-  args: z__namespace.record(z__namespace.string(), z__namespace.unknown())
-});
-const sessionToolCallEndEventSchema = z__namespace.object({
-  t: z__namespace.literal("tool-call-end"),
-  call: z__namespace.string()
-});
-const sessionFileEventSchema = z__namespace.object({
-  t: z__namespace.literal("file"),
-  ref: z__namespace.string(),
-  name: z__namespace.string(),
-  size: z__namespace.number(),
-  image: z__namespace.object({
-    width: z__namespace.number(),
-    height: z__namespace.number(),
-    thumbhash: z__namespace.string()
-  }).optional()
-});
-const sessionTurnStartEventSchema = z__namespace.object({
-  t: z__namespace.literal("turn-start")
-});
-const sessionStartEventSchema = z__namespace.object({
-  t: z__namespace.literal("start"),
-  title: z__namespace.string().optional()
-});
-const sessionTurnEndStatusSchema = z__namespace.enum(["completed", "failed", "cancelled"]);
-const sessionTurnEndEventSchema = z__namespace.object({
-  t: z__namespace.literal("turn-end"),
-  status: sessionTurnEndStatusSchema
-});
-const sessionStopEventSchema = z__namespace.object({
-  t: z__namespace.literal("stop")
-});
-const sessionEventSchema = z__namespace.discriminatedUnion("t", [
-  sessionTextEventSchema,
-  sessionServiceMessageEventSchema,
-  sessionToolCallStartEventSchema,
-  sessionToolCallEndEventSchema,
-  sessionFileEventSchema,
-  sessionTurnStartEventSchema,
-  sessionStartEventSchema,
-  sessionTurnEndEventSchema,
-  sessionStopEventSchema
-]);
-const sessionEnvelopeSchema = z__namespace.object({
-  id: z__namespace.string(),
-  time: z__namespace.number(),
-  role: sessionRoleSchema,
-  turn: z__namespace.string().optional(),
-  subagent: z__namespace.string().refine((value) => cuid2.isCuid(value), {
-    message: "subagent must be a cuid2 value"
-  }).optional(),
-  ev: sessionEventSchema
-}).superRefine((envelope, ctx) => {
-  if (envelope.ev.t === "service" && envelope.role !== "agent") {
-    ctx.addIssue({
-      code: z__namespace.ZodIssueCode.custom,
-      message: 'service events must use role "agent"',
-      path: ["role"]
-    });
-  }
-  if ((envelope.ev.t === "start" || envelope.ev.t === "stop") && envelope.role !== "agent") {
-    ctx.addIssue({
-      code: z__namespace.ZodIssueCode.custom,
-      message: `${envelope.ev.t} events must use role "agent"`,
-      path: ["role"]
-    });
-  }
-});
-const MessageMetaSchema$1 = z__namespace.object({
-  sentFrom: z__namespace.string().optional(),
-  permissionMode: z__namespace.enum(["default", "acceptEdits", "bypassPermissions", "plan", "read-only", "safe-yolo", "yolo"]).optional(),
-  model: z__namespace.string().nullable().optional(),
-  fallbackModel: z__namespace.string().nullable().optional(),
-  reasoningEffort: z__namespace.string().nullable().optional(),
-  customSystemPrompt: z__namespace.string().nullable().optional(),
-  appendSystemPrompt: z__namespace.string().nullable().optional(),
-  allowedTools: z__namespace.array(z__namespace.string()).nullable().optional(),
-  disallowedTools: z__namespace.array(z__namespace.string()).nullable().optional(),
-  displayText: z__namespace.string().optional()
-});
-const UserMessageSchema$1 = z__namespace.object({
-  role: z__namespace.literal("user"),
-  content: z__namespace.object({
-    type: z__namespace.literal("text"),
-    text: z__namespace.string()
-  }),
-  localKey: z__namespace.string().optional(),
-  meta: MessageMetaSchema$1.optional()
-});
-const AgentMessageSchema$1 = z__namespace.object({
-  role: z__namespace.literal("agent"),
-  content: z__namespace.object({
-    type: z__namespace.string()
-  }).passthrough(),
-  meta: MessageMetaSchema$1.optional()
-});
-z__namespace.discriminatedUnion("role", [UserMessageSchema$1, AgentMessageSchema$1]);
-const SessionMessageContentSchema = z__namespace.object({
-  c: z__namespace.string(),
-  t: z__namespace.literal("encrypted")
-});
-const SessionMessageSchema = z__namespace.object({
-  id: z__namespace.string(),
-  seq: z__namespace.number(),
-  localId: z__namespace.string().nullish(),
-  content: SessionMessageContentSchema,
-  createdAt: z__namespace.number(),
-  updatedAt: z__namespace.number()
-});
-const SessionProtocolMessageSchema = z__namespace.object({
-  role: z__namespace.literal("session"),
-  content: sessionEnvelopeSchema,
-  meta: MessageMetaSchema$1.optional()
-});
-z__namespace.discriminatedUnion("role", [
-  UserMessageSchema$1,
-  AgentMessageSchema$1,
-  SessionProtocolMessageSchema
-]);
-const VersionedEncryptedValueSchema = z__namespace.object({
-  version: z__namespace.number(),
-  value: z__namespace.string()
-});
-const VersionedNullableEncryptedValueSchema = z__namespace.object({
-  version: z__namespace.number(),
-  value: z__namespace.string().nullable()
-});
-const UpdateNewMessageBodySchema = z__namespace.object({
-  t: z__namespace.literal("new-message"),
-  sid: z__namespace.string(),
-  message: SessionMessageSchema
-});
-const UpdateSessionBodySchema = z__namespace.object({
-  t: z__namespace.literal("update-session"),
-  id: z__namespace.string(),
-  metadata: VersionedEncryptedValueSchema.nullish(),
-  agentState: VersionedNullableEncryptedValueSchema.nullish()
-});
-const VersionedMachineEncryptedValueSchema = z__namespace.object({
-  version: z__namespace.number(),
-  value: z__namespace.string()
-});
-const UpdateMachineBodySchema = z__namespace.object({
-  t: z__namespace.literal("update-machine"),
-  machineId: z__namespace.string(),
-  metadata: VersionedMachineEncryptedValueSchema.nullish(),
-  daemonState: VersionedMachineEncryptedValueSchema.nullish(),
-  active: z__namespace.boolean().optional(),
-  activeAt: z__namespace.number().optional()
-});
-const CoreUpdateBodySchema = z__namespace.discriminatedUnion("t", [
-  UpdateNewMessageBodySchema,
-  UpdateSessionBodySchema,
-  UpdateMachineBodySchema
-]);
-z__namespace.object({
-  id: z__namespace.string(),
-  seq: z__namespace.number(),
-  body: CoreUpdateBodySchema,
-  createdAt: z__namespace.number()
-});
-const MODEL_MODE_DEFAULT = "default";
-const MODEL_MODES = [
-  MODEL_MODE_DEFAULT,
-  "claude-fable-5",
-  "claude-fable-5[1m]",
-  "claude-opus-5",
-  "claude-opus-5[1m]",
-  "claude-opus-4-8",
-  "claude-opus-4-8[1m]",
-  "claude-opus-4-6",
-  "claude-opus-4-6[1m]",
-  "claude-sonnet-4-6",
-  "claude-sonnet-4-6[1m]",
-  "claude-haiku-4-5",
-  "claude-fable-5-low",
-  "claude-fable-5-medium",
-  "claude-fable-5-high",
-  "claude-fable-5-xhigh",
-  "claude-fable-5-max",
-  "claude-fable-5[1m]-low",
-  "claude-fable-5[1m]-medium",
-  "claude-fable-5[1m]-high",
-  "claude-fable-5[1m]-xhigh",
-  "claude-fable-5[1m]-max",
-  "claude-opus-5-low",
-  "claude-opus-5-medium",
-  "claude-opus-5-high",
-  "claude-opus-5-xhigh",
-  "claude-opus-5-max",
-  "claude-opus-5[1m]-low",
-  "claude-opus-5[1m]-medium",
-  "claude-opus-5[1m]-high",
-  "claude-opus-5[1m]-xhigh",
-  "claude-opus-5[1m]-max",
-  "claude-opus-4-8-low",
-  "claude-opus-4-8-medium",
-  "claude-opus-4-8-high",
-  "claude-opus-4-8-xhigh",
-  "claude-opus-4-8-max",
-  "claude-opus-4-8[1m]-low",
-  "claude-opus-4-8[1m]-medium",
-  "claude-opus-4-8[1m]-high",
-  "claude-opus-4-8[1m]-xhigh",
-  "claude-opus-4-8[1m]-max",
-  "claude-opus-4-6-low",
-  "claude-opus-4-6-medium",
-  "claude-opus-4-6-high",
-  "claude-opus-4-6-max",
-  "claude-opus-4-6[1m]-low",
-  "claude-opus-4-6[1m]-medium",
-  "claude-opus-4-6[1m]-high",
-  "claude-opus-4-6[1m]-max",
-  "claude-sonnet-4-6-low",
-  "claude-sonnet-4-6-medium",
-  "claude-sonnet-4-6-high",
-  "claude-sonnet-4-6[1m]-low",
-  "claude-sonnet-4-6[1m]-medium",
-  "claude-sonnet-4-6[1m]-high",
-  "claude-haiku-4-5-low",
-  "claude-haiku-4-5-medium",
-  "claude-haiku-4-5-high",
-  "gpt-5.6-sol-low",
-  "gpt-5.6-sol-medium",
-  "gpt-5.6-sol-high",
-  "gpt-5.6-sol-xhigh",
-  "gpt-5.6-sol-max",
-  "gpt-5.6-terra-low",
-  "gpt-5.6-terra-medium",
-  "gpt-5.6-terra-high",
-  "gpt-5.6-terra-xhigh",
-  "gpt-5.6-luna-low",
-  "gpt-5.6-luna-medium",
-  "gpt-5.6-luna-high",
-  "gpt-5.6-luna-xhigh",
-  "gpt-5.5-low",
-  "gpt-5.5-medium",
-  "gpt-5.5-high",
-  "gpt-5.5-xhigh",
-  "gpt-5.4-low",
-  "gpt-5.4-medium",
-  "gpt-5.4-high",
-  "gpt-5.4-xhigh",
-  "gpt-5.3-codex-low",
-  "gpt-5.3-codex-medium",
-  "gpt-5.3-codex-high",
-  "gpt-5.3-codex-xhigh",
-  "gpt-5.2-codex-low",
-  "gpt-5.2-codex-medium",
-  "gpt-5.2-codex-high",
-  "gpt-5.2-codex-xhigh",
-  "gpt-5.2-low",
-  "gpt-5.2-medium",
-  "gpt-5.2-high",
-  "gpt-5.2-xhigh",
-  "gpt-5.1-codex-max-low",
-  "gpt-5.1-codex-max-medium",
-  "gpt-5.1-codex-max-high",
-  "gpt-5.1-codex-max-xhigh",
-  "gpt-5.1-codex-mini-medium",
-  "gpt-5.1-codex-mini-high",
-  "gemini-3-pro-preview",
-  "gemini-3-flash-preview",
-  "gemini-2.5-pro"
-];
-const CLAUDE_MODEL_MODES = [
-  MODEL_MODE_DEFAULT,
-  "claude-fable-5",
-  "claude-fable-5[1m]",
-  "claude-opus-5",
-  "claude-opus-5[1m]",
-  "claude-opus-4-8",
-  "claude-opus-4-8[1m]",
-  "claude-opus-4-6",
-  "claude-opus-4-6[1m]",
-  "claude-sonnet-4-6",
-  "claude-sonnet-4-6[1m]",
-  "claude-haiku-4-5",
-  "claude-fable-5-low",
-  "claude-fable-5-medium",
-  "claude-fable-5-high",
-  "claude-fable-5-xhigh",
-  "claude-fable-5-max",
-  "claude-fable-5[1m]-low",
-  "claude-fable-5[1m]-medium",
-  "claude-fable-5[1m]-high",
-  "claude-fable-5[1m]-xhigh",
-  "claude-fable-5[1m]-max",
-  "claude-opus-5-low",
-  "claude-opus-5-medium",
-  "claude-opus-5-high",
-  "claude-opus-5-xhigh",
-  "claude-opus-5-max",
-  "claude-opus-5[1m]-low",
-  "claude-opus-5[1m]-medium",
-  "claude-opus-5[1m]-high",
-  "claude-opus-5[1m]-xhigh",
-  "claude-opus-5[1m]-max",
-  "claude-opus-4-8-low",
-  "claude-opus-4-8-medium",
-  "claude-opus-4-8-high",
-  "claude-opus-4-8-xhigh",
-  "claude-opus-4-8-max",
-  "claude-opus-4-8[1m]-low",
-  "claude-opus-4-8[1m]-medium",
-  "claude-opus-4-8[1m]-high",
-  "claude-opus-4-8[1m]-xhigh",
-  "claude-opus-4-8[1m]-max",
-  "claude-opus-4-6-low",
-  "claude-opus-4-6-medium",
-  "claude-opus-4-6-high",
-  "claude-opus-4-6-max",
-  "claude-opus-4-6[1m]-low",
-  "claude-opus-4-6[1m]-medium",
-  "claude-opus-4-6[1m]-high",
-  "claude-opus-4-6[1m]-max",
-  "claude-sonnet-4-6-low",
-  "claude-sonnet-4-6-medium",
-  "claude-sonnet-4-6-high",
-  "claude-sonnet-4-6[1m]-low",
-  "claude-sonnet-4-6[1m]-medium",
-  "claude-sonnet-4-6[1m]-high",
-  "claude-haiku-4-5-low",
-  "claude-haiku-4-5-medium",
-  "claude-haiku-4-5-high"
-];
-const GEMINI_MODEL_MODES = [
-  MODEL_MODE_DEFAULT,
-  "gemini-3-pro-preview",
-  "gemini-3-flash-preview",
-  "gemini-2.5-pro"
-];
-const CODEX_MODEL_MODES = [
-  MODEL_MODE_DEFAULT,
-  "gpt-5.6-sol-low",
-  "gpt-5.6-sol-medium",
-  "gpt-5.6-sol-high",
-  "gpt-5.6-sol-xhigh",
-  "gpt-5.6-sol-max",
-  "gpt-5.6-terra-low",
-  "gpt-5.6-terra-medium",
-  "gpt-5.6-terra-high",
-  "gpt-5.6-terra-xhigh",
-  "gpt-5.6-luna-low",
-  "gpt-5.6-luna-medium",
-  "gpt-5.6-luna-high",
-  "gpt-5.6-luna-xhigh",
-  "gpt-5.5-low",
-  "gpt-5.5-medium",
-  "gpt-5.5-high",
-  "gpt-5.5-xhigh",
-  "gpt-5.4-low",
-  "gpt-5.4-medium",
-  "gpt-5.4-high",
-  "gpt-5.4-xhigh",
-  "gpt-5.3-codex-low",
-  "gpt-5.3-codex-medium",
-  "gpt-5.3-codex-high",
-  "gpt-5.3-codex-xhigh",
-  "gpt-5.2-codex-low",
-  "gpt-5.2-codex-medium",
-  "gpt-5.2-codex-high",
-  "gpt-5.2-codex-xhigh",
-  "gpt-5.2-low",
-  "gpt-5.2-medium",
-  "gpt-5.2-high",
-  "gpt-5.2-xhigh",
-  "gpt-5.1-codex-max-low",
-  "gpt-5.1-codex-max-medium",
-  "gpt-5.1-codex-max-high",
-  "gpt-5.1-codex-max-xhigh",
-  "gpt-5.1-codex-mini-medium",
-  "gpt-5.1-codex-mini-high"
-];
-const MODEL_MODE_SET = new Set(MODEL_MODES);
-const CLAUDE_MODEL_MODE_SET = new Set(CLAUDE_MODEL_MODES);
-const GEMINI_MODEL_MODE_SET = new Set(GEMINI_MODEL_MODES);
-const CODEX_MODEL_MODE_SET = new Set(CODEX_MODEL_MODES);
-function isModelMode(value) {
-  return MODEL_MODE_SET.has(value);
-}
-function isModelModeForAgent(agent, mode) {
-  if (!isModelMode(mode)) return false;
-  if (agent === "claude") return CLAUDE_MODEL_MODE_SET.has(mode);
-  if (agent === "gemini") return GEMINI_MODEL_MODE_SET.has(mode);
-  return CODEX_MODEL_MODE_SET.has(mode);
-}
-const CLAUDE_MODE_TO_SELECTION = {
-  "claude-fable-5-low": { family: "claude-fable-5", effort: "low" },
-  "claude-fable-5-medium": { family: "claude-fable-5", effort: "medium" },
-  "claude-fable-5-high": { family: "claude-fable-5", effort: "high" },
-  "claude-fable-5-xhigh": { family: "claude-fable-5", effort: "xhigh" },
-  "claude-fable-5-max": { family: "claude-fable-5", effort: "max" },
-  "claude-fable-5[1m]-low": { family: "claude-fable-5[1m]", effort: "low" },
-  "claude-fable-5[1m]-medium": { family: "claude-fable-5[1m]", effort: "medium" },
-  "claude-fable-5[1m]-high": { family: "claude-fable-5[1m]", effort: "high" },
-  "claude-fable-5[1m]-xhigh": { family: "claude-fable-5[1m]", effort: "xhigh" },
-  "claude-fable-5[1m]-max": { family: "claude-fable-5[1m]", effort: "max" },
-  "claude-opus-5-low": { family: "claude-opus-5", effort: "low" },
-  "claude-opus-5-medium": { family: "claude-opus-5", effort: "medium" },
-  "claude-opus-5-high": { family: "claude-opus-5", effort: "high" },
-  "claude-opus-5-xhigh": { family: "claude-opus-5", effort: "xhigh" },
-  "claude-opus-5-max": { family: "claude-opus-5", effort: "max" },
-  "claude-opus-5[1m]-low": { family: "claude-opus-5[1m]", effort: "low" },
-  "claude-opus-5[1m]-medium": { family: "claude-opus-5[1m]", effort: "medium" },
-  "claude-opus-5[1m]-high": { family: "claude-opus-5[1m]", effort: "high" },
-  "claude-opus-5[1m]-xhigh": { family: "claude-opus-5[1m]", effort: "xhigh" },
-  "claude-opus-5[1m]-max": { family: "claude-opus-5[1m]", effort: "max" },
-  "claude-opus-4-8-low": { family: "claude-opus-4-8", effort: "low" },
-  "claude-opus-4-8-medium": { family: "claude-opus-4-8", effort: "medium" },
-  "claude-opus-4-8-high": { family: "claude-opus-4-8", effort: "high" },
-  "claude-opus-4-8-xhigh": { family: "claude-opus-4-8", effort: "xhigh" },
-  "claude-opus-4-8-max": { family: "claude-opus-4-8", effort: "max" },
-  "claude-opus-4-8[1m]-low": { family: "claude-opus-4-8[1m]", effort: "low" },
-  "claude-opus-4-8[1m]-medium": { family: "claude-opus-4-8[1m]", effort: "medium" },
-  "claude-opus-4-8[1m]-high": { family: "claude-opus-4-8[1m]", effort: "high" },
-  "claude-opus-4-8[1m]-xhigh": { family: "claude-opus-4-8[1m]", effort: "xhigh" },
-  "claude-opus-4-8[1m]-max": { family: "claude-opus-4-8[1m]", effort: "max" },
-  "claude-opus-4-6-low": { family: "claude-opus-4-6", effort: "low" },
-  "claude-opus-4-6-medium": { family: "claude-opus-4-6", effort: "medium" },
-  "claude-opus-4-6-high": { family: "claude-opus-4-6", effort: "high" },
-  "claude-opus-4-6-max": { family: "claude-opus-4-6", effort: "max" },
-  "claude-opus-4-6[1m]-low": { family: "claude-opus-4-6[1m]", effort: "low" },
-  "claude-opus-4-6[1m]-medium": { family: "claude-opus-4-6[1m]", effort: "medium" },
-  "claude-opus-4-6[1m]-high": { family: "claude-opus-4-6[1m]", effort: "high" },
-  "claude-opus-4-6[1m]-max": { family: "claude-opus-4-6[1m]", effort: "max" },
-  "claude-sonnet-4-6-low": { family: "claude-sonnet-4-6", effort: "low" },
-  "claude-sonnet-4-6-medium": { family: "claude-sonnet-4-6", effort: "medium" },
-  "claude-sonnet-4-6-high": { family: "claude-sonnet-4-6", effort: "high" },
-  "claude-sonnet-4-6[1m]-low": { family: "claude-sonnet-4-6[1m]", effort: "low" },
-  "claude-sonnet-4-6[1m]-medium": { family: "claude-sonnet-4-6[1m]", effort: "medium" },
-  "claude-sonnet-4-6[1m]-high": { family: "claude-sonnet-4-6[1m]", effort: "high" },
-  "claude-haiku-4-5-low": { family: "claude-haiku-4-5", effort: "low" },
-  "claude-haiku-4-5-medium": { family: "claude-haiku-4-5", effort: "medium" },
-  "claude-haiku-4-5-high": { family: "claude-haiku-4-5", effort: "high" }
-};
-const CODEX_MODE_TO_SELECTION = {
-  "gpt-5.6-sol-low": { family: "gpt-5.6-sol", effort: "low" },
-  "gpt-5.6-sol-medium": { family: "gpt-5.6-sol", effort: "medium" },
-  "gpt-5.6-sol-high": { family: "gpt-5.6-sol", effort: "high" },
-  "gpt-5.6-sol-xhigh": { family: "gpt-5.6-sol", effort: "xhigh" },
-  "gpt-5.6-sol-max": { family: "gpt-5.6-sol", effort: "max" },
-  "gpt-5.6-terra-low": { family: "gpt-5.6-terra", effort: "low" },
-  "gpt-5.6-terra-medium": { family: "gpt-5.6-terra", effort: "medium" },
-  "gpt-5.6-terra-high": { family: "gpt-5.6-terra", effort: "high" },
-  "gpt-5.6-terra-xhigh": { family: "gpt-5.6-terra", effort: "xhigh" },
-  "gpt-5.6-luna-low": { family: "gpt-5.6-luna", effort: "low" },
-  "gpt-5.6-luna-medium": { family: "gpt-5.6-luna", effort: "medium" },
-  "gpt-5.6-luna-high": { family: "gpt-5.6-luna", effort: "high" },
-  "gpt-5.6-luna-xhigh": { family: "gpt-5.6-luna", effort: "xhigh" },
-  "gpt-5.5-low": { family: "gpt-5.5", effort: "low" },
-  "gpt-5.5-medium": { family: "gpt-5.5", effort: "medium" },
-  "gpt-5.5-high": { family: "gpt-5.5", effort: "high" },
-  "gpt-5.5-xhigh": { family: "gpt-5.5", effort: "xhigh" },
-  "gpt-5.4-low": { family: "gpt-5.4", effort: "low" },
-  "gpt-5.4-medium": { family: "gpt-5.4", effort: "medium" },
-  "gpt-5.4-high": { family: "gpt-5.4", effort: "high" },
-  "gpt-5.4-xhigh": { family: "gpt-5.4", effort: "xhigh" },
-  "gpt-5.3-codex-low": { family: "gpt-5.3-codex", effort: "low" },
-  "gpt-5.3-codex-medium": { family: "gpt-5.3-codex", effort: "medium" },
-  "gpt-5.3-codex-high": { family: "gpt-5.3-codex", effort: "high" },
-  "gpt-5.3-codex-xhigh": { family: "gpt-5.3-codex", effort: "xhigh" },
-  "gpt-5.2-codex-low": { family: "gpt-5.2-codex", effort: "low" },
-  "gpt-5.2-codex-medium": { family: "gpt-5.2-codex", effort: "medium" },
-  "gpt-5.2-codex-high": { family: "gpt-5.2-codex", effort: "high" },
-  "gpt-5.2-codex-xhigh": { family: "gpt-5.2-codex", effort: "xhigh" },
-  "gpt-5.2-low": { family: "gpt-5.2", effort: "low" },
-  "gpt-5.2-medium": { family: "gpt-5.2", effort: "medium" },
-  "gpt-5.2-high": { family: "gpt-5.2", effort: "high" },
-  "gpt-5.2-xhigh": { family: "gpt-5.2", effort: "xhigh" },
-  "gpt-5.1-codex-max-low": { family: "gpt-5.1-codex-max", effort: "low" },
-  "gpt-5.1-codex-max-medium": { family: "gpt-5.1-codex-max", effort: "medium" },
-  "gpt-5.1-codex-max-high": { family: "gpt-5.1-codex-max", effort: "high" },
-  "gpt-5.1-codex-max-xhigh": { family: "gpt-5.1-codex-max", effort: "xhigh" },
-  "gpt-5.1-codex-mini-medium": { family: "gpt-5.1-codex-mini", effort: "medium" },
-  "gpt-5.1-codex-mini-high": { family: "gpt-5.1-codex-mini", effort: "high" }
-};
-function parseClaudeModelMode(mode) {
-  const entry = CLAUDE_MODE_TO_SELECTION[mode];
-  if (entry) return entry;
-  if (mode === MODEL_MODE_DEFAULT) return { family: MODEL_MODE_DEFAULT, effort: null };
-  return { family: mode, effort: null };
-}
-function parseCodexModelMode(mode) {
-  return CODEX_MODE_TO_SELECTION[mode] ?? { family: MODEL_MODE_DEFAULT, effort: "medium" };
-}
-const FeishuWebhookConfigSchema = z.z.object({
-  url: z.z.string().url(),
-  secret: z.z.string().optional(),
-  enabled: z.z.boolean()
-});
-z.z.object({
-  url: z.z.string().nullable(),
-  secret_set: z.z.boolean(),
-  enabled: z.z.boolean(),
-  lastTestedAt: z.z.number().nullable()
-});
-z.z.object({
-  feishu: FeishuWebhookConfigSchema.extend({
-    lastTestedAt: z.z.number().optional()
-  }).optional(),
-  feishuMention: FeishuWebhookConfigSchema.extend({
-    lastTestedAt: z.z.number().optional()
-  }).optional(),
-  /**
-   * The account owner's own Feishu identity (open_id `ou_…` or tenant
-   * user_id). When set, collaboration @ notifications sent to any owner's
-   * mention webhook render this user as a real `<at>` ping instead of
-   * plain text. The ping only fires if the user is in the bot's group.
-   */
-  feishuUserId: z.z.string().optional()
-});
-const MemorySourceSchema = z.z.enum(["manual", "message-pin"]);
-z.z.object({
-  id: z.z.string(),
-  content: z.z.string().min(1).max(8e3),
-  source: MemorySourceSchema,
-  sourceSessionId: z.z.string().nullable(),
-  sourceMessageId: z.z.string().nullable(),
-  archivedAt: z.z.number().nullable(),
-  createdAt: z.z.number(),
-  updatedAt: z.z.number()
-});
-z.z.object({
-  content: z.z.string().min(1).max(8e3),
-  source: MemorySourceSchema.optional().default("manual"),
-  sourceSessionId: z.z.string().optional(),
-  sourceMessageId: z.z.string().optional()
-});
-z.z.object({
-  content: z.z.string().min(1).max(8e3)
-});
-
 z.z.object({
   host: z.z.string(),
   platform: z.z.string(),
@@ -1150,141 +135,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 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));
-}
-function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
-  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.min(currentFailureCount, maxFailureCount);
-  return Math.round(Math.random() * maxDelayRet);
-}
-function createBackoff(opts) {
-  return async (callback) => {
-    let currentFailureCount = 0;
-    const minDelay = 250;
-    const maxDelay = 1e3;
-    const maxFailureCount = 50;
-    while (true) {
-      try {
-        return await callback();
-      } catch (e) {
-        if (currentFailureCount < maxFailureCount) {
-          currentFailureCount++;
-        }
-        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
-        await delay(waitForRequest);
-      }
-    }
-  };
-}
-let backoff = createBackoff();
-
 class AsyncLock {
   permits = 1;
   promiseResolverQueue = [];
@@ -1365,7 +215,7 @@ class InvalidateSync {
     this._pendings = [];
   };
   _doSync = async () => {
-    await backoff(async () => {
+    await time.backoff(async () => {
       if (this._stopped) {
         return;
       }
@@ -1385,7 +235,7 @@ class InvalidateSync {
   };
 }
 
-const diffsDir = path.join(configuration.happyHomeDir, "diffs");
+const diffsDir = path.join(logger.configuration.happyHomeDir, "diffs");
 function ensureDiffsDir() {
   if (!fs.existsSync(diffsDir)) {
     fs.mkdirSync(diffsDir, { recursive: true });
@@ -1409,9 +259,9 @@ function saveDiffRecords(sessionId, records) {
     }
     existing.push(...records);
     fs.writeFileSync(filePath, JSON.stringify(existing), "utf-8");
-    logger.debug(`[DiffStore] Saved ${records.length} record(s) for session ${sessionId}`);
+    logger.logger.debug(`[DiffStore] Saved ${records.length} record(s) for session ${sessionId}`);
   } catch (error) {
-    logger.warn(`[DiffStore] Failed to save diff records:`, error);
+    logger.logger.warn(`[DiffStore] Failed to save diff records:`, error);
   }
 }
 function getDiffDetail(sessionId, callId, filePath) {
@@ -1423,12 +273,12 @@ function getDiffDetail(sessionId, callId, filePath) {
     if (!record) return null;
     return { diff: record.diff, additions: record.additions, deletions: record.deletions };
   } catch (error) {
-    logger.warn(`[DiffStore] Failed to get diff detail:`, error);
+    logger.logger.warn(`[DiffStore] Failed to get diff detail:`, error);
     return null;
   }
 }
 
-const toolOutputsDir = path.join(configuration.happyHomeDir, "tool-outputs");
+const toolOutputsDir = path.join(logger.configuration.happyHomeDir, "tool-outputs");
 function ensureToolOutputsDir() {
   if (!fs.existsSync(toolOutputsDir)) {
     fs.mkdirSync(toolOutputsDir, { recursive: true });
@@ -1451,9 +301,9 @@ function saveToolOutputRecord(sessionId, record) {
     }
     existing.push(record);
     fs.writeFileSync(filePath, JSON.stringify(existing), "utf-8");
-    logger.debug(`[ToolOutputStore] Saved output for ${record.toolName} (${record.callId}) in session ${sessionId}`);
+    logger.logger.debug(`[ToolOutputStore] Saved output for ${record.toolName} (${record.callId}) in session ${sessionId}`);
   } catch (error) {
-    logger.warn("[ToolOutputStore] Failed to save tool output record:", error);
+    logger.logger.warn("[ToolOutputStore] Failed to save tool output record:", error);
   }
 }
 function getToolOutputRecord(sessionId, callId) {
@@ -1463,7 +313,7 @@ function getToolOutputRecord(sessionId, callId) {
     const records = JSON.parse(fs.readFileSync(filePath, "utf-8"));
     return records.find((record) => record.callId === callId) || null;
   } catch (error) {
-    logger.warn("[ToolOutputStore] Failed to get tool output record:", error);
+    logger.logger.warn("[ToolOutputStore] Failed to get tool output record:", error);
     return null;
   }
 }
@@ -1769,7 +619,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) => logger.logger.debug(msg, data));
   }
   /** Encryption key — exposed so feature modules can encrypt outbound non-RPC frames. */
   getEncryptionKey() {
@@ -1824,11 +674,11 @@ 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 = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
         return encryptedError;
       }
       const isPlaintext = typeof request.params !== "string";
-      const decryptedParams = isPlaintext ? request.params : decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(request.params));
+      const decryptedParams = isPlaintext ? request.params : logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.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 });
@@ -1839,7 +689,7 @@ class RpcHandlerManager {
         this.logger("[RPC] Handler returned pre-encrypted response", { method: request.method });
         return result.data;
       }
-      const encryptedResponse = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, result));
+      const encryptedResponse = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, result));
       this.logger("[RPC] Sending encrypted response", { method: request.method, responseLength: encryptedResponse.length });
       return encryptedResponse;
     } catch (error) {
@@ -1850,7 +700,7 @@ class RpcHandlerManager {
       if (typeof request.params !== "string") {
         return errorResponse;
       }
-      return encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+      return logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
     }
   }
   onSocketConnect(socket) {
@@ -2500,14 +1350,8 @@ No git repository was found from session cwd or workspace repo metadata. Session
   };
 }
 
-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-DvTsFaqR.cjs', document.baseURI).href))));
-function projectPath() {
-  const path = path$1.resolve(__dirname$1, "..");
-  return path;
-}
-
 function run$1(args, options) {
-  const RUNNER_PATH = path$1.resolve(path$1.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  const RUNNER_PATH = path$1.resolve(path$1.join(projectPath.projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
     const child = child_process.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -2541,7 +1385,7 @@ function toolsPackageName() {
   return `@zonease/happy-tools-${toolsPlatform()}`;
 }
 function legacyToolsDir() {
-  return path.resolve(projectPath(), "tools", "unpacked");
+  return path.resolve(projectPath.projectPath(), "tools", "unpacked");
 }
 let cached$1;
 function resolveToolsDir() {
@@ -2551,7 +1395,7 @@ function resolveToolsDir() {
 }
 function findToolsDir() {
   try {
-    const manifest = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-DvTsFaqR.cjs', document.baseURI).href))).resolve(`${toolsPackageName()}/package.json`);
+    const manifest = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('api-C7FyJfZ1.cjs', document.baseURI).href))).resolve(`${toolsPackageName()}/package.json`);
     return path.dirname(manifest);
   } catch {
   }
@@ -2625,10 +1469,10 @@ function ensureSpawnHelperExecutable() {
     for (const candidate of candidates) {
       if (!fs.existsSync(candidate) || (fs.statSync(candidate).mode & 73) !== 0) continue;
       fs.chmodSync(candidate, 493);
-      logger.debug(`[pty] restored exec bit on ${candidate}`);
+      logger.logger.debug(`[pty] restored exec bit on ${candidate}`);
     }
   } catch (err) {
-    logger.debug("[pty] could not check spawn-helper permissions:", err);
+    logger.logger.debug("[pty] could not check spawn-helper permissions:", err);
   }
 }
 function loadNodePty() {
@@ -2643,7 +1487,7 @@ function loadNodePty() {
     return mod;
   } catch (err) {
     loadError = err instanceof Error ? err : new Error(String(err));
-    logger.debug("[pty] node-pty unavailable:", loadError.message);
+    logger.logger.debug("[pty] node-pty unavailable:", loadError.message);
     return null;
   }
 }
@@ -2701,13 +1545,13 @@ function spawnShell(opts) {
   if (!mod) {
     const err = new Error(PTY_UNAVAILABLE);
     if (loadError) {
-      logger.debug("[pty] underlying load error:", loadError.stack ?? loadError.message);
+      logger.logger.debug("[pty] underlying load error:", loadError.stack ?? loadError.message);
     }
     throw err;
   }
   const shell = process.env.SHELL || (process.platform === "win32" ? "powershell.exe" : "bash");
   const cwd = opts.cwd ?? process.cwd();
-  const shellArgs = process.platform !== "win32" && isBashShell(shell) ? ["--rcfile", createHappyBashRc(), "-i"] : [];
+  const shellArgs = process.platform === "win32" ? [] : isBashShell(shell) ? ["--rcfile", createHappyBashRc(), "-i"] : ["-l", "-i"];
   const shellEnv = { ...process.env };
   delete shellEnv.NO_COLOR;
   delete shellEnv.NODE_DISABLE_COLORS;
@@ -2736,7 +1580,7 @@ function spawnShell(opts) {
   });
   const ptyId = node_crypto.randomUUID();
   ptys.set(ptyId, term);
-  logger.debug(`[pty] spawned ${ptyId} pid=${term.pid} shell=${shell} cols=${opts.cols} rows=${opts.rows} cwd=${cwd}`);
+  logger.logger.debug(`[pty] spawned ${ptyId} pid=${term.pid} shell=${shell} cols=${opts.cols} rows=${opts.rows} cwd=${cwd}`);
   return { ptyId, term };
 }
 function resizePty(ptyId, cols, rows) {
@@ -2746,7 +1590,7 @@ function resizePty(ptyId, cols, rows) {
     term.resize(cols, rows);
     return true;
   } catch (err) {
-    logger.debug(`[pty] resize ${ptyId} failed:`, err);
+    logger.logger.debug(`[pty] resize ${ptyId} failed:`, err);
     return false;
   }
 }
@@ -2757,7 +1601,7 @@ function writeToPty(ptyId, data) {
     term.write(data);
     return true;
   } catch (err) {
-    logger.debug(`[pty] write ${ptyId} failed:`, err);
+    logger.logger.debug(`[pty] write ${ptyId} failed:`, err);
     return false;
   }
 }
@@ -2768,7 +1612,7 @@ function closePty(ptyId) {
   try {
     term.kill();
   } catch (err) {
-    logger.debug(`[pty] kill ${ptyId} failed (likely already exited):`, err);
+    logger.logger.debug(`[pty] kill ${ptyId} failed (likely already exited):`, err);
   }
   return true;
 }
@@ -2801,7 +1645,7 @@ function runLoginShell(shell) {
       (error, stdout) => {
         const parsed = parseEnvDump(stdout ?? "");
         if (!parsed && error) {
-          logger.debug("[shellEnv] login shell did not return an environment:", error.message);
+          logger.logger.debug("[shellEnv] login shell did not return an environment:", error.message);
         }
         resolve(parsed);
       }
@@ -2822,7 +1666,7 @@ function resolveLoginShellEnv() {
     if (!shell) return process.env;
     const resolved = await runLoginShell(shell);
     if (!resolved) return process.env;
-    logger.debug(`[shellEnv] resolved ${Object.keys(resolved).length} variables from ${shell}`);
+    logger.logger.debug(`[shellEnv] resolved ${Object.keys(resolved).length} variables from ${shell}`);
     return { ...resolved, ...daemonOwnedEnv() };
   })();
   return cached;
@@ -2871,7 +1715,7 @@ const PTY_OUTPUT_FLUSH_MS = 16;
 const PTY_OUTPUT_FLUSH_BYTES = 32 * 1024;
 function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId) {
   rpcHandlerManager.registerHandler("bash", async (data) => {
-    logger.debug("Shell command request:", data.command);
+    logger.logger.debug("Shell command request:", data.command);
     if (data.cwd && data.cwd !== "/") {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -2883,21 +1727,25 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         cwd: data.cwd === "/" ? void 0 : data.cwd,
         timeout: data.timeout || 3e4,
         // Default 30 seconds timeout
+        // node's 1MB default kills the child and reports failure once
+        // output crosses it — the command has already succeeded by
+        // then, and the caller sees a truncated result with an error.
+        maxBuffer: 64 * 1024 * 1024,
         // launchd and systemd hand the daemon a bare PATH, so without
         // this a command that works when typed into the device terminal
         // fails here with "command not found".
         env: await resolveLoginShellEnv()
       };
-      logger.debug("Shell command executing...", { cwd: options.cwd, timeout: options.timeout });
+      logger.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...");
+      logger.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:", {
+      logger.logger.debug("Shell command result:", {
         success: true,
         exitCode: 0,
         stdoutLen: result.stdout.length,
@@ -2914,7 +1762,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
           exitCode: typeof execError.code === "number" ? execError.code : -1,
           error: "Command timed out"
         };
-        logger.debug("Shell command timed out:", {
+        logger.logger.debug("Shell command timed out:", {
           success: false,
           exitCode: result2.exitCode,
           error: "Command timed out"
@@ -2928,7 +1776,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         exitCode: typeof execError.code === "number" ? execError.code : 1,
         error: execError.message || "Command failed"
       };
-      logger.debug("Shell command failed:", {
+      logger.logger.debug("Shell command failed:", {
         success: false,
         exitCode: result.exitCode,
         error: result.error,
@@ -2939,40 +1787,40 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
     }
   });
   rpcHandlerManager.registerHandler("readFile", async (data) => {
-    logger.debug("Read file request:", data.path);
+    logger.logger.debug("Read file request:", data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
     try {
-      const buffer = await fs$2.readFile(data.path);
+      const buffer = await fs$1.readFile(data.path);
       const content = buffer.toString("base64");
       return { success: true, content };
     } catch (error) {
-      logger.debug("Failed to read file:", error);
+      logger.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);
+    logger.logger.debug("Write file request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
-      logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, validation.error);
+      logger.logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, validation.error);
       return { success: false, error: validation.error };
     }
     if (!isWritableForSession(absPath)) {
-      logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
+      logger.logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
       return { success: false, error: `Path '${absPath}' is on the system write deny-list` };
     }
     try {
       const buf = Buffer.from(data.content, "base64");
-      await fs$2.writeFile(absPath, buf);
-      logger.debug("[writeFile] path=%s bytes=%d ok=%s", absPath, buf.length, true);
+      await fs$1.writeFile(absPath, buf);
+      logger.logger.debug("[writeFile] path=%s bytes=%d ok=%s", absPath, buf.length, true);
       return { success: true, bytesWritten: buf.length };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to write file";
-      logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, message);
+      logger.logger.debug("[writeFile] path=%s ok=%s reason=%s", absPath, false, message);
       return { success: false, error: message };
     }
   });
@@ -3001,10 +1849,10 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       return { success: false, error: `Path '${paths.absolutePath}' is on the system write deny-list` };
     }
     try {
-      await fs$2.mkdir(paths.directory, { recursive: true });
-      await fs$2.rm(paths.tempAbsolutePath, { force: true });
-      await fs$2.rm(paths.absolutePath, { force: true });
-      await fs$2.writeFile(paths.tempAbsolutePath, Buffer.alloc(0));
+      await fs$1.mkdir(paths.directory, { recursive: true });
+      await fs$1.rm(paths.tempAbsolutePath, { force: true });
+      await fs$1.rm(paths.absolutePath, { force: true });
+      await fs$1.writeFile(paths.tempAbsolutePath, Buffer.alloc(0));
       return {
         success: true,
         relativePath: paths.relativePath,
@@ -3033,12 +1881,12 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
     }
     try {
       const chunk = Buffer.from(data.chunkBase64, "base64");
-      const current = await fs$2.stat(paths.tempAbsolutePath).catch(() => null);
+      const current = await fs$1.stat(paths.tempAbsolutePath).catch(() => null);
       const currentSize = current?.size ?? 0;
       if (currentSize + chunk.length > MAX_SESSION_UPLOAD_FILE_BYTES) {
         return { success: false, error: "File exceeds 100MB limit" };
       }
-      await fs$2.appendFile(paths.tempAbsolutePath, chunk);
+      await fs$1.appendFile(paths.tempAbsolutePath, chunk);
       return {
         success: true,
         relativePath: paths.relativePath,
@@ -3074,11 +1922,11 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       return { success: false, error: `Path '${paths.absolutePath}' is on the system write deny-list` };
     }
     try {
-      const info = await fs$2.stat(paths.tempAbsolutePath);
+      const info = await fs$1.stat(paths.tempAbsolutePath);
       if (info.size !== data.fileSize) {
         return { success: false, error: `Upload size mismatch: expected ${data.fileSize}, got ${info.size}` };
       }
-      await fs$2.rename(paths.tempAbsolutePath, paths.absolutePath);
+      await fs$1.rename(paths.tempAbsolutePath, paths.absolutePath);
       return {
         success: true,
         relativePath: paths.relativePath,
@@ -3096,14 +1944,14 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         uploadId: data.uploadId,
         fileName: data.fileName
       });
-      await fs$2.rm(paths.tempAbsolutePath, { force: true });
+      await fs$1.rm(paths.tempAbsolutePath, { force: true });
       return { success: true };
     } catch (error) {
       return { success: false, error: error instanceof Error ? error.message : "Failed to abort upload" };
     }
   });
   rpcHandlerManager.registerHandler("rename", async (data) => {
-    logger.debug("Rename request:", data.from, "->", data.to);
+    logger.logger.debug("Rename request:", data.from, "->", data.to);
     const absFrom = path$1.resolve(workingDirectory, data.from);
     const absTo = path$1.resolve(workingDirectory, data.to);
     const fromValidation = validatePath(data.from, workingDirectory);
@@ -3115,68 +1963,68 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       return { success: false, error: toValidation.error };
     }
     if (!isWritableForSession(absFrom)) {
-      logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
+      logger.logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
       return { success: false, error: `Path '${absFrom}' is on the system write deny-list` };
     }
     if (!isWritableForSession(absTo)) {
-      logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
+      logger.logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
       return { success: false, error: `Path '${absTo}' is on the system write deny-list` };
     }
     try {
-      await fs$2.rename(absFrom, absTo);
-      logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, true);
+      await fs$1.rename(absFrom, absTo);
+      logger.logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, true);
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to rename";
-      logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
+      logger.logger.info("[rename] %s -> %s ok=%s", absFrom, absTo, false);
       return { success: false, error: message };
     }
   });
   rpcHandlerManager.registerHandler("deleteFile", async (data) => {
-    logger.debug("Delete file request:", data.path);
+    logger.logger.debug("Delete file request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
     if (!isWritableForSession(absPath)) {
-      logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
+      logger.logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
       return { success: false, error: `Path '${absPath}' is on the system write deny-list` };
     }
     try {
-      const st = await fs$2.lstat(absPath);
+      const st = await fs$1.lstat(absPath);
       if (st.isDirectory()) {
-        logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, "is directory");
+        logger.logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, "is directory");
         return { success: false, error: "Not a file, use deleteDirectory" };
       }
-      await fs$2.unlink(absPath);
-      logger.info("[deleteFile] path=%s ok=%s", absPath, true);
+      await fs$1.unlink(absPath);
+      logger.logger.info("[deleteFile] path=%s ok=%s", absPath, true);
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to delete file";
-      logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, message);
+      logger.logger.info("[deleteFile] path=%s ok=%s reason=%s", absPath, false, message);
       return { success: false, error: message };
     }
   });
   rpcHandlerManager.registerHandler("deleteDirectory", async (data) => {
-    logger.debug("Delete directory request:", data.path);
+    logger.logger.debug("Delete directory request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
     if (!isWritableForSession(absPath)) {
-      logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
+      logger.logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
       return { success: false, error: `Path '${absPath}' is on the system write deny-list` };
     }
     try {
-      const top = await fs$2.lstat(absPath);
+      const top = await fs$1.lstat(absPath);
       if (!top.isDirectory()) {
-        logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, "not a directory");
+        logger.logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, "not a directory");
         return { success: false, error: "Not a directory" };
       }
       async function countEntries(dir) {
-        const entries = await fs$2.readdir(dir, { withFileTypes: true });
+        const entries = await fs$1.readdir(dir, { withFileTypes: true });
         let n = 0;
         for (const entry of entries) {
           n += 1;
@@ -3187,70 +2035,70 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         return n;
       }
       const deletedCount = await countEntries(absPath);
-      await fs$2.rm(absPath, { recursive: true, force: false });
-      logger.info("[deleteDirectory] path=%s deletedCount=%d ok=%s", absPath, deletedCount, true);
+      await fs$1.rm(absPath, { recursive: true, force: false });
+      logger.logger.info("[deleteDirectory] path=%s deletedCount=%d ok=%s", absPath, deletedCount, true);
       return { success: true, deletedCount };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to delete directory";
-      logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, message);
+      logger.logger.info("[deleteDirectory] path=%s ok=%s reason=%s", absPath, false, message);
       return { success: false, error: message };
     }
   });
   rpcHandlerManager.registerHandler("createFile", async (data) => {
-    logger.debug("Create file request:", data.path);
+    logger.logger.debug("Create file request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
     if (!isWritableForSession(absPath)) {
-      logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
+      logger.logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
       return { success: false, error: `Path '${absPath}' is on the system write deny-list` };
     }
     try {
       const buf = data.content ? Buffer.from(data.content, "base64") : Buffer.alloc(0);
-      await fs$2.writeFile(absPath, buf, { flag: "wx" });
-      logger.info("[createFile] path=%s bytes=%d ok=%s", absPath, buf.length, true);
+      await fs$1.writeFile(absPath, buf, { flag: "wx" });
+      logger.logger.info("[createFile] path=%s bytes=%d ok=%s", absPath, buf.length, true);
       return { success: true };
     } catch (error) {
       const errno = error.code;
       if (errno === "EEXIST") {
-        logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, "file exists");
+        logger.logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, "file exists");
         return { success: false, error: "File exists" };
       }
       const message = error instanceof Error ? error.message : "Failed to create file";
-      logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, message);
+      logger.logger.info("[createFile] path=%s ok=%s reason=%s", absPath, false, message);
       return { success: false, error: message };
     }
   });
   rpcHandlerManager.registerHandler("createDirectory", async (data) => {
-    logger.debug("Create directory request:", data.path);
+    logger.logger.debug("Create directory request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
       return { success: false, error: validation.error };
     }
     if (!isWritableForSession(absPath)) {
-      logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
+      logger.logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, "system path is read-only");
       return { success: false, error: `Path '${absPath}' is on the system write deny-list` };
     }
     try {
-      await fs$2.mkdir(absPath);
-      logger.info("[createDirectory] path=%s ok=%s", absPath, true);
+      await fs$1.mkdir(absPath);
+      logger.logger.info("[createDirectory] path=%s ok=%s", absPath, true);
       return { success: true };
     } catch (error) {
       const errno = error.code;
       if (errno === "EEXIST") {
-        logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, "directory exists");
+        logger.logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, "directory exists");
         return { success: false, error: "Directory exists" };
       }
       const message = error instanceof Error ? error.message : "Failed to create directory";
-      logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, message);
+      logger.logger.info("[createDirectory] path=%s ok=%s reason=%s", absPath, false, message);
       return { success: false, error: message };
     }
   });
   rpcHandlerManager.registerHandler("listDirectory", async (data) => {
-    logger.debug("List directory request:", data.path);
+    logger.logger.debug("List directory request:", data.path);
     const absPath = path$1.resolve(workingDirectory, data.path);
     const validation = validatePath(data.path, workingDirectory);
     if (!validation.valid) {
@@ -3258,7 +2106,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
     }
     const hideSystem = data.hideSystem !== false;
     try {
-      const rawEntries = await fs$2.readdir(absPath, { withFileTypes: true });
+      const rawEntries = await fs$1.readdir(absPath, { withFileTypes: true });
       const noSymlinks = rawEntries.filter((e) => !e.isSymbolicLink());
       const visible = hideSystem ? noSymlinks.filter((e) => !isSystemNoise(e.name)) : noSymlinks;
       const entries = await Promise.all(
@@ -3268,11 +2116,11 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
           let size;
           let mtime;
           try {
-            const stats = await fs$2.stat(fullPath);
+            const stats = await fs$1.stat(fullPath);
             size = stats.size;
             mtime = stats.mtime.getTime();
           } catch (error) {
-            logger.debug(`Failed to stat ${fullPath}:`, error);
+            logger.logger.debug(`Failed to stat ${fullPath}:`, error);
           }
           return { name: entry.name, path: fullPath, type, size, mtime };
         })
@@ -3284,19 +2132,19 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       });
       return { success: true, entries };
     } catch (error) {
-      logger.debug("Failed to list directory:", error);
+      logger.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);
+    logger.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) {
       try {
-        const stats = await fs$2.stat(path);
+        const stats = await fs$1.stat(path);
         const node = {
           name,
           path,
@@ -3305,12 +2153,12 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
           modified: stats.mtime.getTime()
         };
         if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await fs$2.readdir(path, { withFileTypes: true });
+          const entries = await fs$1.readdir(path, { withFileTypes: true });
           const children = [];
           await Promise.all(
             entries.map(async (entry) => {
               if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${path$1.join(path, entry.name)}`);
+                logger.logger.debug(`Skipping symlink: ${path$1.join(path, entry.name)}`);
                 return;
               }
               const childPath = path$1.join(path, entry.name);
@@ -3329,7 +2177,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         }
         return node;
       } catch (error) {
-        logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
+        logger.logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
         return null;
       }
     }
@@ -3344,12 +2192,12 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       }
       return { success: true, tree };
     } catch (error) {
-      logger.debug("Failed to get directory tree:", error);
+      logger.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);
+    logger.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
     if (data.cwd) {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -3365,7 +2213,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         stderr: result.stderr.toString()
       };
     } catch (error) {
-      logger.debug("Failed to run ripgrep:", error);
+      logger.logger.debug("Failed to run ripgrep:", error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Failed to run ripgrep"
@@ -3373,7 +2221,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
     }
   });
   rpcHandlerManager.registerHandler("difftastic", async (data) => {
-    logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
+    logger.logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
     if (data.cwd) {
       const validation = validatePath(data.cwd, workingDirectory);
       if (!validation.valid) {
@@ -3389,7 +2237,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
         stderr: result.stderr.toString()
       };
     } catch (error) {
-      logger.debug("Failed to run difftastic:", error);
+      logger.logger.debug("Failed to run difftastic:", error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Failed to run difftastic"
@@ -3398,7 +2246,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
   });
   if (sessionId) {
     rpcHandlerManager.registerHandler("getDiffDetail", async (data) => {
-      logger.debug("getDiffDetail request:", data.callId, data.filePath);
+      logger.logger.debug("getDiffDetail request:", data.callId, data.filePath);
       const result = getDiffDetail(sessionId, data.callId, data.filePath);
       if (!result) {
         return { success: false, error: "not_found" };
@@ -3411,7 +2259,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       };
     });
     rpcHandlerManager.registerHandler("getToolOutput", async (data) => {
-      logger.debug("getToolOutput request:", data.callId);
+      logger.logger.debug("getToolOutput request:", data.callId);
       const record = getToolOutputRecord(sessionId, data.callId);
       if (!record) {
         return { success: false, error: "not_found" };
@@ -3424,19 +2272,24 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       };
     });
     const outboundStates = /* @__PURE__ */ new Map();
-    const emitEncrypted = (event, payload) => {
+    const emitEncrypted = (event, payload, reliable = false) => {
       const socket = rpcHandlerManager.getSocket();
       if (!socket || !socket.connected) {
         return;
       }
       const envelope = { sessionId: payload.sessionId, ptyId: payload.ptyId };
-      if (event === "pty-output" && typeof payload.data === "string") {
+      if (reliable) envelope.reliable = true;
+      if (event === "pty-output" && payload.data !== void 0) {
         const key = rpcHandlerManager.getEncryptionKey();
         const variant = rpcHandlerManager.getEncryptionVariant();
-        envelope.data = encodeBase64(encrypt(key, variant, payload.data));
+        envelope.data = logger.encodeBase64(logger.encrypt(key, variant, payload.data));
       } else if (event === "pty-exit" && typeof payload.exitCode === "number") {
         envelope.exitCode = payload.exitCode;
       }
+      if (reliable) {
+        socket.emit(event, envelope);
+        return;
+      }
       socket.volatile.emit(event, envelope);
     };
     const splitOnUtf8Boundary = (merged) => {
@@ -3493,7 +2346,73 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       outboundStates.delete(ptyId);
     };
     rpcHandlerManager.registerHandler("pty-start", async (data) => {
-      logger.debug("[pty-start] request", { cols: data.cols, rows: data.rows, cwd: data.cwd });
+      logger.logger.debug("[pty-start] request", { cols: data.cols, rows: data.rows, cwd: data.cwd, exec: !!data.exec });
+      if (data.exec) {
+        const execId = node_crypto.randomUUID();
+        const child = child_process.spawn(process.env.SHELL || "/bin/sh", ["-c", data.exec.command], {
+          cwd: data.cwd,
+          env: await resolveLoginShellEnv(),
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const killTimer = setTimeout(() => child.kill("SIGTERM"), data.exec.timeoutMs ?? 3e5);
+        child.stdout?.pause();
+        child.stderr?.pause();
+        setImmediate(() => {
+          child.stdout?.resume();
+          child.stderr?.resume();
+        });
+        const pending = { stdout: [], stderr: [] };
+        let pendingBytes = 0;
+        let frameCount = 0;
+        let flushTimer = null;
+        const flushExec = () => {
+          if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+          }
+          pendingBytes = 0;
+          frameCount++;
+          for (const stream of ["stdout", "stderr"]) {
+            if (pending[stream].length === 0) continue;
+            const chunk = Buffer.concat(pending[stream]);
+            pending[stream] = [];
+            emitEncrypted("pty-output", {
+              sessionId,
+              ptyId: execId,
+              data: { stream, chunk: chunk.toString("base64") }
+            }, true);
+          }
+        };
+        for (const [stream, source] of [["stdout", child.stdout], ["stderr", child.stderr]]) {
+          source?.on("data", (chunk) => {
+            pending[stream].push(chunk);
+            pendingBytes += chunk.length;
+            if (pendingBytes >= PTY_OUTPUT_FLUSH_BYTES) {
+              flushExec();
+              return;
+            }
+            if (!flushTimer) flushTimer = setTimeout(flushExec, PTY_OUTPUT_FLUSH_MS);
+          });
+        }
+        child.on("close", (code, signal) => {
+          clearTimeout(killTimer);
+          logger.logger.debug(`[exec] close code=${code} signal=${signal} pending=${pendingBytes}`);
+          flushExec();
+          logger.logger.debug(`[exec] flushed ${frameCount} frames, emitting exit`);
+          emitEncrypted("pty-exit", { sessionId, ptyId: execId, exitCode: code ?? (signal ? 143 : 1) }, true);
+        });
+        child.on("error", (error) => {
+          clearTimeout(killTimer);
+          emitEncrypted("pty-output", {
+            sessionId,
+            ptyId: execId,
+            data: { stream: "stderr", chunk: Buffer.from(`${error.message}
+`).toString("base64") }
+          }, true);
+          emitEncrypted("pty-exit", { sessionId, ptyId: execId, exitCode: 1 }, true);
+        });
+        return { ok: true, ptyId: execId };
+      }
       try {
         const { ptyId, term } = spawnShell({
           cols: data.cols,
@@ -3515,7 +2434,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
           }
         });
         const exitDispose = term.onExit(({ exitCode }) => {
-          logger.debug(`[pty-exit] ${ptyId} exitCode=${exitCode}`);
+          logger.logger.debug(`[pty-exit] ${ptyId} exitCode=${exitCode}`);
           flushPtyOutput(ptyId);
           emitEncrypted("pty-exit", { sessionId, ptyId, exitCode });
           cleanupPtyState(ptyId);
@@ -3532,27 +2451,27 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         if (message === PTY_UNAVAILABLE) {
-          logger.debug("[pty-start] node-pty unavailable on this host");
+          logger.logger.debug("[pty-start] node-pty unavailable on this host");
           return { ok: false, error: PTY_UNAVAILABLE };
         }
-        logger.debug("[pty-start] spawn failed:", message);
+        logger.logger.debug("[pty-start] spawn failed:", message);
         return { ok: false, error: message };
       }
     });
     rpcHandlerManager.registerHandler("pty-resize", async (data) => {
-      logger.debug(`[pty-resize] ${data.ptyId} ${data.cols}x${data.rows}`);
+      logger.logger.debug(`[pty-resize] ${data.ptyId} ${data.cols}x${data.rows}`);
       const ok = resizePty(data.ptyId, data.cols, data.rows);
       return { ok };
     });
     rpcHandlerManager.registerHandler("pty-close", async (data) => {
-      logger.debug(`[pty-close] ${data.ptyId}`);
+      logger.logger.debug(`[pty-close] ${data.ptyId}`);
       cleanupPtyState(data.ptyId);
       const ok = closePty(data.ptyId);
       return { ok };
     });
     rpcHandlerManager.registerSocketEvent("pty-input", (envelope) => {
       if (!envelope || typeof envelope !== "object") {
-        logger.debug("[pty-input] unexpected envelope shape, dropping");
+        logger.logger.debug("[pty-input] unexpected envelope shape, dropping");
         return;
       }
       if (envelope.sessionId !== sessionId) return;
@@ -3561,14 +2480,14 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory, sessionId)
       try {
         const key = rpcHandlerManager.getEncryptionKey();
         const variant = rpcHandlerManager.getEncryptionVariant();
-        const decoded = decrypt(key, variant, decodeBase64(envelope.data));
+        const decoded = logger.decrypt(key, variant, logger.decodeBase64(envelope.data));
         if (typeof decoded !== "string") {
-          logger.debug("[pty-input] decrypted payload not a string, dropping");
+          logger.logger.debug("[pty-input] decrypted payload not a string, dropping");
           return;
         }
         writeToPty(envelope.ptyId, decoded);
       } catch (err) {
-        logger.debug("[pty-input] decrypt/dispatch failed:", err);
+        logger.logger.debug("[pty-input] decrypt/dispatch failed:", err);
       }
     });
   }
@@ -3836,7 +2755,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   initialTitleSet = false;
   queueOrDeliverUserMessage(message, source) {
     if (isHumanOnlyMessageRecord(message)) {
-      logger.debug(`[API] Ignoring human-only collaboration message from ${source}`);
+      logger.logger.debug(`[API] Ignoring human-only collaboration message from ${source}`);
       return false;
     }
     if (this.pendingMessageCallback) {
@@ -3861,7 +2780,7 @@ 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) => logger.logger.debug(msg, data)
     });
     registerCommonHandlers(this.rpcHandlerManager, this.metadata.path, this.sessionId);
     this.autoReviewGuard = this.createAutoReviewGuard();
@@ -3878,7 +2797,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       }
     });
     this.sendSync = new InvalidateSync(() => this.flushOutbox());
-    this.socket = socket_ioClient.io(configuration.serverUrl, {
+    this.socket = socket_ioClient.io(logger.configuration.serverUrl, {
       auth: {
         token: this.token,
         clientType: "session-scoped",
@@ -3895,18 +2814,18 @@ class ApiSessionClient extends node_events.EventEmitter {
       autoConnect: false
     });
     this.socket.on("connect", () => {
-      logger.debug("Socket connected successfully");
+      logger.logger.debug("Socket connected successfully");
       this.rpcHandlerManager.onSocketConnect(this.socket);
     });
     this.socket.on("rpc-request", async (data, callback) => {
       callback(await this.rpcHandlerManager.handleRequest(data));
     });
     this.socket.on("disconnect", (reason) => {
-      logger.debug("[API] Socket disconnected:", reason);
+      logger.logger.debug("[API] Socket disconnected:", reason);
       this.rpcHandlerManager.onSocketDisconnect();
     });
     this.socket.on("connect_error", (error) => {
-      logger.debug("[API] Socket connection error:", error);
+      logger.logger.debug("[API] Socket connection error:", error);
       this.rpcHandlerManager.onSocketDisconnect();
     });
     this.socket.on("ephemeral", (payload) => {
@@ -3939,20 +2858,20 @@ class ApiSessionClient extends node_events.EventEmitter {
         });
       };
       try {
-        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        logger.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
         if (!data.body) {
-          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          logger.logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
           return;
         }
         if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
-          const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.message.content.c));
-          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          const body = logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(data.body.message.content.c));
+          logger.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
           const userResult = UserMessageSchema.safeParse(body);
           if (userResult.success) {
             if (isHumanOnlyMessageRecord(body)) {
-              logger.debug("[SOCKET] [UPDATE] Ignoring human-only collaboration message");
+              logger.logger.debug("[SOCKET] [UPDATE] Ignoring human-only collaboration message");
             } else if (userResult.data.meta?.sentFrom === "cli") {
-              logger.debug("[SOCKET] [UPDATE] Ignoring echo of CLI-originated user message");
+              logger.logger.debug("[SOCKET] [UPDATE] Ignoring echo of CLI-originated user message");
             } else {
               this.maybeSetInitialTitleFromUserText(userResult.data.content.text);
               if (this.queueOrDeliverUserMessage(userResult.data, "socket-update")) {
@@ -3971,22 +2890,22 @@ class ApiSessionClient extends node_events.EventEmitter {
           if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
             this.metadata = adoptServerSessionMetadata(
               this.metadata,
-              decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.metadata.value))
+              logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(data.body.metadata.value))
             );
             this.metadataVersion = data.body.metadata.version;
             this.syncedModel = this.metadata?.model?.trim() || null;
           }
           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 ? logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.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`);
+          logger.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 });
+        logger.logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
         if (data?.body?.t === "new-message") {
           const errorMessage = error instanceof Error ? error.message : String(error);
           emitMessageReceipt({
@@ -4000,7 +2919,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       }
     });
     this.socket.on("error", (error) => {
-      logger.debug("[API] Socket error:", error);
+      logger.logger.debug("[API] Socket error:", error);
     });
     this.socket.connect();
   }
@@ -4015,7 +2934,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorSubmit(body) {
     const response = await axios.post(
-      `${configuration.serverUrl}/v1/orchestrator/submit`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/submit`,
       body,
       {
         headers: this.orchestratorHeaders(),
@@ -4026,7 +2945,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorGetContext() {
     const response = await axios.get(
-      `${configuration.serverUrl}/v1/orchestrator/context`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/context`,
       {
         headers: this.orchestratorHeaders(),
         timeout: 3e4
@@ -4036,7 +2955,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorGetRun(runId, includeTasks = true) {
     const response = await axios.get(
-      `${configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}`,
       {
         headers: this.orchestratorHeaders(),
         params: { includeTasks },
@@ -4047,7 +2966,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorListRuns(query = {}) {
     const response = await axios.get(
-      `${configuration.serverUrl}/v1/orchestrator/runs`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/runs`,
       {
         headers: this.orchestratorHeaders(),
         params: query,
@@ -4058,7 +2977,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorPend(runId, query = {}) {
     const response = await axios.get(
-      `${configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}/pend`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}/pend`,
       {
         headers: this.orchestratorHeaders(),
         params: query,
@@ -4069,7 +2988,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorSendMessage(body) {
     const response = await axios.post(
-      `${configuration.serverUrl}/v1/orchestrator/tasks/${encodeURIComponent(body.taskId)}/send-message`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/tasks/${encodeURIComponent(body.taskId)}/send-message`,
       {
         message: body.message
       },
@@ -4082,7 +3001,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async orchestratorCancel(runId, body) {
     const response = await axios.post(
-      `${configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}/cancel`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/runs/${encodeURIComponent(runId)}/cancel`,
       body ?? {},
       {
         headers: this.orchestratorHeaders(),
@@ -4321,7 +3240,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     for (let offset = 0; offset < batch.length; offset += OUTBOX_FLUSH_BATCH_SIZE) {
       const chunk = batch.slice(offset, offset + OUTBOX_FLUSH_BATCH_SIZE);
       await axios.post(
-        `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+        `${logger.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
         {
           messages: chunk
         },
@@ -4341,7 +3260,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * This is the parallel reliable path alongside the fast-path socket emit.
    */
   enqueueMessage(content) {
-    const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const encrypted = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, content));
     this.pendingOutbox.push({
       content: encrypted,
       localId: node_crypto.randomUUID()
@@ -4358,7 +3277,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       const messages = await this.fetchRecentReviewMessages(80);
       return messages.some((message) => message.role === "user" && normalizeAutoReviewTextForDedupe(message.text) === normalized);
     } catch (error) {
-      logger.debug("[AUTO_REVIEW] Failed to check duplicate follow-up messages:", error);
+      logger.logger.debug("[AUTO_REVIEW] Failed to check duplicate follow-up messages:", error);
       return false;
     }
   }
@@ -4380,9 +3299,9 @@ class ApiSessionClient extends node_events.EventEmitter {
         displayText: trimmed
       }
     };
-    const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const encrypted = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, content));
     await axios.post(
-      `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/send`,
+      `${logger.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/send`,
       {
         content: encrypted,
         localId,
@@ -4399,7 +3318,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async fetchRecentReviewMessages(limit = 200) {
     const response = await axios.get(
-      `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+      `${logger.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
       {
         params: { limit },
         headers: { "Authorization": `Bearer ${this.token}` },
@@ -4412,7 +3331,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       const encrypted = row?.content?.t === "encrypted" ? row.content.c : null;
       if (!encrypted) continue;
       try {
-        const decrypted = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(encrypted));
+        const decrypted = logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(encrypted));
         if (isHumanOnlyMessageRecord(decrypted)) {
           continue;
         }
@@ -4420,7 +3339,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         const text = extractPlainTextForAutoReview(decrypted);
         if (text) result.push({ role, text });
       } catch (error) {
-        logger.debug("[AUTO_REVIEW] Failed to decrypt review history message:", error);
+        logger.logger.debug("[AUTO_REVIEW] Failed to decrypt review history message:", error);
       }
     }
     return result;
@@ -4431,13 +3350,13 @@ class ApiSessionClient extends node_events.EventEmitter {
         const isSidechain = body.isSidechain === true;
         this.sendUsageData(body.message.usage, isSidechain ? void 0 : body.message.model);
       } catch (error) {
-        logger.debug("[SOCKET] Failed to send usage data:", error);
+        logger.logger.debug("[SOCKET] Failed to send usage data:", error);
       }
     }
     if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
       this.updateMetadata((metadata) => {
         if (metadata.summaryPinned) {
-          logger.debug("[SOCKET] Skipping summary update: title is pinned by user");
+          logger.logger.debug("[SOCKET] Skipping summary update: title is pinned by user");
           return metadata;
         }
         const newSummary = body.summary;
@@ -4445,7 +3364,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         const dirName = metadata.path?.split(/[\\/]/).filter(Boolean).pop();
         const isNewSummaryDirName = dirName && newSummary === dirName;
         if (isNewSummaryDirName && currentSummary && currentSummary !== dirName) {
-          logger.debug("[SOCKET] Skipping summary update: new summary is directory name but current title is better", {
+          logger.logger.debug("[SOCKET] Skipping summary update: new summary is directory name but current title is better", {
             newSummary,
             currentSummary,
             dirName
@@ -4471,18 +3390,18 @@ class ApiSessionClient extends node_events.EventEmitter {
     if (content.role === "agent") {
       this.autoReviewGuard.onAgentText(extractPlainTextForAutoReview(content), String(body.uuid || node_crypto.randomUUID()));
     }
-    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
+    logger.logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
     this.enqueueMessage(content);
     this.postSendProcessing(body);
   }
   async sendClaudeSessionMessageBatch(messages, mode = "append") {
     if (!this.socket.connected) {
-      logger.debug("[API] Socket not connected, cannot send Claude session message batch. Messages will be lost:", { count: messages.length });
+      logger.logger.debug("[API] Socket not connected, cannot send Claude session message batch. Messages will be lost:", { count: messages.length });
       return { result: "error" };
     }
     const payload = messages.map((item) => {
       const content = this.buildMessageContent(item.message);
-      const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+      const encrypted = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, content));
       return {
         message: encrypted,
         localId: item.localId ?? null
@@ -4537,7 +3456,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         sentFrom: "cli"
       }
     };
-    logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
+    logger.logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
     this.autoReviewGuard.onAgentText(normalizeReviewableAgentText(body), `${provider}-${Date.now()}`);
     this.enqueueMessage(content);
   }
@@ -4548,17 +3467,17 @@ class ApiSessionClient extends node_events.EventEmitter {
    */
   async sendBackfillBatch(messages, mode = "append") {
     if (!this.socket.connected) {
-      logger.debug(`[API] Socket not connected, cannot send backfill batch (${messages.length} messages)`);
+      logger.logger.debug(`[API] Socket not connected, cannot send backfill batch (${messages.length} messages)`);
       return { result: "error" };
     }
     const payload = messages.map((item) => {
-      const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, item.content));
+      const encrypted = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, item.content));
       return {
         message: encrypted,
         localId: item.localId
       };
     });
-    logger.debug(`[SOCKET] Sending backfill batch: ${messages.length} messages, mode=${mode}`);
+    logger.logger.debug(`[SOCKET] Sending backfill batch: ${messages.length} messages, mode=${mode}`);
     const response = await this.socket.emitWithAck("message-batch", {
       sid: this.sessionId,
       messages: payload,
@@ -4575,7 +3494,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         data: event
       }
     };
-    const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const encrypted = logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, content));
     this.socket.emit("message", {
       sid: this.sessionId,
       message: encrypted
@@ -4585,8 +3504,8 @@ class ApiSessionClient extends node_events.EventEmitter {
    * Send a ping message to keep the connection alive
    */
   keepAlive(thinking, mode) {
-    if (isDebug()) {
-      logger.debug(`[API] Sending keep alive message: ${thinking}`);
+    if (logger.isDebug()) {
+      logger.logger.debug(`[API] Sending keep alive message: ${thinking}`);
     }
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
@@ -4605,7 +3524,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * Send a generic usage report to the server for any provider
    */
   sendUsageReport(report) {
-    logger.debugLargeJson("[SOCKET] Sending usage report:", report);
+    logger.logger.debugLargeJson("[SOCKET] Sending usage report:", report);
     this.socket.emit("usage-report", {
       key: report.key,
       sessionId: this.sessionId,
@@ -4613,7 +3532,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       cost: report.cost
     }, (response) => {
       if (!response?.success) {
-        logger.debug("[SOCKET] Usage report rejected by server", {
+        logger.logger.debug("[SOCKET] Usage report rejected by server", {
           key: report.key,
           sessionId: this.sessionId,
           error: response?.error || "unknown error"
@@ -4700,22 +3619,22 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   async updateMetadataAsync(handler) {
     await this.metadataLock.inLock(async () => {
-      await backoff(async () => {
+      await time.backoff(async () => {
         const base = this.metadata;
         if (!base) {
-          logger.debug("[API] skipping metadata update: no local metadata to build on");
+          logger.logger.debug("[API] skipping metadata update: no local metadata to build on");
           return;
         }
         const updated = adoptServerSessionMetadata(base, handler(base));
-        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: logger.encodeBase64(logger.encrypt(this.encryptionKey, this.encryptionVariant, updated)) });
         if (answer.result === "success") {
-          this.metadata = adoptServerSessionMetadata(this.metadata, decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata)));
+          this.metadata = adoptServerSessionMetadata(this.metadata, logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(answer.metadata)));
           this.metadataVersion = answer.version;
           this.syncedModel = this.metadata?.model?.trim() || null;
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.metadataVersion) {
             this.metadataVersion = answer.version;
-            this.metadata = adoptServerSessionMetadata(this.metadata, decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata)));
+            this.metadata = adoptServerSessionMetadata(this.metadata, logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(answer.metadata)));
             this.syncedModel = this.metadata?.model?.trim() || null;
           }
           throw new Error("Metadata version mismatch");
@@ -4728,19 +3647,19 @@ 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);
+    logger.logger.debugLargeJson("Updating agent state", this.agentState);
     this.agentStateLock.inLock(async () => {
-      await backoff(async () => {
+      await time.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 ? logger.encodeBase64(logger.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 ? logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(answer.agentState)) : null;
           this.agentStateVersion = answer.version;
-          logger.debug("Agent state updated", this.agentState);
+          logger.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 ? logger.decrypt(this.encryptionKey, this.encryptionVariant, logger.decodeBase64(answer.agentState)) : null;
           }
           throw new Error("Agent state version mismatch");
         } else if (answer.result === "error") ;
@@ -4755,7 +3674,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     try {
       await this.sendSync.invalidateAndAwait();
     } catch (error) {
-      logger.debug("[API] flush: outbox flush failed, some messages may be lost:", error);
+      logger.logger.debug("[API] flush: outbox flush failed, some messages may be lost:", error);
     }
     if (!this.socket.connected) {
       return;
@@ -4770,387 +3689,17 @@ class ApiSessionClient extends node_events.EventEmitter {
     });
   }
   async close() {
-    logger.debug("[API] socket.close() called");
+    logger.logger.debug("[API] socket.close() called");
     try {
       await this.sendSync.invalidateAndAwait();
     } catch (error) {
-      logger.debug("[API] close: final outbox flush failed:", error);
+      logger.logger.debug("[API] close: final outbox flush failed:", error);
     }
     this.sendSync.stop();
     this.socket.close();
   }
 }
 
-const AnthropicConfigSchema = z__namespace.object({
-  baseUrl: z__namespace.string().url().optional(),
-  authToken: z__namespace.string().optional(),
-  model: z__namespace.string().optional()
-});
-const OpenAIConfigSchema = z__namespace.object({
-  apiKey: z__namespace.string().optional(),
-  baseUrl: z__namespace.string().url().optional(),
-  model: z__namespace.string().optional()
-});
-const AzureOpenAIConfigSchema = z__namespace.object({
-  apiKey: z__namespace.string().optional(),
-  endpoint: z__namespace.string().url().optional(),
-  apiVersion: z__namespace.string().optional(),
-  deploymentName: z__namespace.string().optional()
-});
-const TogetherAIConfigSchema = z__namespace.object({
-  apiKey: z__namespace.string().optional(),
-  model: z__namespace.string().optional()
-});
-const TmuxConfigSchema = z__namespace.object({
-  sessionName: z__namespace.string().optional(),
-  tmpDir: z__namespace.string().optional(),
-  updateEnvironment: z__namespace.boolean().optional()
-});
-const EnvironmentVariableSchema = z__namespace.object({
-  name: z__namespace.string().regex(/^[A-Z_][A-Z0-9_]*$/, "Invalid environment variable name"),
-  value: z__namespace.string()
-});
-const ProfileCompatibilitySchema = z__namespace.object({
-  claude: z__namespace.boolean().default(true),
-  codex: z__namespace.boolean().default(true),
-  gemini: z__namespace.boolean().default(true)
-});
-const AIBackendProfileSchema = z__namespace.object({
-  id: z__namespace.string().uuid(),
-  name: z__namespace.string().min(1).max(100),
-  description: z__namespace.string().max(500).optional(),
-  // Agent-specific configurations
-  anthropicConfig: AnthropicConfigSchema.optional(),
-  openaiConfig: OpenAIConfigSchema.optional(),
-  azureOpenAIConfig: AzureOpenAIConfigSchema.optional(),
-  togetherAIConfig: TogetherAIConfigSchema.optional(),
-  // Tmux configuration
-  tmuxConfig: TmuxConfigSchema.optional(),
-  // Environment variables (validated)
-  environmentVariables: z__namespace.array(EnvironmentVariableSchema).default([]),
-  // Default session type for this profile
-  defaultSessionType: z__namespace.enum(["simple", "worktree"]).optional(),
-  // Default permission mode for this profile (supports both Claude and Codex modes)
-  defaultPermissionMode: z__namespace.enum([
-    "default",
-    "acceptEdits",
-    "bypassPermissions",
-    "plan",
-    // Claude modes
-    "read-only",
-    "safe-yolo",
-    "yolo"
-    // Codex modes
-  ]).optional(),
-  // Default model mode for this profile
-  defaultModelMode: z__namespace.string().optional(),
-  // Compatibility metadata
-  compatibility: ProfileCompatibilitySchema.default({ claude: true, codex: true, gemini: true }),
-  // Built-in profile indicator
-  isBuiltIn: z__namespace.boolean().default(false),
-  // Metadata
-  createdAt: z__namespace.number().default(() => Date.now()),
-  updatedAt: z__namespace.number().default(() => Date.now()),
-  version: z__namespace.string().default("1.0.0")
-});
-function validateProfileForAgent(profile, agent) {
-  return profile.compatibility[agent];
-}
-function getProfileEnvironmentVariables(profile) {
-  const envVars = {};
-  profile.environmentVariables.forEach((envVar) => {
-    envVars[envVar.name] = envVar.value;
-  });
-  if (profile.anthropicConfig) {
-    if (profile.anthropicConfig.baseUrl) envVars.ANTHROPIC_BASE_URL = profile.anthropicConfig.baseUrl;
-    if (profile.anthropicConfig.authToken) envVars.ANTHROPIC_AUTH_TOKEN = profile.anthropicConfig.authToken;
-    if (profile.anthropicConfig.model) envVars.ANTHROPIC_MODEL = profile.anthropicConfig.model;
-  }
-  if (profile.openaiConfig) {
-    if (profile.openaiConfig.apiKey) envVars.OPENAI_API_KEY = profile.openaiConfig.apiKey;
-    if (profile.openaiConfig.baseUrl) envVars.OPENAI_BASE_URL = profile.openaiConfig.baseUrl;
-    if (profile.openaiConfig.model) envVars.OPENAI_MODEL = profile.openaiConfig.model;
-  }
-  if (profile.azureOpenAIConfig) {
-    if (profile.azureOpenAIConfig.apiKey) envVars.AZURE_OPENAI_API_KEY = profile.azureOpenAIConfig.apiKey;
-    if (profile.azureOpenAIConfig.endpoint) envVars.AZURE_OPENAI_ENDPOINT = profile.azureOpenAIConfig.endpoint;
-    if (profile.azureOpenAIConfig.apiVersion) envVars.AZURE_OPENAI_API_VERSION = profile.azureOpenAIConfig.apiVersion;
-    if (profile.azureOpenAIConfig.deploymentName) envVars.AZURE_OPENAI_DEPLOYMENT_NAME = profile.azureOpenAIConfig.deploymentName;
-  }
-  if (profile.togetherAIConfig) {
-    if (profile.togetherAIConfig.apiKey) envVars.TOGETHER_API_KEY = profile.togetherAIConfig.apiKey;
-    if (profile.togetherAIConfig.model) envVars.TOGETHER_MODEL = profile.togetherAIConfig.model;
-  }
-  if (profile.tmuxConfig) {
-    if (profile.tmuxConfig.sessionName !== void 0) envVars.TMUX_SESSION_NAME = profile.tmuxConfig.sessionName;
-    if (profile.tmuxConfig.tmpDir) envVars.TMUX_TMPDIR = profile.tmuxConfig.tmpDir;
-    if (profile.tmuxConfig.updateEnvironment !== void 0) {
-      envVars.TMUX_UPDATE_ENVIRONMENT = profile.tmuxConfig.updateEnvironment.toString();
-    }
-  }
-  return envVars;
-}
-const SUPPORTED_SCHEMA_VERSION = 2;
-const defaultSettings = {
-  schemaVersion: SUPPORTED_SCHEMA_VERSION,
-  onboardingCompleted: false,
-  profiles: [],
-  localEnvironmentVariables: {}
-};
-function migrateSettings(raw, fromVersion) {
-  let migrated = { ...raw };
-  if (fromVersion < 2) {
-    if (!migrated.profiles) {
-      migrated.profiles = [];
-    }
-    if (!migrated.localEnvironmentVariables) {
-      migrated.localEnvironmentVariables = {};
-    }
-    migrated.schemaVersion = 2;
-  }
-  return migrated;
-}
-async function readSettings() {
-  if (!fs.existsSync(configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    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, schemaVersion);
-    if (migrated.profiles && Array.isArray(migrated.profiles)) {
-      const validProfiles = [];
-      for (const profile of migrated.profiles) {
-        try {
-          const validated = AIBackendProfileSchema.parse(profile);
-          validProfiles.push(validated);
-        } catch (error) {
-          logger.warn(
-            `\u26A0\uFE0F Invalid profile "${profile?.name || profile?.id || "unknown"}" - skipping. Error: ${error.message}`
-          );
-        }
-      }
-      migrated.profiles = validProfiles;
-    }
-    return { ...defaultSettings, ...migrated };
-  } catch (error) {
-    logger.warn(`Failed to read settings: ${error.message}`);
-    return { ...defaultSettings };
-  }
-}
-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, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
-      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 current = await readSettings() || { ...defaultSettings };
-    const updated = await updater(current);
-    if (!fs.existsSync(configuration.happyHomeDir)) {
-      await promises.mkdir(configuration.happyHomeDir, { recursive: true });
-    }
-    await promises.writeFile(tmpFile, JSON.stringify(updated, null, 2));
-    await promises.rename(tmpFile, configuration.settingsFile);
-    return updated;
-  } finally {
-    await fileHandle.close();
-    await promises.unlink(lockFile).catch(() => {
-    });
-  }
-}
-const credentialsSchema = z__namespace.object({
-  token: z__namespace.string(),
-  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 (!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,
-        encryption: {
-          type: "legacy",
-          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
-        }
-      };
-    } else if (credentials.encryption) {
-      return {
-        token: credentials.token,
-        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 writeCredentialsLegacy(credentials) {
-  if (!fs.existsSync(configuration.happyHomeDir)) {
-    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
-  }
-  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-async function writeCredentialsDataKey(credentials) {
-  if (!fs.existsSync(configuration.happyHomeDir)) {
-    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
-  }
-  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
-    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
-    token: credentials.token
-  }, null, 2));
-}
-async function clearCredentials() {
-  if (fs.existsSync(configuration.privateKeyFile)) {
-    await promises.unlink(configuration.privateKeyFile);
-  }
-}
-async function clearMachineId() {
-  await updateSettings((settings) => ({
-    ...settings,
-    machineId: void 0
-  }));
-}
-async function readDaemonState() {
-  try {
-    if (!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) {
-  fs.writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
-}
-async function clearDaemonState() {
-  if (fs.existsSync(configuration.daemonStateFile)) {
-    await promises.unlink(configuration.daemonStateFile);
-  }
-  if (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,
-        fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY
-      );
-      await fileHandle.writeFile(String(process.pid));
-      return fileHandle;
-    } catch (error) {
-      if (error.code === "EEXIST") {
-        try {
-          const lockPid = fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
-          if (lockPid && !isNaN(Number(lockPid))) {
-            try {
-              process.kill(Number(lockPid), 0);
-            } catch {
-              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 (fs.existsSync(configuration.daemonLockFile)) {
-      fs.unlinkSync(configuration.daemonLockFile);
-    }
-  } catch {
-  }
-}
-
-var persistence = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AIBackendProfileSchema: AIBackendProfileSchema,
-    SUPPORTED_SCHEMA_VERSION: SUPPORTED_SCHEMA_VERSION,
-    acquireDaemonLock: acquireDaemonLock,
-    clearCredentials: clearCredentials,
-    clearDaemonState: clearDaemonState,
-    clearMachineId: clearMachineId,
-    getProfileEnvironmentVariables: getProfileEnvironmentVariables,
-    readCredentials: readCredentials,
-    readDaemonState: readDaemonState,
-    readSettings: readSettings,
-    releaseDaemonLock: releaseDaemonLock,
-    updateSettings: updateSettings,
-    validateProfileForAgent: validateProfileForAgent,
-    writeCredentialsDataKey: writeCredentialsDataKey,
-    writeCredentialsLegacy: writeCredentialsLegacy,
-    writeDaemonState: writeDaemonState
-});
-
 function buildRunningDaemonState(previousState, currentRuntimeState, opts = {}) {
   const currentHttpPort = currentRuntimeState?.httpPort;
   const currentStartedAt = currentRuntimeState?.startedAt;
@@ -5216,11 +3765,11 @@ class OpenClawTunnelManager {
     this.tunnels.set(tunnelId, tunnel);
     return new Promise((resolve) => {
       try {
-        logger.debug(`[OpenClawTunnel] Connecting to ${config.url}`);
+        logger.logger.debug(`[OpenClawTunnel] Connecting to ${config.url}`);
         const ws = new WebSocket(config.url);
         tunnel.ws = ws;
         ws.on("open", () => {
-          logger.debug(`[OpenClawTunnel] WebSocket opened for tunnel ${tunnelId}`);
+          logger.logger.debug(`[OpenClawTunnel] WebSocket opened for tunnel ${tunnelId}`);
         });
         ws.on("message", async (data) => {
           const result = await this.handleMessage(tunnelId, tunnel, data.toString());
@@ -5229,7 +3778,7 @@ class OpenClawTunnelManager {
           }
         });
         ws.on("error", (error) => {
-          logger.debug(`[OpenClawTunnel] WebSocket error for tunnel ${tunnelId}:`, error);
+          logger.logger.debug(`[OpenClawTunnel] WebSocket error for tunnel ${tunnelId}:`, error);
           tunnel.status = "error";
           this.failAllPending(tunnel, new Error("WebSocket error"));
           resolve({
@@ -5240,7 +3789,7 @@ class OpenClawTunnelManager {
         });
         ws.on("close", (code, reason) => {
           const reasonStr = reason?.toString() || "";
-          logger.debug(`[OpenClawTunnel] WebSocket closed for tunnel ${tunnelId}: ${code} ${reasonStr}`);
+          logger.logger.debug(`[OpenClawTunnel] WebSocket closed for tunnel ${tunnelId}: ${code} ${reasonStr}`);
           const isPairingRequired = reasonStr.includes("unauthorized") || reasonStr.includes("NOT_PAIRED");
           this.failAllPending(tunnel, new Error(reasonStr || "Connection closed"));
           if (tunnel.status === "connecting") {
@@ -5372,7 +3921,7 @@ class OpenClawTunnelManager {
       tunnel.ws = null;
     }
     this.tunnels.delete(tunnelId);
-    logger.debug(`[OpenClawTunnel] Closed tunnel ${tunnelId}`);
+    logger.logger.debug(`[OpenClawTunnel] Closed tunnel ${tunnelId}`);
     return true;
   }
   async handleMessage(tunnelId, tunnel, data) {
@@ -5380,7 +3929,7 @@ class OpenClawTunnelManager {
     try {
       frame = JSON.parse(data);
     } catch {
-      logger.debug(`[OpenClawTunnel] Invalid JSON: ${data.slice(0, 100)}`);
+      logger.logger.debug(`[OpenClawTunnel] Invalid JSON: ${data.slice(0, 100)}`);
       return null;
     }
     if (frame.type === "res") {
@@ -5405,7 +3954,7 @@ class OpenClawTunnelManager {
       if (frame.event === "connect.challenge" && !tunnel.connectSent) {
         const nonce = payload?.nonce;
         if (nonce) {
-          logger.debug(`[OpenClawTunnel] Received challenge nonce for tunnel ${tunnelId}`);
+          logger.logger.debug(`[OpenClawTunnel] Received challenge nonce for tunnel ${tunnelId}`);
           tunnel.connectNonce = nonce;
         }
         return this.sendConnect(tunnelId, tunnel);
@@ -5485,7 +4034,7 @@ class OpenClawTunnelManager {
             tunnel.mainSessionKey = result.snapshot?.sessionDefaults?.mainSessionKey ?? null;
             tunnel.serverHost = result.server?.host ?? null;
             tunnel.deviceToken = result.auth?.deviceToken ?? null;
-            logger.debug(`[OpenClawTunnel] Connected tunnel ${tunnelId}, server: ${tunnel.serverHost}`);
+            logger.logger.debug(`[OpenClawTunnel] Connected tunnel ${tunnelId}, server: ${tunnel.serverHost}`);
             resolve({
               ok: true,
               status: "connected",
@@ -5603,7 +4152,7 @@ function registerOpenClawHandlers(rpcManager, encryptionContext) {
         if (Array.isArray(payload.messages) && payload.messages.length > 0) {
           return {
             __preEncrypted: true,
-            data: encodeBase64(encryptLegacy(result, encryptionContext.key))
+            data: logger.encodeBase64(logger.encryptLegacy(result, encryptionContext.key))
           };
         }
       }
@@ -5655,7 +4204,7 @@ const SESSION_CACHE_REFRESH_MODES = /* @__PURE__ */ new Set([
   "background"
 ]);
 function getSessionMetadataCachePath(cacheFileName) {
-  return path.join(configuration.happyHomeDir, cacheFileName);
+  return path.join(logger.configuration.happyHomeDir, cacheFileName);
 }
 function getCacheLockPath(cachePath) {
   return `${cachePath}.lock`;
@@ -6702,7 +5251,7 @@ const GeminiSessionLineSchema = z.z.discriminatedUnion("type", [
 
 const SESSIONS_DIR_NAME = "gemini_sessions";
 function getGeminiSessionsDir() {
-  return path.join(configuration.happyHomeDir, SESSIONS_DIR_NAME);
+  return path.join(logger.configuration.happyHomeDir, SESSIONS_DIR_NAME);
 }
 function getGeminiSessionFilePath(sessionId) {
   return path.join(getGeminiSessionsDir(), `${sessionId}.jsonl`);
@@ -6722,9 +5271,9 @@ class GeminiSessionWriter {
         value: meta ?? {},
         timestamp: Date.now()
       });
-      logger.debug(`[GeminiSessionWriter] Initialized: ${this.filePath}`);
+      logger.logger.debug(`[GeminiSessionWriter] Initialized: ${this.filePath}`);
     } catch (error) {
-      logger.debug(`[GeminiSessionWriter] Failed to init:`, error);
+      logger.logger.debug(`[GeminiSessionWriter] Failed to init:`, error);
     }
   }
   getFilePath() {
@@ -6783,7 +5332,7 @@ class GeminiSessionWriter {
    */
   appendLine(line) {
     this.writePromise = this.writePromise.then(() => promises.appendFile(this.filePath, JSON.stringify(line) + "\n", "utf-8")).catch((error) => {
-      logger.debug(`[GeminiSessionWriter] Write failed:`, error);
+      logger.logger.debug(`[GeminiSessionWriter] Write failed:`, error);
     });
   }
 }
@@ -6794,7 +5343,7 @@ async function readGeminiSessionLog(sessionId) {
   try {
     content = await promises.readFile(filePath, "utf-8");
   } catch (error) {
-    logger.debug(`[GeminiSessionReader] Session file not found: ${filePath}`);
+    logger.logger.debug(`[GeminiSessionReader] Session file not found: ${filePath}`);
     return [];
   }
   const lines = content.split("\n");
@@ -6807,10 +5356,10 @@ async function readGeminiSessionLog(sessionId) {
       if (result.success) {
         entries.push(result.data);
       } else {
-        logger.debug(`[GeminiSessionReader] Skipping invalid line: ${line.substring(0, 100)}`);
+        logger.logger.debug(`[GeminiSessionReader] Skipping invalid line: ${line.substring(0, 100)}`);
       }
     } catch {
-      logger.debug(`[GeminiSessionReader] Skipping non-JSON line: ${line.substring(0, 100)}`);
+      logger.logger.debug(`[GeminiSessionReader] Skipping non-JSON line: ${line.substring(0, 100)}`);
     }
   }
   return entries;
@@ -7032,7 +5581,7 @@ async function forkAndTruncateGeminiSession(sessionId, truncateBeforeUuid) {
         return { success: false, errorMessage: truncateResult.errorMessage };
       }
     }
-    logger.debug(`[GeminiSessionFork] Forked ${sessionId} -> ${newSessionId}`);
+    logger.logger.debug(`[GeminiSessionFork] Forked ${sessionId} -> ${newSessionId}`);
     return { success: true, newSessionId };
   } catch (error) {
     try {
@@ -7169,14 +5718,14 @@ function isSystemMessage(text) {
 async function readCodexSessionUserMessages(codexSessionId, limit = 50) {
   const filePath = findCodexSessionFile(codexSessionId);
   if (!filePath) {
-    logger.debug(`[CodexSessionReader] Session file not found for: ${codexSessionId}`);
+    logger.logger.debug(`[CodexSessionReader] Session file not found for: ${codexSessionId}`);
     return [];
   }
   let content;
   try {
     content = await promises.readFile(filePath, "utf-8");
   } catch (error) {
-    logger.debug(`[CodexSessionReader] Failed to read file: ${filePath}`, error);
+    logger.logger.debug(`[CodexSessionReader] Failed to read file: ${filePath}`, error);
     return [];
   }
   const lines = content.split("\n");
@@ -7473,7 +6022,7 @@ async function forkAndTruncateCodexSession(codexSessionId, truncateBeforeUuid) {
       }
       await promises.writeFile(newPath, outputLines.join("\n") + "\n", "utf-8");
     }
-    logger.debug(`[CodexSessionFork] Forked ${path.basename(originalPath)} -> ${path.basename(newPath)}`);
+    logger.logger.debug(`[CodexSessionFork] Forked ${path.basename(originalPath)} -> ${path.basename(newPath)}`);
     return { success: true, newFilePath: newPath };
   } catch (error) {
     try {
@@ -7660,7 +6209,7 @@ function createSessionCacheStatsReporter(saveStats, label) {
     const stats = pendingStats;
     pendingStats = null;
     flushPromise = saveStats(stats).catch((error) => {
-      logger.debug(`[API MACHINE] Failed to persist ${label} session cache stats`, error);
+      logger.logger.debug(`[API MACHINE] Failed to persist ${label} session cache stats`, error);
     }).then(() => {
       flushPromise = null;
     });
@@ -7692,7 +6241,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) => logger.logger.debug(msg, data)
     });
     registerCommonHandlers(this.rpcHandlerManager, process.env.HAPPY_DAEMON_ROOT || "/", this.machine.id);
     registerOpenClawHandlers(this.rpcHandlerManager, {
@@ -7708,6 +6257,11 @@ class ApiMachineClient {
     });
   }
   socket;
+  /** The daemon's live connection. Reused for device RPC so a CLI command does
+   *  not spend ~500ms building its own TLS + WebSocket handshake. */
+  get rpcSocket() {
+    return this.socket;
+  }
   keepAliveInterval = null;
   rpcHandlerManager;
   claudeCache = new SessionCache({
@@ -7741,7 +6295,7 @@ class ApiMachineClient {
       event,
       payload
     };
-    const encryptedData = encodeBase64(encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, eventData));
+    const encryptedData = logger.encodeBase64(logger.encrypt(this.machine.encryptionKey, this.machine.encryptionVariant, eventData));
     const rpcMethod = `${this.machine.id}:openclaw-tunnel-event`;
     this.socket.emit("rpc-call", {
       method: rpcMethod,
@@ -7757,12 +6311,12 @@ class ApiMachineClient {
     orchestratorCancel
   }) {
     this.rpcHandlerManager.registerHandler("spawn-happy-session", async (params) => {
-      const settings = await readSettings();
+      const settings = await logger.readSettings();
       if (settings.deviceMode) {
         throw new Error("This machine is enrolled as a device and does not host sessions");
       }
       const { directory, sessionId, resumeSessionId, intent, sessionTitle, skipForkSession, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables, worktreeBasePath, worktreeBranchName, workspaceRepos, workspacePath, repoScripts, mcpServers } = params || {};
-      logger.debug(`[API MACHINE] Spawning session with params: ${JSON.stringify(params)}`);
+      logger.logger.debug(`[API MACHINE] Spawning session with params: ${JSON.stringify(params)}`);
       if (!directory) {
         throw new Error("Directory is required");
       }
@@ -7772,10 +6326,10 @@ class ApiMachineClient {
           this.claudeCache.invalidate();
           this.geminiCache.invalidate();
           this.codexCache.invalidate();
-          logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
+          logger.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}`);
+          logger.logger.debug(`[API MACHINE] Requesting directory creation approval for: ${result.directory}`);
           return { type: "requestToApproveDirectoryCreation", directory: result.directory };
         case "error":
           throw new Error(result.errorMessage);
@@ -7791,9 +6345,9 @@ class ApiMachineClient {
         const { worktreePath, basePath, branchName, archiveScript, deleteBranch } = repo;
         try {
           if (archiveScript) {
-            logger.info(`[DAEMON] Running archive script in ${worktreePath}...`);
+            logger.logger.info(`[DAEMON] Running archive script in ${worktreePath}...`);
             node_child_process.execSync(archiveScript, { cwd: worktreePath, stdio: "pipe", timeout: 3e5 });
-            logger.info(`[DAEMON] Archive script completed for ${worktreePath}`);
+            logger.logger.info(`[DAEMON] Archive script completed for ${worktreePath}`);
           }
           if (worktreePath !== basePath) {
             try {
@@ -7803,7 +6357,7 @@ class ApiMachineClient {
                 timeout: 3e4
               });
             } catch (err) {
-              logger.warn(`[DAEMON] git worktree remove failed: ${err.message}`);
+              logger.logger.warn(`[DAEMON] git worktree remove failed: ${err.message}`);
             }
             if (deleteBranch && branchName) {
               try {
@@ -7813,13 +6367,13 @@ class ApiMachineClient {
                   timeout: 1e4
                 });
               } catch (err) {
-                logger.warn(`[DAEMON] git branch -D failed: ${err.message}`);
+                logger.logger.warn(`[DAEMON] git branch -D failed: ${err.message}`);
               }
             }
           }
           results.push({ repo: worktreePath, success: true });
         } catch (err) {
-          logger.warn(`[DAEMON] Archive failed for ${worktreePath}: ${err.message}`);
+          logger.logger.warn(`[DAEMON] Archive failed for ${worktreePath}: ${err.message}`);
           results.push({ repo: worktreePath, success: false, error: err.message });
         }
       }
@@ -7828,7 +6382,7 @@ class ApiMachineClient {
           const entries = fs.readdirSync(workspacePath);
           if (entries.length === 0) {
             fs.rmdirSync(workspacePath);
-            logger.info(`[DAEMON] Removed empty workspace directory: ${workspacePath}`);
+            logger.logger.info(`[DAEMON] Removed empty workspace directory: ${workspacePath}`);
           }
         } catch {
         }
@@ -7847,13 +6401,13 @@ class ApiMachineClient {
       this.claudeCache.invalidate();
       this.geminiCache.invalidate();
       this.codexCache.invalidate();
-      logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
+      logger.logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
       return { message: "Session stopped" };
     });
     this.rpcHandlerManager.registerHandler("stop-daemon", () => {
-      logger.debug("[API MACHINE] Received stop-daemon RPC request");
+      logger.logger.debug("[API MACHINE] Received stop-daemon RPC request");
       setTimeout(() => {
-        logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
+        logger.logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
         requestShutdown();
       }, 100);
       return { message: "Daemon stop request acknowledged, starting shutdown sequence..." };
@@ -8091,21 +6645,21 @@ class ApiMachineClient {
    * for example to set a custom name.
    */
   async updateMachineMetadata(handler) {
-    await backoff(async () => {
+    await time.backoff(async () => {
       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: logger.encodeBase64(logger.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 = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.decodeBase64(answer.metadata));
         this.machine.metadataVersion = answer.version;
-        logger.debug("[API MACHINE] Metadata updated successfully");
+        logger.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 = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.decodeBase64(answer.metadata));
         }
         throw new Error("Metadata version mismatch");
       }
@@ -8116,29 +6670,29 @@ class ApiMachineClient {
    * Simplified without lock - relies on backoff for retry
    */
   async updateDaemonState(handler) {
-    await backoff(async () => {
+    await time.backoff(async () => {
       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: logger.encodeBase64(logger.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 = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.decodeBase64(answer.daemonState));
         this.machine.daemonStateVersion = answer.version;
-        logger.debug("[API MACHINE] Daemon state updated successfully");
+        logger.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 = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.decodeBase64(answer.daemonState));
         }
         throw new Error("Daemon state version mismatch");
       }
     });
   }
   connect() {
-    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
-    logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
+    const serverUrl = logger.configuration.serverUrl.replace(/^http/, "ws");
+    logger.logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
     this.socket = socket_ioClient.io(serverUrl, {
       transports: ["websocket"],
       auth: {
@@ -8152,7 +6706,7 @@ class ApiMachineClient {
       reconnectionDelayMax: 5e3
     });
     this.socket.on("connect", () => {
-      logger.debug("[API MACHINE] Connected to server");
+      logger.logger.debug("[API MACHINE] Connected to server");
       this.updateDaemonState((state) => buildRunningDaemonState(
         state,
         this.currentRuntimeDaemonState ?? this.machine.daemonState
@@ -8161,36 +6715,36 @@ class ApiMachineClient {
       this.startKeepAlive();
     });
     this.socket.on("disconnect", () => {
-      logger.debug("[API MACHINE] Disconnected from server");
+      logger.logger.debug("[API MACHINE] Disconnected from server");
       this.rpcHandlerManager.onSocketDisconnect();
       this.stopKeepAlive();
     });
     this.socket.on("rpc-request", async (data, callback) => {
-      logger.debugLargeJson(`[API MACHINE] Received RPC request:`, data);
+      logger.logger.debugLargeJson(`[API MACHINE] Received RPC request:`, data);
       callback(await this.rpcHandlerManager.handleRequest(data));
     });
     this.socket.on("update", (data) => {
       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));
+          logger.logger.debug("[API MACHINE] Received external metadata update");
+          this.machine.metadata = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.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));
+          logger.logger.debug("[API MACHINE] Received external daemon state update");
+          this.machine.daemonState = logger.decrypt(this.machine.encryptionKey, this.machine.encryptionVariant, logger.decodeBase64(update.daemonState.value));
           this.machine.daemonStateVersion = update.daemonState.version;
         }
       } else {
-        logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
+        logger.logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
       }
     });
     this.socket.on("connect_error", (error) => {
-      logger.debug(`[API MACHINE] Connection error: ${error.message}`);
+      logger.logger.debug(`[API MACHINE] Connection error: ${error.message}`);
     });
     this.socket.io.on("error", (error) => {
-      logger.debug("[API MACHINE] Socket error:", error);
+      logger.logger.debug("[API MACHINE] Socket error:", error);
     });
   }
   startKeepAlive() {
@@ -8200,27 +6754,27 @@ class ApiMachineClient {
         machineId: this.machine.id,
         time: Date.now()
       };
-      if (isDebug()) {
-        logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
+      if (logger.isDebug()) {
+        logger.logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
       }
       this.socket.emit("machine-alive", payload);
     }, 2e4);
-    logger.debug("[API MACHINE] Keep-alive started (20s interval)");
+    logger.logger.debug("[API MACHINE] Keep-alive started (20s interval)");
   }
   stopKeepAlive() {
     if (this.keepAliveInterval) {
       clearInterval(this.keepAliveInterval);
       this.keepAliveInterval = null;
-      logger.debug("[API MACHINE] Keep-alive stopped");
+      logger.logger.debug("[API MACHINE] Keep-alive stopped");
     }
   }
   shutdown() {
-    logger.debug("[API MACHINE] Shutting down");
+    logger.logger.debug("[API MACHINE] Shutting down");
     openClawTunnelManager.closeAll();
     this.stopKeepAlive();
     if (this.socket) {
       this.socket.close();
-      logger.debug("[API MACHINE] Socket closed");
+      logger.logger.debug("[API MACHINE] Socket closed");
     }
   }
 }
@@ -8248,13 +6802,13 @@ class PushNotificationClient {
           }
         }
       );
-      logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+      logger.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()}`);
+        logger.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:", error);
+      logger.logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
       throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -8263,7 +6817,7 @@ class PushNotificationClient {
    * @param messages - Array of push messages to send
    */
   async sendPushNotifications(messages) {
-    logger.debug(`Sending ${messages.length} push notifications`);
+    logger.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));
@@ -8271,7 +6825,7 @@ class PushNotificationClient {
       return expoServerSdk.Expo.isExpoPushToken(message.to);
     });
     if (validMessages.length === 0) {
-      logger.debug("No valid Expo push tokens found");
+      logger.logger.debug("No valid Expo push tokens found");
       return;
     }
     const chunks = this.expo.chunkPushNotifications(validMessages);
@@ -8285,7 +6839,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);
+            logger.logger.debug("[PUSH] Some notifications failed:", errorDetails);
           }
           if (errors.length === ticketChunk.length) {
             throw new Error("All push notifications in chunk failed");
@@ -8294,7 +6848,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");
+            logger.logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
             break;
           }
           attempt++;
@@ -8302,13 +6856,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})`);
+            logger.logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
             await new Promise((resolve) => setTimeout(resolve, waitTime));
           }
         }
       }
     }
-    logger.debug(`Push notifications sent successfully`);
+    logger.logger.debug(`Push notifications sent successfully`);
   }
   /**
    * Increment the badge count on the server and return the new value
@@ -8327,7 +6881,7 @@ class PushNotificationClient {
       );
       return response.data.badgeCount;
     } catch (error) {
-      logger.debug("[PUSH] Failed to increment badge count:", error);
+      logger.logger.debug("[PUSH] Failed to increment badge count:", error);
       return 1;
     }
   }
@@ -8338,24 +6892,24 @@ class PushNotificationClient {
    * @param data - Additional data to send with the notification
    */
   sendToAllDevices(title, body, data) {
-    logger.debug(`[PUSH] sendToAllDevices called with title: "${title}", body: "${body}"`);
+    logger.logger.debug(`[PUSH] sendToAllDevices called with title: "${title}", body: "${body}"`);
     (async () => {
       try {
-        logger.debug("[PUSH] Fetching push tokens and incrementing badge...");
+        logger.logger.debug("[PUSH] Fetching push tokens and incrementing badge...");
         const [tokens, badgeCount] = await Promise.all([
           this.fetchPushTokens(),
           this.incrementBadgeCount()
         ]);
-        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens, badge: ${badgeCount}`);
+        logger.logger.debug(`[PUSH] Fetched ${tokens.length} push tokens, badge: ${badgeCount}`);
         tokens.forEach((token, index) => {
-          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
+          logger.logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
         });
         if (tokens.length === 0) {
-          logger.debug("No push tokens found for user");
+          logger.logger.debug("No push tokens found for user");
           return;
         }
         const messages = tokens.map((token, index) => {
-          logger.debug(`[PUSH] Creating message ${index + 1} for token`);
+          logger.logger.debug(`[PUSH] Creating message ${index + 1} for token`);
           return {
             to: token.token,
             title,
@@ -8367,43 +6921,16 @@ class PushNotificationClient {
             badge: badgeCount
           };
         });
-        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        logger.logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
         await this.sendPushNotifications(messages);
-        logger.debug("[PUSH] Push notifications sent successfully");
+        logger.logger.debug("[PUSH] Push notifications sent successfully");
       } catch (error) {
-        logger.debug("[PUSH] Error sending to all devices:", error);
+        logger.logger.debug("[PUSH] Error sending to all devices:", error);
       }
     })();
   }
 }
 
-function keyPath(sessionId) {
-  return path.join(configuration.sessionKeysDir, `${sessionId}.key`);
-}
-async function cacheSessionKey(sessionId, sessionAESKey, machineKey) {
-  if (!fs.existsSync(configuration.sessionKeysDir)) {
-    fs.mkdirSync(configuration.sessionKeysDir, { recursive: true });
-  }
-  const encrypted = encryptWithDataKey(encodeBase64(sessionAESKey), machineKey);
-  await promises.writeFile(keyPath(sessionId), encrypted);
-}
-function readCachedSessionKey(sessionId, machineKey) {
-  const p = keyPath(sessionId);
-  if (!fs.existsSync(p)) {
-    return null;
-  }
-  try {
-    const blob = new Uint8Array(fs.readFileSync(p));
-    const b64 = decryptWithDataKey(blob, machineKey);
-    if (typeof b64 !== "string") {
-      return null;
-    }
-    return decodeBase64(b64);
-  } catch {
-    return null;
-  }
-}
-
 function startOfflineReconnection(config) {
   let reconnected = false;
   let session = null;
@@ -8428,16 +6955,16 @@ function startOfflineReconnection(config) {
       if (cancelled) return;
       reconnected = true;
       config.onNotify("\u2705 Reconnected! Session syncing in background.");
-      logger.debug("[OfflineReconnection] Successfully reconnected");
+      logger.logger.debug("[OfflineReconnection] Successfully reconnected");
     } catch (e) {
       if (axios.isAxiosError(e) && e.response?.status === 401) {
-        logger.debug("[OfflineReconnection] Authentication error, stopping retries");
+        logger.logger.debug("[OfflineReconnection] Authentication error, stopping retries");
         config.onNotify("\u274C Authentication failed. Please re-authenticate with `happy auth`.");
         return;
       }
       failureCount++;
-      const delay = exponentialBackoffDelay(failureCount, 5e3, 6e4, 10);
-      logger.debug(`[OfflineReconnection] Attempt ${failureCount} failed, retrying in ${delay}ms`);
+      const delay = time.exponentialBackoffDelay(failureCount, 5e3, 6e4, 10);
+      logger.logger.debug(`[OfflineReconnection] Attempt ${failureCount} failed, retrying in ${delay}ms`);
       if (!cancelled) {
         timeoutId = setTimeout(attemptReconnect, delay);
       }
@@ -8537,7 +7064,7 @@ class ApiClient {
   pushClient;
   constructor(credential) {
     this.credential = credential;
-    this.pushClient = new PushNotificationClient(credential.token, configuration.serverUrl);
+    this.pushClient = new PushNotificationClient(credential.token, logger.configuration.serverUrl);
   }
   /**
    * Create a new session or load existing one with the given tag
@@ -8547,9 +7074,9 @@ class ApiClient {
     let encryptionKey;
     let encryptionVariant;
     if (this.credential.encryption.type === "dataKey") {
-      encryptionKey = getRandomBytes(32);
+      encryptionKey = logger.getRandomBytes(32);
       encryptionVariant = "dataKey";
-      let encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
+      let encryptedDataKey = logger.libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
       dataEncryptionKey.set([0], 0);
       dataEncryptionKey.set(encryptedDataKey, 1);
@@ -8559,12 +7086,12 @@ class ApiClient {
     }
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/sessions`,
+        `${logger.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: logger.encodeBase64(logger.encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          agentState: opts.state ? logger.encodeBase64(logger.encrypt(encryptionKey, encryptionVariant, opts.state)) : null,
+          dataEncryptionKey: dataEncryptionKey ? logger.encodeBase64(dataEncryptionKey) : null
         },
         {
           headers: {
@@ -8575,25 +7102,25 @@ class ApiClient {
           // 1 minute timeout for very bad network connections
         }
       );
-      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      logger.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: logger.decrypt(encryptionKey, encryptionVariant, logger.decodeBase64(raw.metadata)),
         metadataVersion: raw.metadataVersion,
-        agentState: raw.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.agentState)) : null,
+        agentState: raw.agentState ? logger.decrypt(encryptionKey, encryptionVariant, logger.decodeBase64(raw.agentState)) : null,
         agentStateVersion: raw.agentStateVersion,
         encryptionKey,
         encryptionVariant
       };
       if (this.credential.encryption.type === "dataKey") {
-        cacheSessionKey(raw.id, encryptionKey, this.credential.encryption.machineKey).catch(() => {
+        sessionKeyCache.cacheSessionKey(raw.id, encryptionKey, this.credential.encryption.machineKey).catch(() => {
         });
       }
       return session;
     } catch (error) {
-      logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      logger.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)) {
@@ -8601,7 +7128,7 @@ class ApiClient {
             operation: "Session creation",
             caller: "api.getOrCreateSession",
             errorCode,
-            url: `${configuration.serverUrl}/v1/sessions`
+            url: `${logger.configuration.serverUrl}/v1/sessions`
           });
           return null;
         }
@@ -8611,7 +7138,7 @@ class ApiClient {
         connectionState.fail({
           operation: "Session creation",
           errorCode: "404",
-          url: `${configuration.serverUrl}/v1/sessions`
+          url: `${logger.configuration.serverUrl}/v1/sessions`
         });
         return null;
       }
@@ -8621,7 +7148,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Session creation",
             errorCode: String(status),
-            url: `${configuration.serverUrl}/v1/sessions`,
+            url: `${logger.configuration.serverUrl}/v1/sessions`,
             details: ["Server encountered an error, will retry automatically"]
           });
           return null;
@@ -8641,7 +7168,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 = logger.libsodiumEncryptForPublicKey(this.credential.encryption.machineKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
       dataEncryptionKey.set([0], 0);
       dataEncryptionKey.set(encryptedDataKey, 1);
@@ -8660,12 +7187,12 @@ class ApiClient {
     });
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/machines`,
+        `${logger.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: logger.encodeBase64(logger.encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          daemonState: opts.daemonState ? logger.encodeBase64(logger.encrypt(encryptionKey, encryptionVariant, opts.daemonState)) : void 0,
+          dataEncryptionKey: dataEncryptionKey ? logger.encodeBase64(dataEncryptionKey) : void 0,
           // Plaintext label so other clients can render a device list without
           // holding this machine's key. Everything else stays encrypted.
           displayName: opts.metadata.displayName || opts.metadata.host || void 0,
@@ -8683,14 +7210,14 @@ class ApiClient {
         }
       );
       const raw = response.data.machine;
-      logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
+      logger.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 ? logger.decrypt(encryptionKey, encryptionVariant, logger.decodeBase64(raw.metadata)) : null,
         metadataVersion: raw.metadataVersion || 0,
-        daemonState: raw.daemonState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.daemonState)) : null,
+        daemonState: raw.daemonState ? logger.decrypt(encryptionKey, encryptionVariant, logger.decodeBase64(raw.daemonState)) : null,
         daemonStateVersion: raw.daemonStateVersion || 0
       };
       return machine;
@@ -8700,7 +7227,7 @@ class ApiClient {
           operation: "Machine registration",
           caller: "api.getOrCreateMachine",
           errorCode: error.code,
-          url: `${configuration.serverUrl}/v1/machines`
+          url: `${logger.configuration.serverUrl}/v1/machines`
         });
         return createMinimalMachine();
       }
@@ -8728,7 +7255,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Machine registration",
             errorCode: String(status),
-            url: `${configuration.serverUrl}/v1/machines`,
+            url: `${logger.configuration.serverUrl}/v1/machines`,
             details: ["Server encountered an error, will retry automatically"]
           });
           return createMinimalMachine();
@@ -8737,7 +7264,7 @@ class ApiClient {
           connectionState.fail({
             operation: "Machine registration",
             errorCode: "404",
-            url: `${configuration.serverUrl}/v1/machines`
+            url: `${logger.configuration.serverUrl}/v1/machines`
           });
           return createMinimalMachine();
         }
@@ -8759,7 +7286,7 @@ class ApiClient {
    */
   async reportOrchestratorExecutionStart(opts) {
     await axios.post(
-      `${configuration.serverUrl}/v1/orchestrator/executions/${opts.executionId}/start`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/executions/${opts.executionId}/start`,
       {
         dispatchToken: opts.dispatchToken,
         startedAt: opts.startedAt,
@@ -8779,7 +7306,7 @@ class ApiClient {
    */
   async reportOrchestratorExecutionFinish(opts) {
     await axios.post(
-      `${configuration.serverUrl}/v1/orchestrator/executions/${opts.executionId}/finish`,
+      `${logger.configuration.serverUrl}/v1/orchestrator/executions/${opts.executionId}/finish`,
       {
         dispatchToken: opts.dispatchToken,
         status: opts.status,
@@ -8808,7 +7335,7 @@ class ApiClient {
   async registerVendorToken(vendor, apiKey) {
     try {
       const response = await axios.post(
-        `${configuration.serverUrl}/v1/connect/${vendor}/register`,
+        `${logger.configuration.serverUrl}/v1/connect/${vendor}/register`,
         {
           token: JSON.stringify(apiKey)
         },
@@ -8823,9 +7350,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`);
+      logger.logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
     } catch (error) {
-      logger.debug(`[API] [ERROR] Failed to register vendor token:`, error);
+      logger.logger.debug(`[API] [ERROR] Failed to register vendor token:`, error);
       throw new Error(`Failed to register vendor token: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -8838,7 +7365,7 @@ class ApiClient {
   async listMemories() {
     try {
       const response = await axios.get(
-        `${configuration.serverUrl}/v1/memory`,
+        `${logger.configuration.serverUrl}/v1/memory`,
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
@@ -8852,7 +7379,7 @@ class ApiClient {
       }
       return response.data.memories;
     } catch (err) {
-      logger.debug("[API] listMemories failed (continuing without memory injection):", err);
+      logger.logger.debug("[API] listMemories failed (continuing without memory injection):", err);
       return [];
     }
   }
@@ -8863,7 +7390,7 @@ class ApiClient {
   async getVendorToken(vendor) {
     try {
       const response = await axios.get(
-        `${configuration.serverUrl}/v1/connect/${vendor}/token`,
+        `${logger.configuration.serverUrl}/v1/connect/${vendor}/token`,
         {
           headers: {
             "Authorization": `Bearer ${this.credential.token}`,
@@ -8873,13 +7400,13 @@ class ApiClient {
         }
       );
       if (response.status === 404) {
-        logger.debug(`[API] No vendor token found for ${vendor}`);
+        logger.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:`, {
+      logger.logger.debug(`[API] Raw vendor token response:`, {
         status: response.status,
         dataKeys: Object.keys(response.data || {}),
         hasToken: "token" in (response.data || {}),
@@ -8891,153 +7418,62 @@ class ApiClient {
           try {
             tokenData = JSON.parse(response.data.token);
           } catch (parseError) {
-            logger.debug(`[API] Failed to parse token as JSON, using as string:`, parseError);
+            logger.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`);
+          logger.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`);
+          logger.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}`);
+        logger.logger.debug(`[API] Token data is null for ${vendor}`);
         return null;
       }
-      logger.debug(`[API] Vendor token for ${vendor} retrieved successfully`, {
+      logger.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}`);
+        logger.logger.debug(`[API] No vendor token found for ${vendor}`);
         return null;
       }
-      logger.debug(`[API] [ERROR] Failed to get vendor token:`, error);
+      logger.logger.debug(`[API] [ERROR] Failed to get vendor token:`, error);
       return null;
     }
   }
 }
 
 var api = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ApiClient: ApiClient
+  __proto__: null,
+  ApiClient: ApiClient
 });
 
-const UsageSchema = z.z.object({
-  input_tokens: z.z.number().int().nonnegative(),
-  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
-  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
-  output_tokens: z.z.number().int().nonnegative(),
-  service_tier: z.z.string().nullish()
-}).passthrough();
-const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
-  // User message - validates uuid and message.content
-  z.z.object({
-    type: z.z.literal("user"),
-    isSidechain: z.z.boolean().optional(),
-    isMeta: z.z.boolean().optional(),
-    uuid: z.z.string(),
-    // Used in getMessageKey()
-    message: z.z.object({
-      content: z.z.union([z.z.string(), z.z.any()])
-      // Used in sessionScanner.ts
-    }).passthrough()
-  }).passthrough(),
-  // Assistant message - only validates uuid and type
-  // message object is optional to handle synthetic error messages (isApiErrorMessage: true)
-  // which may have different structure than normal assistant messages
-  z.z.object({
-    uuid: z.z.string(),
-    type: z.z.literal("assistant"),
-    message: z.z.object({
-      usage: UsageSchema.optional(),
-      // Used in apiSession.ts
-      model: z.z.string().optional()
-      // Used for cost calculation
-    }).passthrough().optional()
-  }).passthrough(),
-  // Summary message - validates summary and leafUuid
-  z.z.object({
-    type: z.z.literal("summary"),
-    summary: z.z.string(),
-    // Used in apiSession.ts
-    leafUuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough(),
-  // System message - validates uuid
-  z.z.object({
-    type: z.z.literal("system"),
-    uuid: z.z.string()
-    // Used in getMessageKey()
-  }).passthrough(),
-  // Progress message - hook progress events, not counted toward message limits
-  z.z.object({
-    type: z.z.literal("progress"),
-    uuid: z.z.string()
-  }).passthrough()
-]);
-
 exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
 exports.AsyncLock = AsyncLock;
-exports.GEMINI_MODEL_MODES = GEMINI_MODEL_MODES;
 exports.GeminiSessionWriter = GeminiSessionWriter;
 exports.InvalidateSync = InvalidateSync;
-exports.MODEL_MODE_DEFAULT = MODEL_MODE_DEFAULT;
-exports.RawJSONLinesSchema = RawJSONLinesSchema;
-exports.acquireDaemonLock = acquireDaemonLock;
 exports.api = api;
 exports.buildResumeContextFromSessionLog = buildResumeContextFromSessionLog;
-exports.clearCredentials = clearCredentials;
-exports.clearDaemonState = clearDaemonState;
-exports.clearMachineId = clearMachineId;
-exports.configuration = configuration;
 exports.connectionState = connectionState;
-exports.decodeBase64 = decodeBase64;
-exports.decrypt = decrypt;
-exports.decryptLegacy = decryptLegacy;
-exports.decryptWithDataKey = decryptWithDataKey;
-exports.delay = delay;
-exports.encodeBase64 = encodeBase64;
-exports.encodeBase64Url = encodeBase64Url;
-exports.encrypt = encrypt;
 exports.extractUserText = extractUserText;
 exports.findClaudeProjectId = findClaudeProjectId;
 exports.findCodexSessionFile = findCodexSessionFile;
 exports.generateStableUuid = generateStableUuid;
-exports.getLatestDaemonLog = getLatestDaemonLog;
-exports.getProfileEnvironmentVariables = getProfileEnvironmentVariables;
-exports.isDebug = isDebug;
-exports.isModelModeForAgent = isModelModeForAgent;
 exports.isSystemMessage = isSystemMessage;
-exports.libsodiumPublicKeyFromSecretKey = libsodiumPublicKeyFromSecretKey;
-exports.logger = logger;
-exports.packageJson = packageJson;
-exports.parseClaudeModelMode = parseClaudeModelMode;
-exports.parseCodexModelMode = parseCodexModelMode;
-exports.persistence = persistence;
-exports.projectPath = projectPath;
-exports.readCachedSessionKey = readCachedSessionKey;
-exports.readCredentials = readCredentials;
-exports.readDaemonState = readDaemonState;
 exports.readGeminiSessionLog = readGeminiSessionLog;
-exports.readSettings = readSettings;
-exports.releaseDaemonLock = releaseDaemonLock;
 exports.resolveToolsDir = resolveToolsDir;
 exports.saveDiffRecords = saveDiffRecords;
 exports.saveToolOutputRecord = saveToolOutputRecord;
 exports.startOfflineReconnection = startOfflineReconnection;
-exports.updateSettings = updateSettings;
-exports.validateProfileForAgent = validateProfileForAgent;
-exports.writeCredentialsDataKey = writeCredentialsDataKey;
-exports.writeCredentialsLegacy = writeCredentialsLegacy;
-exports.writeDaemonState = writeDaemonState;