u-foo 1.5.0 → 1.6.0

package/src/chat/dashboardView.js

@@ -22,17 +22,35 @@ function ensureAtPrefix(value) {
   return text.startsWith("@") ? text : `@${text}`;
 }
 
+function activityMarker(state = "") {
+  const normalized = String(state || "").trim().toLowerCase();
+  if (normalized === "working") return "*";
+  if (normalized === "waiting_input") return "?";
+  if (normalized === "blocked") return "!";
+  return "";
+}
+
+function withActivityMarker(label = "", state = "") {
+  const marker = activityMarker(state);
+  if (!marker) return label;
+  return `${marker}${label}`;
+}
+
 function buildSummaryLine(options = {}) {
   const {
     activeAgents = [],
     getAgentLabel = (id) => id,
+    getAgentState = () => "",
     launchMode = "terminal",
     agentProvider = "codex-cli",
     assistantEngine = "auto",
     cronTasks = [],
   } = options;
   const agents = activeAgents.length > 0
-    ? activeAgents.slice(0, 3).map((id) => ensureAtPrefix(getAgentLabel(id))).join(", ") + (activeAgents.length > 3 ? ` +${activeAgents.length - 3}` : "")
+    ? activeAgents.slice(0, 3)
+      .map((id) => withActivityMarker(ensureAtPrefix(getAgentLabel(id)), getAgentState(id)))
+      .join(", ")
+      + (activeAgents.length > 3 ? ` +${activeAgents.length - 3}` : "")
     : "none";
   return `{gray-fg}Agents:{/gray-fg} {cyan-fg}${agents}{/cyan-fg}`
     + `  {gray-fg}Mode:{/gray-fg} {cyan-fg}${launchMode}{/cyan-fg}`
@@ -86,17 +104,13 @@ function buildProjectRailLine(options = {}) {
     const rowRoot = String((row && row.project_root) || "");
     const isActiveProject = Boolean(activeRoot && rowRoot === activeRoot);
     const isSelected = absoluteIndex === safeSelectedIndex;
-    const displayName = isActiveProject ? `[${name}]` : name;
     if (projectsFocused && isSelected) {
-      return `{inverse}${displayName}{/inverse}`;
+      return `{inverse}${name}{/inverse}`;
     }
     if (isActiveProject) {
-      return `{cyan-fg}${displayName}{/cyan-fg}`;
-    }
-    if (isSelected) {
-      return `{inverse}${displayName}{/inverse}`;
+      return `{bold}{cyan-fg}${name}{/cyan-fg}{/bold}`;
     }
-    return `{cyan-fg}${displayName}{/cyan-fg}`;
+    return `{cyan-fg}${name}{/cyan-fg}`;
   });
 
   const leftMore = start > 0 ? "{gray-fg}<{/gray-fg} " : "";
