u-foo 2.3.31 → 2.4.0

package/src/{daemon → runtime/daemon}/index.js

@@ -2,22 +2,22 @@ const fs = require("fs");
 const path = require("path");
 const net = require("net");
 const { spawn, spawnSync } = require("child_process");
-const { runUfooAgent, runUfooRouteAgent } = require("../agent/ufooAgent");
+const { runUfooAgent, runUfooRouteAgent } = require("../../agents/controller/ufooAgent");
 const { launchAgent, closeAgent, getRecoverableAgents, resumeAgents } = require("./ops");
 const { buildStatus } = require("./status");
-const EventBus = require("../bus");
+const EventBus = require("../../coordination/bus");
 const { AgentProcessManager } = require("./agentProcessManager");
-const NicknameManager = require("../bus/nickname");
-const { generateInstanceId, subscriberToSafeName } = require("../bus/utils");
+const NicknameManager = require("../../coordination/bus/nickname");
+const { generateInstanceId, subscriberToSafeName } = require("../../coordination/bus/utils");
 const { createDaemonIpcServer } = require("./ipcServer");
-const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
-const { getUfooPaths } = require("../ufoo/paths");
+const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../contracts/eventContract");
+const { getUfooPaths } = require("../../coordination/state/paths");
 const { upsertProjectRuntime, markProjectStopped } = require("../projects");
-const { scheduleProviderSessionProbe, resolveSessionFromFile, persistProviderSession, loadProviderSessionCache } = require("./providerSessions");
+const { scheduleProviderSessionResolve, resolveSessionFromFile, persistProviderSession, loadProviderSessionCache } = require("./providerSessions");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
 const { createGroupOrchestrator } = require("./groupOrchestrator");
-const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromRuntime } = require("../group/diagram");
+const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromRuntime } = require("../../orchestration/groups/diagram");
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
 const { recordAgentReport } = require("./reporting");
@@ -36,9 +36,10 @@ const {
   resolveDisplayNickname,
   resolveScopedNickname,
 } = require("./nicknameScope");
+const { resolveNodeExecutable } = require("../process/nodeExecutable");
 
 let providerSessions = null;
-let probeHandles = new Map();
+let sessionResolveHandles = new Map();
 let daemonCronController = null;
 let daemonGroupOrchestrator = null;
 const PROJECT_RUNTIME_HEARTBEAT_MS = 10 * 1000;
@@ -52,6 +53,7 @@ function normalizeBusAgentType(agentType = "") {
   if (!value) return "claude-code";
   if (value === "codex") return "codex";
   if (value === "claude" || value === "claude-code") return "claude-code";
+  if (value === "agy" || value === "antigravity") return "agy";
   if (value === "ufoo" || value === "ucode" || value === "ufoo-code") return "ufoo-code";
   return value;
 }
@@ -60,6 +62,7 @@ function normalizeLaunchAgent(agent = "") {
   const value = String(agent || "").trim().toLowerCase();
   if (value === "codex") return "codex";
   if (value === "claude" || value === "claude-code") return "claude";
+  if (value === "agy" || value === "antigravity") return "agy";
   if (value === "ufoo" || value === "ucode" || value === "ufoo-code") return "ufoo";
   return "";
 }
@@ -124,6 +127,15 @@ function logPath(projectRoot) {
   return getUfooPaths(projectRoot).ufooDaemonLog;
 }
 
+function appendControlLog(projectRoot, msg) {
+  try {
+    ensureDir(path.dirname(logPath(projectRoot)));
+    fs.appendFileSync(logPath(projectRoot), `[daemon-control] ${new Date().toISOString()} ${msg}\n`);
+  } catch {
+    // ignore control logging errors
+  }
+}
+
 function writePid(projectRoot) {
   fs.writeFileSync(pidPath(projectRoot), String(process.pid));
 }
@@ -151,6 +163,10 @@ function checkPid(pid) {
   }
 }
 
