u-foo 1.5.0 → 1.7.0

package/src/chat/daemonMessageRouter.js

@@ -25,8 +25,17 @@ function createDaemonMessageRouter(options = {}) {
     appendStreamDelta = () => {},
     finalizeStream = () => {},
     hasStream = () => false,
+    setTransientAgentState = () => {},
+    clearTransientAgentState = () => {},
+    refreshDashboard = () => {},
   } = options;
 
+  function isLikelySubscriberId(value) {
+    const text = String(value || "");
+    if (!text) return false;
+    return text.includes(":") && !text.includes(" ");
+  }
+
   function normalizeDisplayMessage(raw) {
     let displayMessage = raw || "";
     let streamPayload = null;
@@ -53,6 +62,14 @@ function createDaemonMessageRouter(options = {}) {
     if (typeof data.phase === "string") {
       const text = data.text || "";
       const item = { key: data.key, text };
+      const key = typeof data.key === "string" ? data.key : "";
+      if (isLikelySubscriberId(key)) {
+        if (data.phase === BUS_STATUS_PHASES.START) {
+          setTransientAgentState(key, "working");
+        } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
+          clearTransientAgentState(key);
+        }
+      }
       if (data.phase === BUS_STATUS_PHASES.START) {
         enqueueBusStatus(item);
       } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
@@ -66,6 +83,7 @@ function createDaemonMessageRouter(options = {}) {
       } else {
         enqueueBusStatus(item);
       }
+      refreshDashboard();
       renderScreen();
       return false;
     }
@@ -301,6 +319,10 @@ function createDaemonMessageRouter(options = {}) {
 
   function handleBusMessage(msg) {
     const data = msg.data || {};
+    if (data.event === "activity_state_changed") {
+      requestStatus();
+      return true;
+    }
     const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
     const publisher = data.publisher && data.publisher !== "unknown"
       ? data.publisher

package/src/chat/daemonTransport.js

@@ -11,6 +11,7 @@ function createDaemonTransport(options = {}) {
     secondaryRetries = DAEMON_TRANSPORT_DEFAULTS.secondaryRetries,
     retryDelayMs = DAEMON_TRANSPORT_DEFAULTS.retryDelayMs,
     restartDelayMs = DAEMON_TRANSPORT_DEFAULTS.restartDelayMs,
+    connectTimeoutMs = DAEMON_TRANSPORT_DEFAULTS.connectTimeoutMs,
   } = options;
 
   let activeProjectRoot = projectRoot;
@@ -25,14 +26,24 @@ function createDaemonTransport(options = {}) {
 
   async function connectClientForTarget(override = {}) {
     const target = resolveTarget(override);
-    let client = await connectWithRetry(target.sockPath, primaryRetries, retryDelayMs);
+    let client = await connectWithRetry(
+      target.sockPath,
+      primaryRetries,
+      retryDelayMs,
+      { timeoutMs: connectTimeoutMs }
+    );
     if (!client) {
       // Retry once with a fresh daemon start and longer wait.
       if (!isRunning(target.projectRoot)) {
         startDaemon(target.projectRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }
-      client = await connectWithRetry(target.sockPath, secondaryRetries, retryDelayMs);
+      client = await connectWithRetry(
+        target.sockPath,
+        secondaryRetries,
+        retryDelayMs,
+        { timeoutMs: connectTimeoutMs }
+      );
     }
     return client;
   }

package/src/chat/daemonTransportDefaults.js

@@ -3,6 +3,7 @@ const DAEMON_TRANSPORT_DEFAULTS = {
   secondaryRetries: 50,
   retryDelayMs: 200,
   restartDelayMs: 1000,
+  connectTimeoutMs: 2000,
 };
 
 module.exports = {

package/src/chat/dashboardKeyController.js

@@ -23,6 +23,7 @@ function createDashboardKeyController(options = {}) {
     clampAgentWindow = () => {},
     clampAgentWindowWithSelection = () => {},
     requestProjectSwitch = () => {},
+    requestCloseProject = () => {},
     renderDashboard = () => {},
     renderAgentDashboard = () => {},
     renderScreen = () => {},
@@ -385,6 +386,14 @@ function createDashboardKeyController(options = {}) {
       return true;
     }
 
+    if (key.name === "x" && key.ctrl) {
+      const current = Number.isFinite(state.selectedProjectIndex) ? state.selectedProjectIndex : 0;
+      if (current >= 0 && current < projects.length) {
+        requestCloseProject(current);
+      }
+      return true;
+    }
+
     if (key.name === "down") {
       state.dashboardView = "agents";
       if (!Array.isArray(state.activeAgents) || state.activeAgents.length === 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,13 +38,19 @@ 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");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonTransport } = require("./daemonTransport");
-const { listProjectRuntimes } = require("../projects/registry");
+const { listProjectRuntimes, resolveRuntimeDir } = 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 = {
@@ -718,7 +725,7 @@ async function runChat(projectRoot, options = {}) {
     if (!terminalAdapterRouter) return null;
     const meta = activeAgentMetaMap ? activeAgentMetaMap.get(agentId) : null;
     const agentLaunchMode = (meta && meta.launch_mode) || launchMode || "";
-    return terminalAdapterRouter.getAdapter({ launchMode: agentLaunchMode, agentId });
+    return terminalAdapterRouter.getAdapter({ launchMode: agentLaunchMode, agentId, meta });
   }
 
   function getViewingAgentAdapter() {
@@ -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,33 @@ async function runChat(projectRoot, options = {}) {
     if (daemonCoordinator && daemonCoordinator.isConnected()) {
       requestStatus();
     }
-  }, 30000);
+  }, 5000);
+
+  // Global mode: watch runtime registry for new/removed projects
+  if (globalMode) {
+    const runtimeDir = resolveRuntimeDir();
+    if (!fs.existsSync(runtimeDir)) {
+      fs.mkdirSync(runtimeDir, { recursive: true });
+    }
+    let runtimeWatchDebounce = null;
+    try {
+      const watcher = fs.watch(runtimeDir, () => {
+        if (runtimeWatchDebounce) return;
+        runtimeWatchDebounce = setTimeout(() => {
+          runtimeWatchDebounce = null;
+          const prevCount = projectRuntimes.length;
+          refreshProjectRuntimes();
+          if (projectRuntimes.length !== prevCount) {
+            renderDashboard();
+            screen.render();
+          }
+        }, 300);
+      });
+      screen.on("destroy", () => watcher.close());
+    } catch {
+      // Fallback: ignore if fs.watch not supported
+    }
+  }
   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,
+};