@@ -117,6 +131,7 @@ function buildDashboardDetailLine(options = {}) {
     agentListWindowStart = 0,
     maxAgentWindow = 4,
     getAgentLabel = (id) => id,
+    getAgentState = () => "",
     selectedModeIndex = 0,
     selectedProviderIndex = 0,
     selectedAssistantIndex = 0,
@@ -203,7 +218,10 @@ function buildDashboardDetailLine(options = {}) {
     const visibleAgents = activeAgents.slice(start, end);
     const agentParts = visibleAgents.map((agent, i) => {
       const absoluteIndex = start + i;
-      const label = ensureAtPrefix(getAgentLabel(agent));
+      const label = withActivityMarker(
+        ensureAtPrefix(getAgentLabel(agent)),
+        getAgentState(agent)
+      );
       if (absoluteIndex === selectedAgentIndex) {
         return `{inverse}${label}{/inverse}`;
       }
@@ -238,6 +256,7 @@ function computeDashboardContent(options = {}) {
     agentListWindowStart = 0,
     maxAgentWindow = 4,
     getAgentLabel = (id) => id,
+    getAgentState = () => "",
     launchMode = "terminal",
     agentProvider = "codex-cli",
     assistantEngine = "auto",
@@ -275,6 +294,7 @@ function computeDashboardContent(options = {}) {
       const line2 = buildSummaryLine({
         activeAgents,
         getAgentLabel,
+        getAgentState,
         launchMode,
         agentProvider,
         assistantEngine,
@@ -294,6 +314,7 @@ function computeDashboardContent(options = {}) {
       agentListWindowStart,
       maxAgentWindow,
       getAgentLabel,
+      getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
       selectedAssistantIndex,
@@ -320,6 +341,7 @@ function computeDashboardContent(options = {}) {
       agentListWindowStart,
       maxAgentWindow,
       getAgentLabel,
+      getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
       selectedAssistantIndex,
@@ -337,6 +359,7 @@ function computeDashboardContent(options = {}) {
   content += buildSummaryLine({
     activeAgents,
     getAgentLabel,
+    getAgentState,
     launchMode,
     agentProvider,
     assistantEngine,

package/src/chat/index.js

@@ -38,6 +38,7 @@ const { createChatLogController } = require("./chatLogController");
 const { createPasteController } = require("./pasteController");
 const { createAgentViewController } = require("./agentViewController");
 const { createSettingsController } = require("./settingsController");
+const { createProjectCloseController } = require("./projectCloseController");
 const { createChatLayout } = require("./layout");
 const { createDaemonCoordinator } = require("./daemonCoordinator");
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
@@ -45,6 +46,11 @@ const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonTransport } = require("./daemonTransport");
 const { listProjectRuntimes } = require("../projects/registry");
 const { canonicalProjectRoot, buildProjectId } = require("../projects/projectId");
+const {
+  sortProjectRuntimes,
+  parseTimestampMs,
+  filterVisibleProjectRuntimes,
+} = require("./projectRuntimes");
 
 async function runChat(projectRoot, options = {}) {
   const globalMode = options && options.globalMode === true;
@@ -655,6 +661,7 @@ async function runChat(projectRoot, options = {}) {
   let activeAgents = [];
   let activeAgentLabelMap = new Map();
   let activeAgentMetaMap = new Map(); // Store full meta including launch_mode
+  const transientAgentStateMap = new Map();
   let agentListWindowStart = 0;
   const MAX_AGENT_WINDOW = 4;
   let projectRuntimes = [];
@@ -698,7 +705,7 @@ async function runChat(projectRoot, options = {}) {
     cron: "Ctrl+X close · ↑ back",
     resume: "",
     projects: "Use /project switch <index|path>",
-    projectsFocus: "←/→ switch · ↓ second row · Enter confirm · ↑ back",
+    projectsFocus: "←/→ switch · Ctrl+X close · ↓ second row · Enter confirm · ↑ back",
     projectsEmpty: "Run ufoo chat or ufoo daemon start in project directories",
   };
   const AGENT_BAR_HINTS = {
@@ -927,6 +934,7 @@ async function runChat(projectRoot, options = {}) {
     } catch {
       rows = [];
     }
+    rows = filterVisibleProjectRuntimes(rows);
     const normalizedActive = String(activeProjectRoot || "");
     if (
       normalizedActive
@@ -939,7 +947,27 @@ async function runChat(projectRoot, options = {}) {
         last_seen: null,
       });
     }
-    projectRuntimes = rows;
+    projectRuntimes = sortProjectRuntimes({
+      rows,
+      activeProjectRoot: normalizedActive,
+      resolveProjectRoot: resolveRuntimeProjectRoot,
+      getInteractionMs: (row) => {
+        const rowRoot = resolveRuntimeProjectRoot(row);
+        if (!rowRoot) return 0;
+        try {
+          const historyContext = resolveHistoryContext(rowRoot);
+          if (historyContext && historyContext.historyFile && fs.existsSync(historyContext.historyFile)) {
+            const stat = fs.statSync(historyContext.historyFile);
+            if (Number.isFinite(stat.mtimeMs) && stat.mtimeMs > 0) {
+              return stat.mtimeMs;
+            }
+          }
+        } catch {
+          // fall through
+        }
+        return parseTimestampMs(row && row.last_seen);
+      },
+    });
 
     if (projectRuntimes.length === 0) {
       selectedProjectIndex = -1;
@@ -1040,8 +1068,6 @@ async function runChat(projectRoot, options = {}) {
       logMessage("error", "{white-fg}✗{/white-fg} No agent selected");
       return;
     }
-    const label = getAgentLabel(agentId);
-    logMessage("status", `{white-fg}⚙{/white-fg} Closing ${label}...`);
     send({ type: IPC_REQUEST_TYPES.CLOSE_AGENT, agent_id: agentId });
   }
 
@@ -1135,6 +1161,18 @@ async function runChat(projectRoot, options = {}) {
       agentListWindowStart,
       maxAgentWindow: MAX_AGENT_WINDOW,
       getAgentLabel,
+      getAgentState: (agentId) => {
+        let metaState = "";
+        if (activeAgentMetaMap) {
+          const meta = activeAgentMetaMap.get(agentId);
+          metaState = meta && typeof meta.activity_state === "string"
+            ? String(meta.activity_state).trim()
+            : "";
+        }
+        if (metaState) return metaState;
+        const transientState = transientAgentStateMap.get(agentId);
+        return typeof transientState === "string" ? transientState : "";
+      },
       launchMode,
       agentProvider,
       assistantEngine,
@@ -1162,8 +1200,36 @@ async function runChat(projectRoot, options = {}) {
     dashboard.setContent(dashboardContent);
   }
 
+  function readDiskMetaForActiveAgents(activeList = []) {
+    const map = new Map();
+    const ids = Array.isArray(activeList) ? activeList : [];
+    if (ids.length === 0) return map;
+    try {
+      const busPath = getUfooPaths(activeProjectRoot).agentsFile;
+      if (!fs.existsSync(busPath)) return map;
+      const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+      const agents = bus && bus.agents && typeof bus.agents === "object" ? bus.agents : {};
+      for (const id of ids) {
+        const meta = agents[id];
+        if (!meta || typeof meta !== "object") continue;
+        map.set(id, meta);
+      }
+    } catch {
+      // ignore disk fallback errors
+    }
+    return map;
+  }
+
   function updateDashboard(status) {
     activeAgents = status.active || [];
+    if (transientAgentStateMap.size > 0) {
+      const activeSet = new Set(activeAgents);
+      for (const id of transientAgentStateMap.keys()) {
+        if (!activeSet.has(id)) {
+          transientAgentStateMap.delete(id);
+        }
+      }
+    }
     if (globalMode) {
       refreshProjectRuntimes();
     }
@@ -1187,7 +1253,35 @@ async function runChat(projectRoot, options = {}) {
     }
     const maps = agentDirectory.buildAgentMaps(activeAgents, metaList, fallbackMap);
     activeAgentLabelMap = maps.labelMap;
-    activeAgentMetaMap = maps.metaMap;
+    const diskMetaMap = readDiskMetaForActiveAgents(activeAgents);
+    if (diskMetaMap.size > 0) {
+      const mergedMetaMap = new Map(maps.metaMap);
+      for (const id of activeAgents) {
+        const currentMeta = mergedMetaMap.get(id);
+        const diskMeta = diskMetaMap.get(id);
+        if (!currentMeta && diskMeta) {
+          mergedMetaMap.set(id, { id, ...diskMeta });
+          continue;
+        }
+        if (!currentMeta || !diskMeta) continue;
+        const currentState = typeof currentMeta.activity_state === "string"
+          ? String(currentMeta.activity_state).trim()
+          : "";
+        const diskState = typeof diskMeta.activity_state === "string"
+          ? String(diskMeta.activity_state).trim()
+          : "";
+        if (!currentState && diskState) {
+          mergedMetaMap.set(id, {
+            ...currentMeta,
+            activity_state: diskState,
+            activity_since: currentMeta.activity_since || diskMeta.activity_since || "",
+          });
+        }
+      }
+      activeAgentMetaMap = mergedMetaMap;
+    } else {
+      activeAgentMetaMap = maps.metaMap;
+    }
     clampAgentWindow();
     // If viewing agent went offline, exit view
     const currentView = getCurrentView();
@@ -1320,6 +1414,7 @@ async function runChat(projectRoot, options = {}) {
     clampAgentWindow,
     clampAgentWindowWithSelection,
     requestProjectSwitch: requestProjectSwitchByIndex,
+    requestCloseProject: requestCloseProjectByIndex,
     renderDashboard,
     renderAgentDashboard,
     renderScreen: () => screen.render(),
@@ -1379,6 +1474,15 @@ async function runChat(projectRoot, options = {}) {
       agentListWindowStart = value;
     },
     getAgentLabel,
+    getAgentStates: () => {
+      const states = {};
+      if (activeAgentMetaMap) {
+        for (const [id, meta] of activeAgentMetaMap) {
+          if (meta && meta.activity_state) states[id] = meta.activity_state;
+        }
+      }
+      return states;
+    },
     setDashboardView: (value) => {
       dashboardView = value;
     },
@@ -1444,6 +1548,21 @@ async function runChat(projectRoot, options = {}) {
     appendStreamDelta,
     finalizeStream,
     hasStream: (publisher) => streamTracker.hasStream(publisher),
+    setTransientAgentState: (agentId, state) => {
+      if (!agentId || !state) return;
+      transientAgentStateMap.set(agentId, state);
+    },
+    clearTransientAgentState: (agentId) => {
+      if (!agentId) return;
+      transientAgentStateMap.delete(agentId);
+    },
+    refreshDashboard: () => {
+      if (getCurrentView() === "agent") {
+        renderAgentDashboard();
+        return;
+      }
+      renderDashboard();
+    },
   });
 
   daemonCoordinator = createDaemonCoordinator({
@@ -1677,6 +1796,29 @@ async function runChat(projectRoot, options = {}) {
     return { ok: false, error: "switch did not complete" };
   }
 
+  const projectCloseController = createProjectCloseController({
+    getProjects: () => projectRuntimes,
+    getActiveProjectRoot: () => activeProjectRoot,
+    resolveProjectRoot: resolveRuntimeProjectRoot,
+    isRunning,
+    stopDaemon,
+    switchProject: (targetProjectRoot) => requestProjectSwitchByTarget(targetProjectRoot),
+    refreshProjects: () => {
+      if (!globalMode) return;
+      refreshProjectRuntimes();
+      syncSelectedProjectToActive();
+    },
+    renderDashboard,
+    renderScreen: () => screen.render(),
+    logMessage,
+    escapeBlessed,
+  });
+
+  function requestCloseProjectByIndex(index) {
+    if (!globalMode) return;
+    void projectCloseController.requestCloseProject(index);
+  }
+
   const commandExecutor = createCommandExecutor({
     projectRoot,
     parseCommand,
@@ -1856,7 +1998,7 @@ async function runChat(projectRoot, options = {}) {
     if (daemonCoordinator && daemonCoordinator.isConnected()) {
       requestStatus();
     }
-  }, 30000);
+  }, 5000);
   screen.on("resize", () => {
     if (handleResizeInAgentView()) {
       return;

package/src/chat/projectCloseController.js

@@ -0,0 +1,119 @@
+function normalizeIndex(value, length) {
+  const parsed = Number(value);
+  const nextIndex = Number.isFinite(parsed) ? Math.trunc(parsed) : Number.NaN;
+  if (!Number.isFinite(nextIndex) || nextIndex < 0 || nextIndex >= length) {
+    return -1;
+  }
+  return nextIndex;
+}
+
+function defaultResolveProjectRoot(row = {}) {
+  return String((row && row.project_root) || "");
+}
+
+function createProjectCloseController(options = {}) {
+  const {
+    getProjects = () => [],
+    getActiveProjectRoot = () => "",
+    resolveProjectRoot = defaultResolveProjectRoot,
+    isRunning = () => false,
+    stopDaemon = () => false,
+    switchProject = async () => ({ ok: false, error: "project switching unavailable" }),
+    refreshProjects = () => {},
+    renderDashboard = () => {},
+    renderScreen = () => {},
+    logMessage = () => {},
+    escapeBlessed = (value) => String(value || ""),
+  } = options;
+
+  let closingProject = false;
+
+  function pickFallbackProjectRoot(targetProjectRoot) {
+    const rows = Array.isArray(getProjects()) ? getProjects() : [];
+    for (const row of rows) {
+      const root = resolveProjectRoot(row);
+      if (!root || root === targetProjectRoot) continue;
+      return root;
+    }
+    return "";
+  }
+
+  async function requestCloseProject(index) {
+    if (closingProject) {
+      return { ok: false, error: "project close already in progress" };
+    }
+
+    const rows = Array.isArray(getProjects()) ? getProjects() : [];
+    const nextIndex = normalizeIndex(index, rows.length);
+    if (nextIndex < 0) {
+      return { ok: false, error: "project index out of range" };
+    }
+
+    const target = rows[nextIndex] || {};
+    const projectRoot = resolveProjectRoot(target);
+    if (!projectRoot) {
+      return { ok: false, error: "project root unavailable" };
+    }
+
+    const projectName = String(target.project_name || projectRoot);
+    const escapedName = escapeBlessed(projectName);
+    const activeProjectRoot = String(getActiveProjectRoot() || "");
+
+    closingProject = true;
+    try {
+      logMessage("status", `{white-fg}⚙{/white-fg} Closing project ${escapedName} daemon and agents...`);
+
+      let switchedTo = "";
+      if (activeProjectRoot === projectRoot) {
+        const fallbackRoot = pickFallbackProjectRoot(projectRoot);
+        if (!fallbackRoot) {
+          const error = "Cannot close current project; switch to another project first";
+          logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(error)}`);
+          return { ok: false, error };
+        }
+
+        const switched = await Promise.resolve(switchProject(fallbackRoot));
+        if (!switched || switched.ok !== true) {
+          const reason = String((switched && switched.error) || "switch failed");
+          logMessage("error", `{white-fg}✗{/white-fg} Failed to switch project before close: ${escapeBlessed(reason)}`);
+          return { ok: false, error: reason };
+        }
+        switchedTo = fallbackRoot;
+      }
+
+      const wasRunning = Boolean(isRunning(projectRoot));
+      stopDaemon(projectRoot);
+
+      refreshProjects();
+      renderDashboard();
+      renderScreen();
+
+      if (wasRunning) {
+        logMessage("status", `{white-fg}✓{/white-fg} Closed project ${escapedName} daemon and agents`);
+      } else {
+        logMessage("status", `{white-fg}✓{/white-fg} Project ${escapedName} daemon already stopped`);
+      }
+
+      return {
+        ok: true,
+        project_root: projectRoot,
+        switched_to: switchedTo || undefined,
+      };
+    } catch (err) {
+      const message = err && err.message ? err.message : String(err || "project close failed");
+      logMessage("error", `{white-fg}✗{/white-fg} Failed to close project: ${escapeBlessed(message)}`);
+      return { ok: false, error: message };
+    } finally {
+      closingProject = false;
+    }
+  }
+
+  return {
+    requestCloseProject,
+    pickFallbackProjectRoot,
+  };
+}
+
+module.exports = {
+  createProjectCloseController,
+};

package/src/chat/projectRuntimes.js

@@ -0,0 +1,55 @@
+function parseTimestampMs(value) {
+  const parsed = Date.parse(String(value || ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function projectLabel(row = {}) {
+  return String(row.project_name || row.project_root || "");
+}
+
+function normalizeInteractionMs(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num < 0) return 0;
+  return num;
+}
+
+function filterVisibleProjectRuntimes(rows = []) {
+  const sourceRows = Array.isArray(rows) ? rows : [];
+  return sourceRows.filter((row) => {
+    const status = String((row && row.status) || "").trim().toLowerCase();
+    return status !== "stopped";
+  });
+}
+
+function sortProjectRuntimes(options = {}) {
+  const {
+    rows = [],
+    activeProjectRoot = "",
+    resolveProjectRoot = (row) => String((row && row.project_root) || ""),
+    getInteractionMs = () => 0,
+  } = options;
+  const sourceRows = Array.isArray(rows) ? rows.slice() : [];
+  // Keep arg usage for backward compatibility with existing callers/tests.
+  void activeProjectRoot;
+  void resolveProjectRoot;
+
+  sourceRows.sort((a, b) => {
+    const bInteraction = normalizeInteractionMs(getInteractionMs(b));
+    const aInteraction = normalizeInteractionMs(getInteractionMs(a));
+    if (bInteraction !== aInteraction) return bInteraction - aInteraction;
+
+    const bSeen = parseTimestampMs(b && b.last_seen);
+    const aSeen = parseTimestampMs(a && a.last_seen);
+    if (bSeen !== aSeen) return bSeen - aSeen;
+
+    return projectLabel(a).localeCompare(projectLabel(b), "en", { sensitivity: "base" });
+  });
+
+  return sourceRows;
+}
+
+module.exports = {
+  sortProjectRuntimes,
+  parseTimestampMs,
+  filterVisibleProjectRuntimes,
+};

package/src/chat/statusLineController.js

@@ -107,20 +107,66 @@ function createStatusLineController(options = {}) {
     renderStatusLine();
   }
 
-  function queueStatusLine(text) {
-    pendingStatusLines.push(text || "");
+  function normalizePendingItem(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    return {
+      text: text || "",
+      key,
+    };
+  }
+
+  function headPendingText() {
+    if (pendingStatusLines.length === 0) return "";
+    const item = pendingStatusLines[0];
+    return item && typeof item.text === "string" ? item.text : "";
+  }
+
+  function queueStatusLine(text, options = {}) {
+    const item = normalizePendingItem(text, options);
+    if (item.key) {
+      const existingIndex = pendingStatusLines.findIndex((entry) => entry.key === item.key);
+      if (existingIndex >= 0) {
+        pendingStatusLines[existingIndex] = item;
+        if (existingIndex === 0) {
+          setPrimaryStatus(item.text, { pending: true });
+          renderScreen();
+        }
+        return;
+      }
+    }
+
+    pendingStatusLines.push(item);
     if (pendingStatusLines.length === 1) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      setPrimaryStatus(item.text, { pending: true });
       renderScreen();
     }
   }
 
-  function resolveStatusLine(text) {
+  function resolveStatusLine(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    let removedHead = false;
+
     if (pendingStatusLines.length > 0) {
-      pendingStatusLines.shift();
+      if (key) {
+        const index = pendingStatusLines.findIndex((entry) => entry.key === key);
+        if (index >= 0) {
+          pendingStatusLines.splice(index, 1);
+          removedHead = index === 0;
+        }
+      } else {
+        pendingStatusLines.shift();
+        removedHead = true;
+      }
     }
+
     if (pendingStatusLines.length > 0) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      if (removedHead || !primaryStatusPending) {
+        setPrimaryStatus(headPendingText(), { pending: true });
+      }
     } else {
       setPrimaryStatus(text || "", { pending: false });
     }

package/src/chat/transport.js

@@ -3,10 +3,46 @@ const path = require("path");
 const fs = require("fs");
 const { spawn, spawnSync } = require("child_process");
 
-function connectSocket(sockPath) {
+function connectSocket(sockPath, options = {}) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+    ? Math.trunc(options.timeoutMs)
+    : 0;
   return new Promise((resolve, reject) => {
-    const client = net.createConnection(sockPath, () => resolve(client));
-    client.on("error", reject);
+    let timeoutHandle = null;
+    const client = net.createConnection(sockPath, () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      resolve(client);
+    });
+
+    const cleanup = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+      }
+    };
+
+    client.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+
+    if (timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        const err = new Error(`connect timeout after ${timeoutMs}ms`);
+        err.code = "ETIMEDOUT";
+        try {
+          client.destroy(err);
+        } catch {
+          // ignore
+        }
+        reject(err);
+      }, timeoutMs);
+      if (typeof timeoutHandle.unref === "function") {
+        timeoutHandle.unref();
+      }
+    }
   });
 }
 
@@ -38,11 +74,11 @@ function stopDaemon(projectRoot) {
   });
 }
 
-async function connectWithRetry(sockPath, retries, delayMs) {
+async function connectWithRetry(sockPath, retries, delayMs, options = {}) {
   for (let i = 0; i < retries; i += 1) {
     try {
       // eslint-disable-next-line no-await-in-loop
-      const client = await connectSocket(sockPath);
+      const client = await connectSocket(sockPath, options);
       return client;
     } catch {
       // eslint-disable-next-line no-await-in-loop