+function pidAlive(pid) {
+  return checkPid(pid).alive;
+}
+
 function readProcessArgs(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return "";
   try {
@@ -171,6 +187,32 @@ function readProcessArgs(pid) {
   return "";
 }
 
+function readProcessCwd(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return "";
+  try {
+    const res = spawnSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (!res || res.status !== 0 || !res.stdout) return "";
+    for (const line of String(res.stdout || "").split(/\r?\n/)) {
+      if (line.startsWith("n")) return line.slice(1);
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function sameProjectRoot(a, b) {
+  if (!a || !b) return false;
+  try {
+    return fs.realpathSync(a) === fs.realpathSync(b);
+  } catch {
+    return path.resolve(a) === path.resolve(b);
+  }
+}
+
 function isLikelyDaemonProcess(pid) {
   const args = readProcessArgs(pid);
   if (!args || args === "__EPERM__") return null;
@@ -178,10 +220,41 @@ function isLikelyDaemonProcess(pid) {
   const hasCliPattern = /\bufoo\s+daemon\s+(--start|start)\b/.test(text);
   const hasNodePattern = /\bufoo\.js\s+daemon\s+(--start|start)\b/.test(text);
   if (hasCliPattern || hasNodePattern) return true;
-  if (text.includes("/src/daemon/run.js")) return true;
+  if (text.includes("/src/runtime/daemon/run.js")) return true;
   return false;
 }
 
+function isPidFileDaemonForProject(projectRoot, pid, socketOwnerPids = new Set()) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  if (socketOwnerPids.has(pid)) return true;
+  if (looksLikeRunningDaemon(projectRoot, pid)) return true;
+  if (isLikelyDaemonProcess(pid) !== true) return false;
+  const cwd = readProcessCwd(pid);
+  return sameProjectRoot(cwd, projectRoot);
+}
+
+function socketOwnerDaemonPids(projectRoot) {
+  const sock = socketPath(projectRoot);
+  const out = new Set();
+  try {
+    const res = spawnSync("lsof", ["-nP", "-U"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (!res || res.status !== 0 || !res.stdout) return [];
+    for (const line of String(res.stdout || "").split(/\r?\n/)) {
+      if (!line.includes(sock)) continue;
+      const parts = line.trim().split(/\s+/);
+      const pid = parseInt(parts[1], 10);
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      if (isLikelyDaemonProcess(pid) === true) out.add(pid);
+    }
+  } catch {
+    // ignore lsof failures; pid file fallback still applies
+  }
+  return Array.from(out);
+}
+
 function looksLikeRunningDaemon(projectRoot, pid) {
   const state = checkPid(pid);
   if (!state.alive) return false;
@@ -216,6 +289,16 @@ function cleanupStaleState(projectRoot) {
   removeSocket(projectRoot);
 }
 
+function removePidIfOwned(projectRoot, expectedPid = process.pid) {
+  const pid = readPid(projectRoot);
+  if (pid !== expectedPid) return;
+  try {
+    fs.unlinkSync(pidPath(projectRoot));
+  } catch {
+    // ignore cleanup errors
+  }
+}
+
 function removeSocket(projectRoot) {
   const sock = socketPath(projectRoot);
   if (fs.existsSync(sock)) fs.unlinkSync(sock);
@@ -528,17 +611,15 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
             op.require_activity_monitor === true || op.requireActivityMonitor === true,
         });
         if (launchResult.mode === "internal" && launchResult.subscriberIds && launchResult.subscriberIds.length > 0) {
-          const probeAgentType = agent === "codex"
+          const sessionResolveAgentType = agent === "codex"
             ? "codex"
             : (agent === "claude" ? "claude-code" : "");
           for (const subscriberId of launchResult.subscriberIds) {
-            if (!probeAgentType) continue;
-            const resolvedNickname = resolveSubscriberNickname(projectRoot, subscriberId) || nickname;
-            const probeHandle = scheduleProviderSessionProbe({
+            if (!sessionResolveAgentType) continue;
+            const sessionResolveHandle = scheduleProviderSessionResolve({
               projectRoot,
               subscriberId,
-              agentType: probeAgentType,
-              nickname: resolvedNickname,
+              agentType: sessionResolveAgentType,
               agentCwd: projectRoot,
               onResolved: (id, resolved) => {
                 if (providerSessions) {
@@ -548,11 +629,11 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
                     updated_at: new Date().toISOString(),
                   });
                 }
-                probeHandles.delete(id);
+                sessionResolveHandles.delete(id);
               },
             });
-            if (probeHandle) {
-              probeHandles.set(subscriberId, probeHandle);
+            if (sessionResolveHandle) {
+              sessionResolveHandles.set(subscriberId, sessionResolveHandle);
             }
           }
         }
@@ -715,21 +796,61 @@ async function dispatchMessages(projectRoot, dispatch = []) {
   const eventBus = new EventBus(projectRoot);
   // Always use "ufoo-agent" as the publisher for daemon messages
   const defaultPublisher = "ufoo-agent";
+  const resolveDispatchTarget = (target) => {
+    const raw = String(target || "").trim();
+    if (!raw || raw === "broadcast") return raw;
+    try {
+      eventBus.ensureBus();
+      eventBus.loadBusData();
+      const agents = eventBus.busData && eventBus.busData.agents && typeof eventBus.busData.agents === "object"
+        ? eventBus.busData.agents
+        : {};
+      if (agents[raw]) return raw;
+
+      const candidates = [raw];
+      const scoped = applyProjectNicknamePrefix(projectRoot, raw);
+      if (scoped && scoped !== raw) candidates.push(scoped);
+
+      for (const candidate of candidates) {
+        for (const [id, meta] of Object.entries(agents)) {
+          if (!meta || meta.status !== "active") continue;
+          if (
+            meta.nickname === candidate
+            || meta.scoped_nickname === candidate
+            || meta.display_nickname === candidate
+          ) {
+            return id;
+          }
+        }
+      }
+
+      if (eventBus.messageManager && eventBus.messageManager.resolveTarget(raw).length > 0) {
+        return raw;
+      }
+    } catch {
+      // Fall through to the original target; send will surface/log the failure below.
+    }
+    return raw;
+  };
   for (const item of dispatch) {
     if (!item || !item.target || !item.message) continue;
     const pub = item.publisher || defaultPublisher;
+    const target = resolveDispatchTarget(item.target);
     const sendOptions = {
       injectionMode: item.injection_mode,
       source: item.source,
     };
     try {
-      if (item.target === "broadcast") {
+      if (target === "broadcast") {
         await eventBus.broadcast(item.message, pub, sendOptions);
       } else {
-        await eventBus.send(item.target, item.message, pub, sendOptions);
+        await eventBus.send(target, item.message, pub, sendOptions);
       }
-    } catch {
-      // ignore dispatch failures
+    } catch (err) {
+      appendControlLog(
+        projectRoot,
+        `dispatch failed target=${JSON.stringify(item.target)} resolved=${JSON.stringify(target)} error=${err && err.message ? err.message : String(err)}`
+      );
     }
   }
 }
@@ -1093,8 +1214,26 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   writePid(projectRoot);
 
   const logFile = fs.createWriteStream(logPath(projectRoot), { flags: "a" });
+  const formatLogLine = (msg) => `[daemon] ${new Date().toISOString()} ${msg}\n`;
   const log = (msg) => {
-    logFile.write(`[daemon] ${new Date().toISOString()} ${msg}\n`);
+    logFile.write(formatLogLine(msg));
+  };
+  const logSync = (msg) => {
+    const line = formatLogLine(msg);
+    try {
+      fs.appendFileSync(logPath(projectRoot), line);
+    } catch {
+      try {
+        logFile.write(line);
+      } catch {
+        // ignore fatal logging errors
+      }
+    }
+  };
+  const formatFatalReason = (err) => {
+    if (!err) return "unknown";
+    if (err instanceof Error) return err.stack || err.message;
+    return String(err);
   };
   const publishProjectRuntime = (status = "running") => {
     if (isGlobalControllerProjectRoot(projectRoot)) {
@@ -1119,7 +1258,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
 
   // Provider session cache (in-memory)
   providerSessions = loadProviderSessionCache(projectRoot);
-  probeHandles = new Map();
+  sessionResolveHandles = new Map();
   daemonCronController = createDaemonCronController({
     projectRoot,
     dispatch: async ({ taskId, target, message }) => {
@@ -1219,19 +1358,20 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           }
           const targetPaths = getUfooPaths(root);
           if (!fs.existsSync(targetPaths.ufooDir)) {
-            const repoRoot = path.join(__dirname, "..", "..");
-            const init = new (require("../init"))(repoRoot);
+            const repoRoot = path.join(__dirname, "..", "..", "..");
+            const init = new (require("../../app/cli/features/init"))(repoRoot);
             await init.init({ modules: "context,bus", project: root });
           }
           if (!isRunning(root)) {
             cleanupStaleState(root);
-            const daemonBin = path.join(__dirname, "..", "..", "bin", "ufoo.js");
-            const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
+            const daemonBin = path.join(__dirname, "..", "..", "..", "bin", "ufoo.js");
+            const child = spawn(resolveNodeExecutable(), [daemonBin, "daemon", "--start"], {
               detached: true,
               stdio: "ignore",
               cwd: root,
               env: process.env,
             });
+            child.on("error", () => {});
             child.unref();
           }
 
@@ -1483,7 +1623,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         socket.write(
           `${JSON.stringify({
             type: IPC_RESPONSE_TYPES.ERROR,
-            error: "launch_agent requires agent=codex|claude|ucode",
+            error: "launch_agent requires agent=codex|claude|agy|ucode",
           })}
 `,
         );
@@ -1520,9 +1660,9 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
             : null,
       };
       let soloLaunchBootstrap = null;
-      if (requestedProfile && (normalizedAgent === "ufoo" || normalizedAgent === "claude" || normalizedAgent === "codex")) {
-        const agentTypeMap = { ufoo: "ufoo-code", claude: "claude-code", codex: "codex" };
-        const defaultNickMap = { ufoo: "ucode", claude: "claude", codex: "codex" };
+      if (requestedProfile && (normalizedAgent === "ufoo" || normalizedAgent === "claude" || normalizedAgent === "codex" || normalizedAgent === "agy")) {
+        const agentTypeMap = { ufoo: "ufoo-code", claude: "claude-code", codex: "codex", agy: "agy" };
+        const defaultNickMap = { ufoo: "ucode", claude: "claude", codex: "codex", agy: "agy" };
         const agentTypeForBootstrap = agentTypeMap[normalizedAgent];
         const soloNickname = explicitNickname || defaultNickMap[normalizedAgent];
         const profileResult = resolveSoloPromptProfile(projectRoot, requestedProfile);
@@ -1567,6 +1707,12 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
                 ...(Array.isArray(op.extra_args) ? op.extra_args : []),
                 built.promptText,
               ];
+            } else if (normalizedAgent === "agy") {
+              // agy: bootstrap via -i (alias for --prompt-interactive)
+              op.extra_args = [
+                ...(Array.isArray(op.extra_args) ? op.extra_args : []),
+                "-i", built.promptText,
+              ];
             }
             soloLaunchBootstrap = {
               requested_profile: profileResult.requested_profile,
@@ -2146,7 +2292,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         hostName,
         hostSessionId,
         hostCapabilities,
-        skipProbe,
+        skipSessionResolve,
       } = req;
       if (!agentType) {
         socket.write(
@@ -2205,7 +2351,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           reuseSessionId,
           reuseProviderSessionId,
         };
-        if (skipProbe) joinOptions.skipProbe = true;
+        if (skipSessionResolve) joinOptions.skipSessionResolve = true;
 
         let finalNickname = nickname || "";
         let scopedNickname = applyProjectNicknamePrefix(projectRoot, finalNickname, {
@@ -2234,7 +2380,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         eventBus.saveBusData();
         const resolvedNickname = resolveSubscriberNickname(projectRoot, subscriberId) || finalNickname || "";
 
-        if (!skipProbe && reuseProviderSessionId) {
+        if (!skipSessionResolve && reuseProviderSessionId) {
           if (providerSessions) {
             providerSessions.set(subscriberId, {
               sessionId: reuseProviderSessionId,
@@ -2244,12 +2390,11 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           }
         }
 
-        if (!skipProbe) {
-          const probeHandle = scheduleProviderSessionProbe({
+        if (!skipSessionResolve) {
+          const sessionResolveHandle = scheduleProviderSessionResolve({
             projectRoot,
             subscriberId,
             agentType,
-            nickname: resolvedNickname,
             agentCwd: projectRoot,
             onResolved: (id, resolved) => {
               if (providerSessions) {
@@ -2259,11 +2404,11 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
                   updated_at: new Date().toISOString(),
                 });
               }
-              probeHandles.delete(id);
+              sessionResolveHandles.delete(id);
             },
           });
-          if (probeHandle) {
-            probeHandles.set(subscriberId, probeHandle);
+          if (sessionResolveHandle) {
+            sessionResolveHandles.set(subscriberId, sessionResolveHandle);
           }
         }
         socket.write(
@@ -2318,12 +2463,12 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
                 updated_at: new Date().toISOString(),
               });
             }
-            // Cancel the scheduled probe to prevent redundant /ufoo injection
-            const handle = probeHandles.get(subscriberId);
+            // Cancel the scheduled resolver; AGENT_READY already found the session file.
+            const handle = sessionResolveHandles.get(subscriberId);
             if (handle && typeof handle.cancel === "function") {
               handle.cancel();
             }
-            probeHandles.delete(subscriberId);
+            sessionResolveHandles.delete(subscriberId);
             return;
           }
 
@@ -2335,15 +2480,15 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           }
         }
 
-        // Exhausted retries or no pid — fall back to scheduled probe
-        const probeHandle = probeHandles.get(subscriberId);
-        if (probeHandle && typeof probeHandle.triggerNow === "function") {
-          log(`agent_ready falling back to probe for ${subscriberId}`);
-          probeHandle.triggerNow().catch((err) => {
-            log(`agent_ready probe trigger failed for ${subscriberId}: ${err.message}`);
+        // Exhausted retries or no pid — trigger the scheduled file resolver.
+        const sessionResolveHandle = sessionResolveHandles.get(subscriberId);
+        if (sessionResolveHandle && typeof sessionResolveHandle.triggerNow === "function") {
+          log(`agent_ready triggering scheduled session resolver for ${subscriberId}`);
+          sessionResolveHandle.triggerNow().catch((err) => {
+            log(`agent_ready session resolver trigger failed for ${subscriberId}: ${err.message}`);
           });
         } else {
-          log(`agent_ready no probe handle found for ${subscriberId}`);
+          log(`agent_ready no session resolver handle found for ${subscriberId}`);
         }
       };
 
@@ -2361,7 +2506,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   log(`Started pid=${process.pid}`);
 
   // 清理旧 daemon 留下的孤儿 internal agent 进程
-  const EventBus = require("../bus");
+  const EventBus = require("../../coordination/bus");
   const { spawnSync } = require("child_process");
   const eventBus = new EventBus(projectRoot);
   try {
@@ -2462,10 +2607,11 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   }
 
   let cleanedUp = false;
-  const cleanup = () => {
+  const cleanup = (reason = "exit", options = {}) => {
     if (cleanedUp) return;
     cleanedUp = true;
-    log(`Shutting down daemon (managed agents: ${processManager.count()})`);
+    const writeLog = options.sync ? logSync : log;
+    writeLog(`Shutting down daemon reason=${reason} (managed agents: ${processManager.count()})`);
     clearInterval(runtimeHeartbeat);
     try {
       if (!isGlobalControllerProjectRoot(projectRoot)) {
@@ -2487,6 +2633,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     ipcServer.stop();
     busBridge.stop();
     removeSocket(projectRoot);
+    removePidIfOwned(projectRoot);
 
     // 释放锁文件
     try {
@@ -2502,46 +2649,84 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
   };
 
-  process.on("exit", cleanup);
+  process.on("beforeExit", (code) => {
+    logSync(`beforeExit code=${code}`);
+  });
+  process.on("exit", (code) => {
+    cleanup(`exit code=${code}`, { sync: true });
+  });
   process.on("SIGTERM", () => {
-    cleanup();
+    cleanup("SIGTERM", { sync: true });
     process.exit(0);
   });
   process.on("SIGINT", () => {
-    cleanup();
+    cleanup("SIGINT", { sync: true });
     process.exit(0);
   });
+  process.on("uncaughtException", (err) => {
+    logSync(`uncaughtException: ${formatFatalReason(err)}`);
+    cleanup("uncaughtException", { sync: true });
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logSync(`unhandledRejection: ${formatFatalReason(reason)}`);
+    cleanup("unhandledRejection", { sync: true });
+    process.exit(1);
+  });
 }
 
-function stopDaemon(projectRoot) {
+function stopDaemon(projectRoot, options = {}) {
   const pid = readPid(projectRoot);
-  if (!pid) {
-    removeSocket(projectRoot);
-    return false;
+  const pids = new Set(socketOwnerDaemonPids(projectRoot));
+  if (pid && isPidFileDaemonForProject(projectRoot, pid, pids)) {
+    pids.add(pid);
   }
+  const source = String(
+    options.source
+      || process.env.UFOO_DAEMON_STOP_SOURCE
+      || `pid=${process.pid} cwd=${process.cwd()} argv=${process.argv.join(" ")}`
+  ).slice(0, 1200);
+  appendControlLog(
+    projectRoot,
+    `stop requested source=${JSON.stringify(source)} pid_file=${pid || ""} target_pids=[${Array.from(pids).join(",")}]`
+  );
   let killed = false;
-  try {
-    process.kill(pid, "SIGTERM");
-    const started = Date.now();
-    while (Date.now() - started < 1500) {
-      try {
-        process.kill(pid, 0);
-      } catch {
-        killed = true;
-        break;
+  for (const targetPid of pids) {
+    try {
+      process.kill(targetPid, "SIGTERM");
+      killed = true;
+    } catch {
+      // ignore kill errors (e.g., already dead)
+    }
+  }
+  const started = Date.now();
+  while (Date.now() - started < 1500) {
+    let anyAlive = false;
+    for (const targetPid of pids) {
+      if (pidAlive(targetPid)) {
+        anyAlive = true;
       }
     }
-    // Force kill if still alive.
+    if (!anyAlive) break;
+  }
+  // Force kill if still alive.
+  for (const targetPid of pids) {
     try {
-      process.kill(pid, 0);
-      process.kill(pid, "SIGKILL");
-      killed = true;
+      if (pidAlive(targetPid)) {
+        process.kill(targetPid, "SIGKILL");
+        killed = true;
+      }
     } catch {
       // ignore if already dead
     }
-  } catch {
-    // ignore kill errors (e.g., already dead)
   }
+
+  const stillAlive = Array.from(pids).filter((targetPid) => pidAlive(targetPid));
+  if (stillAlive.length > 0) {
+    appendControlLog(projectRoot, `stop failed still_alive=[${stillAlive.join(",")}]`);
+    return false;
+  }
+
   try {
     fs.unlinkSync(pidPath(projectRoot));
   } catch {
@@ -2567,7 +2752,16 @@ function stopDaemon(projectRoot) {
     // ignore
   }
 
-  return killed;
+  const stopped = killed || pids.size === 0;
+  appendControlLog(projectRoot, `stop completed stopped=${stopped} killed=${killed} target_count=${pids.size}`);
+  return stopped;
 }
 
-module.exports = { startDaemon, stopDaemon, isRunning, cleanupStaleState, socketPath };
+module.exports = {
+  startDaemon,
+  stopDaemon,
+  isRunning,
+  cleanupStaleState,
+  socketPath,
+  dispatchMessages,
+};

package/src/{daemon → runtime/daemon}/ipcServer.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const net = require("net");
-const { IPC_RESPONSE_TYPES } = require("../shared/eventContract");
+const { IPC_RESPONSE_TYPES } = require("../contracts/eventContract");
 
 function createDaemonIpcServer(options = {}) {
   const {
@@ -56,6 +56,9 @@ function createDaemonIpcServer(options = {}) {
   const server = net.createServer((socket) => {
     sockets.add(socket);
     socket.on("close", () => sockets.delete(socket));
+    socket.on("error", (err) => {
+      log(`ipc socket error: ${err && err.message ? err.message : String(err || "unknown error")}`);
+    });
     let buffer = "";
     socket.on("data", async (data) => {
       buffer += data.toString("utf8");
@@ -66,12 +69,31 @@ function createDaemonIpcServer(options = {}) {
         const items = parseJsonLines(line);
         for (const req of items) {
           if (!req || typeof req !== "object") continue;
-          await handleRequest(req, socket);
+          try {
+            await handleRequest(req, socket);
+          } catch (err) {
+            const message = err && err.message ? err.message : String(err || "request failed");
+            const requestType = String(req.type || "unknown");
+            log(`ipc request failed type=${requestType}: ${err && err.stack ? err.stack : message}`);
+            try {
+              socket.write(`${JSON.stringify({
+                type: IPC_RESPONSE_TYPES.ERROR,
+                error: message,
+                request_type: requestType,
+              })}\n`);
+            } catch {
+              // ignore failed error replies
+            }
+          }
         }
       }
     });
   });
 
+  server.on("error", (err) => {
+    log(`ipc server error: ${err && err.message ? err.message : String(err || "unknown error")}`);
+  });
+
   function listen(sockPath) {
     server.listen(sockPath);
   }