very-happy-cli 0.2.142 → 0.2.144

package/dist/{types-Xd_LJRJN.cjs → types-DZ5c-9f3.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var axios = require('axios');
-var persistence = require('./limits-B3hngubn.cjs');
+var persistence = require('./limits-C_Sklt--.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -1377,6 +1377,40 @@ class RpcHandlerManager {
   }
 }
 
+function describeSocketAckDrop(drop) {
+  switch (drop.reason) {
+    case "no-ack":
+      return "no ack callback on the frame (re-delivered after a transport close?); response dropped";
+    case "handler-threw":
+      return `handler threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+    case "ack-threw":
+      return `ack callback threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+  }
+}
+function safeAck(ack, onDrop) {
+  return (value) => {
+    if (typeof ack !== "function") {
+      onDrop({ reason: "no-ack" });
+      return;
+    }
+    try {
+      ack(value);
+    } catch (error) {
+      onDrop({ reason: "ack-threw", error });
+    }
+  };
+}
+async function answerSocketRequest(ack, run, onDrop) {
+  let value;
+  try {
+    value = await run();
+  } catch (error) {
+    onDrop({ reason: "handler-threw", error });
+    return;
+  }
+  safeAck(ack, onDrop)(value);
+}
+
 function run$1(args, options) {
   const RUNNER_PATH = path.resolve(path.join(projectPath.projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
@@ -3279,7 +3313,11 @@ class ApiSessionClient extends node_events.EventEmitter {
       void this.connectSessionRelay();
     });
     this.socket.on("rpc-request", async (data, callback) => {
-      callback(await this.rpcHandlerManager.handleRequest(data));
+      await answerSocketRequest(
+        callback,
+        () => this.rpcHandlerManager.handleRequest(data),
+        (drop) => persistence.logger.debug(`[API] RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+      );
     });
     this.socket.on("disconnect", (reason) => {
       persistence.logger.debug(`[API] Socket disconnected: ${reason}`);
@@ -3715,9 +3753,14 @@ class ApiSessionClient extends node_events.EventEmitter {
         persistence.logger.debug(`[API] Session connected to regional relay ${assignment.relayId}`);
       });
       relaySocket.on("rpc-request", async (data, callback) => {
-        callback(await this.rpcHandlerManager.handleRequest(data));
+        await answerSocketRequest(
+          callback,
+          () => this.rpcHandlerManager.handleRequest(data),
+          (drop) => persistence.logger.debug(`[API] Relay RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+        );
       });
-      relaySocket.on("session-message-deliver", async (data, callback) => {
+      relaySocket.on("session-message-deliver", async (data, rawCallback) => {
+        const callback = safeAck(rawCallback, (drop) => persistence.logger.debug(`[API] session-message-deliver unanswered \u2014 ${describeSocketAckDrop(drop)}`));
         if (data?.sessionId !== this.sessionId || !Array.isArray(data.messages) || data.messages.length === 0 || data.messages.length > 50) {
           callback({ ok: false, error: "Invalid session message request" });
           return;
@@ -4928,17 +4971,315 @@ function scrubTmuxClientEnv(env) {
   return env;
 }
 
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path$1.join(os$1.homedir(), ".claude");
+const CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+const CODEX_HOME_ENV = "CODEX_HOME";
+const AGENT_HOME_ENV_NAMES = [CLAUDE_CONFIG_DIR_ENV, CODEX_HOME_ENV];
+function expandHomePath(value, homeDir) {
+  const trimmed = value.trim();
+  if (trimmed === "~") return homeDir;
+  if (trimmed.startsWith("~/")) return path$1.join(homeDir, trimmed.slice(2));
+  return path$1.isAbsolute(trimmed) ? trimmed : path$1.resolve(homeDir, trimmed);
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function pick(envName, settingValue, input, defaultRelative) {
+  const fromSettings = nonEmpty(settingValue);
+  if (fromSettings) return { path: expandHomePath(fromSettings, input.homeDir), source: "settings" };
+  const fromShell = nonEmpty(input.loginShellEnv?.[envName]);
+  if (fromShell) return { path: expandHomePath(fromShell, input.homeDir), source: "login-shell" };
+  const fromDaemon = nonEmpty(input.daemonEnv[envName]);
+  if (fromDaemon) return { path: expandHomePath(fromDaemon, input.homeDir), source: "daemon-env" };
+  return { path: path$1.join(input.homeDir, defaultRelative), source: "default" };
+}
+function resolveAgentHomes(input) {
+  return {
+    claudeConfigDir: pick(CLAUDE_CONFIG_DIR_ENV, input.settings.claudeConfigDir, input, ".claude"),
+    codexHome: pick(CODEX_HOME_ENV, input.settings.codexHome, input, ".codex")
+  };
 }
-function getClaudeProjectsRoot() {
-  return path$1.join(getClaudeConfigDir(), "projects");
+function agentHomeEnv(homes) {
+  const env = {};
+  if (homes.claudeConfigDir.source !== "default") env[CLAUDE_CONFIG_DIR_ENV] = homes.claudeConfigDir.path;
+  if (homes.codexHome.source !== "default") env[CODEX_HOME_ENV] = homes.codexHome.path;
+  return env;
 }
-function getProjectPath(workingDirectory) {
-  const projectId = path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  return path$1.join(getClaudeProjectsRoot(), projectId);
+function claudeProjectDirName(workingDirectory) {
+  return path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function claudeConversationPath(configDir, workingDirectory, claudeSessionId) {
+  return path$1.join(configDir, "projects", claudeProjectDirName(workingDirectory), `${claudeSessionId}.jsonl`);
+}
+function agentHomeCandidates(kind, input, homes = resolveAgentHomes(input)) {
+  const envName = kind === "claude" ? CLAUDE_CONFIG_DIR_ENV : CODEX_HOME_ENV;
+  const resolved = kind === "claude" ? homes.claudeConfigDir : homes.codexHome;
+  const raw = [
+    resolved.path,
+    nonEmpty(kind === "claude" ? input.settings.claudeConfigDir : input.settings.codexHome),
+    nonEmpty(input.loginShellEnv?.[envName]),
+    nonEmpty(input.daemonEnv[envName]),
+    path$1.join(input.homeDir, kind === "claude" ? ".claude" : ".codex")
+  ];
+  const out = [];
+  for (const value of raw) {
+    if (!value) continue;
+    const expanded = expandHomePath(value, input.homeDir);
+    if (!out.includes(expanded)) out.push(expanded);
+  }
+  return out;
+}
+function findClaudeConversation(claudeSessionId, workingDirectory, candidates, fileSize) {
+  let best = null;
+  let bestSize = -1;
+  for (let i = 0; i < candidates.length; i++) {
+    const file = claudeConversationPath(candidates[i], workingDirectory, claudeSessionId);
+    const size = fileSize(file);
+    if (size === null || size <= bestSize) continue;
+    best = { home: candidates[i], file, resolved: i === 0 };
+    bestSize = size;
+  }
+  return best;
+}
+function codexRolloutFileMatches(fileName, threadId) {
+  return fileName.startsWith("rollout-") && fileName.endsWith(`-${threadId}.jsonl`);
+}
+function findCodexThread(threadId, candidates, listDir) {
+  const digits = /^\d+$/;
+  for (let i = 0; i < candidates.length; i++) {
+    const sessions = path$1.join(candidates[i], "sessions");
+    for (const year of listDir(sessions).filter((name) => digits.test(name)).sort().reverse()) {
+      for (const month of listDir(path$1.join(sessions, year)).filter((name) => digits.test(name)).sort().reverse()) {
+        for (const day of listDir(path$1.join(sessions, year, month)).filter((name) => digits.test(name)).sort().reverse()) {
+          const dayDir = path$1.join(sessions, year, month, day);
+          const hit = listDir(dayDir).find((name) => codexRolloutFileMatches(name, threadId));
+          if (hit) return { home: candidates[i], file: path$1.join(dayDir, hit), resolved: i === 0 };
+        }
+      }
+    }
+  }
+  return null;
+}
+function describeAgentHome(choice) {
+  const source = {
+    settings: "settings.json",
+    "login-shell": "login shell",
+    "daemon-env": "daemon environment",
+    default: "default"
+  };
+  return `${choice.path} (${source[choice.source]})`;
 }
 
+const LOGIN_SHELL_ENV_MARKER = "__VH_ENV__";
+const LOGIN_SHELL_PROBE_TIMEOUT_MS = 3e3;
+function loginShellProbeScript(names) {
+  const pairs = names.map((name) => `${name} "$${name}"`).join(" ");
+  return `printf '${LOGIN_SHELL_ENV_MARKER}%s=%s\\n' ${pairs}`;
+}
+function parseLoginShellEnv(output, names) {
+  const wanted = new Set(names);
+  const env = {};
+  for (const rawLine of output.split(/\r?\n/)) {
+    const at = rawLine.indexOf(LOGIN_SHELL_ENV_MARKER);
+    if (at < 0) continue;
+    const line = rawLine.slice(at + LOGIN_SHELL_ENV_MARKER.length);
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq);
+    if (!wanted.has(name)) continue;
+    const value = line.slice(eq + 1).trim();
+    env[name] = value ? value : void 0;
+  }
+  return env;
+}
+function probeLoginShellEnv(names, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") return Promise.resolve(null);
+  const shell = (options.shell ?? process.env.SHELL ?? "").trim() || "/bin/sh";
+  const timeoutMs = options.timeoutMs ?? LOGIN_SHELL_PROBE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    let child;
+    try {
+      child = node_child_process.spawn(shell, ["-l", "-i", "-c", loginShellProbeScript(names)], {
+        stdio: ["ignore", "pipe", "ignore"],
+        env: options.env ?? process.env,
+        windowsHide: true
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish(null);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", () => {
+      finish(stdout.includes(LOGIN_SHELL_ENV_MARKER) ? parseLoginShellEnv(stdout, names) : null);
+    });
+  });
+}
+
+const AGENT_HOME_CACHE_MS = 6e4;
+const AGENT_HOME_FAILURE_CACHE_MS = 5 * 6e4;
+let cache = null;
+let inFlight = null;
+let originalDaemonEnv = null;
+function snapshotDaemonEnv() {
+  if (!originalDaemonEnv) {
+    originalDaemonEnv = {};
+    for (const name of AGENT_HOME_ENV_NAMES) originalDaemonEnv[name] = process.env[name];
+  }
+  return originalDaemonEnv;
+}
+async function load(now) {
+  const settings = await persistence.readSettings();
+  const loginShellEnv = await probeLoginShellEnv(AGENT_HOME_ENV_NAMES);
+  const input = {
+    settings: { claudeConfigDir: settings.claudeConfigDir, codexHome: settings.codexHome },
+    daemonEnv: snapshotDaemonEnv(),
+    loginShellEnv,
+    homeDir: os$1.homedir()
+  };
+  const homes = resolveAgentHomes(input);
+  return {
+    input,
+    homes,
+    expiresAt: now + (loginShellEnv ? AGENT_HOME_CACHE_MS : AGENT_HOME_FAILURE_CACHE_MS)
+  };
+}
+async function refreshAgentHomes(now = Date.now()) {
+  if (cache && cache.expiresAt > now) return cache.homes;
+  if (!inFlight) {
+    inFlight = load(now).finally(() => {
+      inFlight = null;
+    });
+  }
+  let entry;
+  try {
+    entry = await inFlight;
+  } catch (error) {
+    persistence.logger.debug("[AGENT HOME] resolve failed, falling back", error);
+    if (cache) return cache.homes;
+    const input = { settings: {}, daemonEnv: snapshotDaemonEnv(), loginShellEnv: null, homeDir: os$1.homedir() };
+    return resolveAgentHomes(input);
+  }
+  const previous = cache?.homes;
+  cache = entry;
+  applyAgentHomesToProcessEnv(entry.homes);
+  if (!previous || previous.claudeConfigDir.path !== entry.homes.claudeConfigDir.path || previous.codexHome.path !== entry.homes.codexHome.path) {
+    persistence.logger.debug(`[AGENT HOME] Claude config dir: ${describeAgentHome(entry.homes.claudeConfigDir)}; Codex home: ${describeAgentHome(entry.homes.codexHome)}`);
+  }
+  return entry.homes;
+}
+function currentAgentHomes() {
+  return cache?.homes ?? null;
+}
+function resetAgentHomesCache() {
+  cache = null;
+  inFlight = null;
+  originalDaemonEnv = null;
+}
+function applyAgentHomesToProcessEnv(homes) {
+  const overlay = agentHomeEnv(homes);
+  for (const name of AGENT_HOME_ENV_NAMES) {
+    const next = overlay[name];
+    if (next === void 0) {
+      const original = snapshotDaemonEnv()[name];
+      if (original === void 0) delete process.env[name];
+      else process.env[name] = original;
+    } else if (process.env[name] !== next) {
+      process.env[name] = next;
+    }
+  }
+}
+function listDirSafe(path) {
+  try {
+    return node_fs.readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function fileSizeSafe(path) {
+  try {
+    const st = node_fs.statSync(path);
+    return st.isFile() ? st.size : null;
+  } catch {
+    return null;
+  }
+}
+function locateClaudeConversation(workingDirectory, claudeSessionId) {
+  const entry = cache;
+  if (!entry) {
+    const input = { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os$1.homedir() };
+    return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", input), fileSizeSafe);
+  }
+  return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", entry.input, entry.homes), fileSizeSafe);
+}
+function locateCodexThread(codexThreadId) {
+  const entry = cache;
+  const input = entry?.input ?? { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os$1.homedir() };
+  return findCodexThread(codexThreadId, agentHomeCandidates("codex", input, entry?.homes), listDirSafe);
+}
+function agentHomeSpawnEnv(input) {
+  const env = {};
+  if (input.claudeSessionId) {
+    const hit = locateClaudeConversation(input.workingDirectory, input.claudeSessionId);
+    if (hit && !hit.resolved) {
+      env[CLAUDE_CONFIG_DIR_ENV] = hit.home;
+      persistence.logger.debug(`[AGENT HOME] Claude conversation ${input.claudeSessionId} found under ${hit.home}; overriding ${CLAUDE_CONFIG_DIR_ENV} for this spawn`);
+    }
+  }
+  if (input.codexThreadId) {
+    const hit = locateCodexThread(input.codexThreadId);
+    if (hit && !hit.resolved) {
+      env[CODEX_HOME_ENV] = hit.home;
+      persistence.logger.debug(`[AGENT HOME] Codex thread ${input.codexThreadId} found under ${hit.home}; overriding ${CODEX_HOME_ENV} for this spawn`);
+    }
+  }
+  return env;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AGENT_HOME_CACHE_MS: AGENT_HOME_CACHE_MS,
+  AGENT_HOME_ENV_NAMES: AGENT_HOME_ENV_NAMES,
+  AGENT_HOME_FAILURE_CACHE_MS: AGENT_HOME_FAILURE_CACHE_MS,
+  CLAUDE_CONFIG_DIR_ENV: CLAUDE_CONFIG_DIR_ENV,
+  CODEX_HOME_ENV: CODEX_HOME_ENV,
+  agentHomeCandidates: agentHomeCandidates,
+  agentHomeEnv: agentHomeEnv,
+  agentHomeSpawnEnv: agentHomeSpawnEnv,
+  claudeConversationPath: claudeConversationPath,
+  claudeProjectDirName: claudeProjectDirName,
+  codexRolloutFileMatches: codexRolloutFileMatches,
+  currentAgentHomes: currentAgentHomes,
+  describeAgentHome: describeAgentHome,
+  expandHomePath: expandHomePath,
+  findClaudeConversation: findClaudeConversation,
+  findCodexThread: findCodexThread,
+  locateClaudeConversation: locateClaudeConversation,
+  locateCodexThread: locateCodexThread,
+  probeLoginShellEnv: probeLoginShellEnv,
+  refreshAgentHomes: refreshAgentHomes,
+  resetAgentHomesCache: resetAgentHomesCache,
+  resolveAgentHomes: resolveAgentHomes
+});
+
 var xtermHeadless = {};
 
 var hasRequiredXtermHeadless;
@@ -11299,7 +11640,8 @@ class WebTerminalManager {
           return false;
         }
       },
-      conversationExists: (cwd, claudeSessionId) => node_fs.existsSync(path$1.join(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
+      // B-478: every Claude config dir the user might have pointed a shell at.
+      conversationExists: (cwd, claudeSessionId) => locateClaudeConversation(cwd, claudeSessionId) !== null,
       // B-273: only consulted for records that were attach terminals.
       // Unbounded: the panel's 50-row cap must not hide a restore target.
       userSessions: record.attachTmux ? this.listUserTmuxSessions(Infinity) : [],
@@ -12649,6 +12991,17 @@ function detectResumeSupport(happyHomeDir = persistence.configuration.happyHomeD
   };
 }
 
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path$1.join(os$1.homedir(), ".claude");
+}
+function getClaudeProjectsRoot() {
+  return path$1.join(getClaudeConfigDir(), "projects");
+}
+function getProjectPath(workingDirectory) {
+  const projectId = path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return path$1.join(getClaudeProjectsRoot(), projectId);
+}
+
 const TITLE_PROMPT_PREFIX = "Summarize the SPECIFIC topic/request of this message into a 3-6 word title";
 const BOARD_ANALYZER_PROMPT_PREFIX = "You are a status analyzer for a task board of coding-agent sessions.";
 const VERY_HAPPY_ONE_SHOT_PROMPT_PREFIXES = [
@@ -15750,7 +16103,11 @@ class ApiMachineClient {
   bindRpcRequestHandler(socket, transport) {
     socket.on("rpc-request", async (data, callback) => {
       persistence.logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
-      callback(await this.rpcHandlerManager.handleRequest(data));
+      await answerSocketRequest(
+        callback,
+        () => this.rpcHandlerManager.handleRequest(data),
+        (drop) => persistence.logger.debug(`[API MACHINE] RPC ${data?.method} via ${transport} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+      );
     });
   }
   bindMachineCommandHandlers(socket) {
@@ -16954,6 +17311,7 @@ const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
+exports.AGENT_HOME_ENV_NAMES = AGENT_HOME_ENV_NAMES;
 exports.AGENT_VERSION_SOURCES = AGENT_VERSION_SOURCES;
 exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
@@ -16971,6 +17329,7 @@ exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.STREAM_DELTA_MAX_CHARS = STREAM_DELTA_MAX_CHARS;
 exports.TITLE_PROMPT_PREFIX = TITLE_PROMPT_PREFIX;
 exports.TurnActivityTracker = TurnActivityTracker;
+exports.agentHomeSpawnEnv = agentHomeSpawnEnv;
 exports.api = api;
 exports.checkIfDaemonRunningAndCleanupStaleState = checkIfDaemonRunningAndCleanupStaleState;
 exports.cleanupDaemonState = cleanupDaemonState;
@@ -16984,13 +17343,16 @@ exports.decideBackfill = decideBackfill;
 exports.decideMirrorBinding = decideMirrorBinding;
 exports.delay = delay;
 exports.deriveLocalCliUpdateSummary = deriveLocalCliUpdateSummary;
+exports.describeAgentHome = describeAgentHome;
 exports.detectCLIAvailability = detectCLIAvailability;
 exports.detectResumeSupport = detectResumeSupport;
 exports.errorLogMetadata = errorLogMetadata;
+exports.expandHomePath = expandHomePath;
 exports.extractCompleteLines = extractCompleteLines;
 exports.fetchCliUpdateState = fetchCliUpdateState;
 exports.getLocalHappyAgentCredentialPath = getLocalHappyAgentCredentialPath;
 exports.getProjectPath = getProjectPath;
+exports.index = index;
 exports.initializeSandbox = initializeSandbox;
 exports.isClaudeSessionId = isClaudeSessionId;
 exports.isDaemonRunningCurrentlyInstalledHappyVersion = isDaemonRunningCurrentlyInstalledHappyVersion;
@@ -16998,6 +17360,7 @@ exports.isValidSessionId = isValidSessionId;
 exports.isValidTerminalId = isValidTerminalId;
 exports.listDaemonSessions = listDaemonSessions;
 exports.listVhTerminals = listVhTerminals;
+exports.locateClaudeConversation = locateClaudeConversation;
 exports.mirrorLineKey = mirrorLineKey;
 exports.mirrorLocalId = mirrorLocalId;
 exports.notifyDaemonClaudeAuthFailed = notifyDaemonClaudeAuthFailed;
@@ -17005,10 +17368,13 @@ exports.notifyDaemonSessionEvent = notifyDaemonSessionEvent;
 exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
 exports.parseExactVersion = parseExactVersion;
 exports.parseTerminalHookPayload = parseTerminalHookPayload;
+exports.probeLoginShellEnv = probeLoginShellEnv;
 exports.pushClipboardViaDaemon = pushClipboardViaDaemon;
 exports.pushFilePreviewViaDaemon = pushFilePreviewViaDaemon;
 exports.readLocalHappyAgentCredentials = readLocalHappyAgentCredentials;
 exports.readVhTerminal = readVhTerminal;
+exports.refreshAgentHomes = refreshAgentHomes;
+exports.resolveAgentHomes = resolveAgentHomes;
 exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
 exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "very-happy-cli",
-  "version": "0.2.142",
+  "version": "0.2.144",
   "description": "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.",
   "author": "Kirill Dubovitskiy",
   "contributors": [
@@ -117,12 +117,12 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "very-happy-tools-arm64-darwin": "0.2.142",
-    "very-happy-tools-x64-darwin": "0.2.142",
-    "very-happy-tools-arm64-linux": "0.2.142",
-    "very-happy-tools-x64-linux": "0.2.142",
-    "very-happy-tools-arm64-win32": "0.2.142",
-    "very-happy-tools-x64-win32": "0.2.142"
+    "very-happy-tools-arm64-darwin": "0.2.144",
+    "very-happy-tools-x64-darwin": "0.2.144",
+    "very-happy-tools-arm64-linux": "0.2.144",
+    "very-happy-tools-x64-linux": "0.2.144",
+    "very-happy-tools-arm64-win32": "0.2.144",
+    "very-happy-tools-x64-win32": "0.2.144"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",