u-foo 3.0.17 → 3.0.19

package/src/app/chat/commandExecutor.js

@@ -357,10 +357,12 @@ function createCommandExecutor(options = {}) {
   }
 
   function logMcpHelp() {
-    logMessage("system", "{cyan-fg}MCP bridge:{/cyan-fg} local stdio bridge for external MCP-capable agents");
-    logMessage("system", "  • Configure client command: ufoo mcp");
+    logMessage("system", "{cyan-fg}MCP server:{/cyan-fg} singleton listener in the global controller daemon");
+    logMessage("system", "  • Configure Codex direct HTTP: ufoo mcp configure codex");
+    logMessage("system", "  • Compatibility proxy command: ufoo mcp");
     logMessage("system", "  • Disable daemon auto-start: ufoo mcp --no-auto-start");
-    logMessage("system", "  • Topology: one global bridge, project tools route through registered project daemons");
+    logMessage("system", "  • Listener control: ufoo mcp status | ufoo mcp restart");
+    logMessage("system", "  • Topology: one global tool router; project calls use registered project runtimes");
     logMessage("system", "  • Chat diagnostics: /mcp status, /mcp tools, /mcp help");
   }
 
@@ -417,8 +419,12 @@ function createCommandExecutor(options = {}) {
           throw new Error("empty MCP status response");
         }
         const projects = Array.isArray(status.projects) ? status.projects : [];
-        logMessage("system", "{cyan-fg}MCP bridge:{/cyan-fg} local stdio server");
-        logMessage("system", "  • command: {cyan-fg}ufoo mcp{/cyan-fg}");
+        logMessage("system", "{cyan-fg}MCP server:{/cyan-fg} global Streamable HTTP listener");
+        logMessage("system", `  • listener: ${status.http?.running ? "{green-fg}running{/green-fg}" : "{yellow-fg}not running{/yellow-fg}"}`);
+        if (status.http?.endpoint) {
+          logMessage("system", `  • endpoint: ${escapeBlessed(status.http.endpoint)}`);
+        }
+        logMessage("system", "  • stdio fallback: {cyan-fg}ufoo mcp{/cyan-fg}");
         logMessage("system", `  • global controller: ${escapeBlessed(status.global_controller_root || "")}`);
         logMessage("system", `  • daemon: ${status.global_controller_running ? "{green-fg}running{/green-fg}" : "{yellow-fg}not running{/yellow-fg}"}`);
         logMessage("system", "  • client auto-start: enabled by default");

package/src/app/cli/run.js

@@ -587,7 +587,7 @@ async function runCli(argv) {
       });
     program
       .command("mcp")
-      .description("Run the local global ufoo MCP bridge over stdio")
+      .description("Run the global MCP stdio proxy; use bin entry for listener status/configuration")
       .option("--no-auto-start", "Do not auto-start the home-scoped global controller daemon")
       .action((opts) => {
         const repoRoot = getPackageRoot();
@@ -1809,8 +1809,7 @@ async function runCli(argv) {
     return;
   }
   if (cmd === "mcp") {
-    const mcpArgs = ["mcp"];
-    if (rest.includes("--no-auto-start")) mcpArgs.push("--no-auto-start");
+    const mcpArgs = ["mcp", ...rest];
     run(resolveNodeExecutable(), [path.join(repoRoot, "bin", "ufoo.js"), ...mcpArgs]);
     return;
   }

package/src/code/UCODE_PROMPT.md

@@ -17,7 +17,7 @@ ufoo integration requirements:
 - Use shared memory for durable project facts. Read existing memory before writing new memory; do not use it for transient task state.
 - Support launch/close/resume/inject flows managed by ufoo daemon.
 - Prefer canonical ufoo commands (`ufoo ctx`, `ufoo bus`, `ufoo memory`, `ufoo report`) for coordination and status sync.
-- A nonempty `UFOO_SUBSCRIBER_ID` means the ufoo wrapper/daemon already registered this Agent and can inject directly into its monitored session. Reuse that identity; never call MCP `register_agent`, run bare `ufoo bus join`, or start resident `ufoo bus poll`.
+- A nonempty `UFOO_SUBSCRIBER_ID` in this Agent's inherited launch environment means the ufoo wrapper/daemon already registered this Agent and can inject directly into its monitored session. Reuse that identity; never call MCP `register_agent`, run bare `ufoo bus join`, or start resident `ufoo bus poll`.
 - After sending a bus message, do not poll `ufoo bus check`, invoke `/ubus`, sleep, or wait for a reply. Continue the current task; any follow-up message will be automatically injected into your prompt/session.
 
 Execution protocol:

package/src/config.js

@@ -36,6 +36,7 @@ const DEFAULT_CONFIG = {
   launchMode: "auto",
   agentProvider: "codex-cli",
   controllerMode: "main",
+  mcpPort: 47631,
   codexInternalThreadMode: "api",
   codexAuthPath: "",
   codexOauthRefreshWindowSec: 300,
@@ -125,6 +126,12 @@ function normalizeCodexInternalThreadMode(value) {
   return "legacy";
 }
 
+function normalizeMcpPort(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) return DEFAULT_CONFIG.mcpPort;
+  return parsed;
+}
+
 function normalizeCodexAuthPath(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -184,6 +191,7 @@ function loadConfig(projectRoot) {
       controllerMode: Object.prototype.hasOwnProperty.call(raw, "controllerMode")
         ? normalizeControllerMode(raw.controllerMode)
         : DEFAULT_CONFIG.controllerMode,
+      mcpPort: normalizeMcpPort(raw.mcpPort),
       codexInternalThreadMode: Object.prototype.hasOwnProperty.call(raw, "codexInternalThreadMode")
         ? normalizeCodexInternalThreadMode(raw.codexInternalThreadMode)
         : DEFAULT_CONFIG.codexInternalThreadMode,
@@ -240,6 +248,7 @@ function saveConfig(projectRoot, config) {
   merged.routerProvider = typeof merged.routerProvider === "string" ? merged.routerProvider.trim() : "";
   merged.routerModel = typeof merged.routerModel === "string" ? merged.routerModel.trim() : "";
   merged.controllerMode = normalizeControllerMode(merged.controllerMode);
+  merged.mcpPort = normalizeMcpPort(merged.mcpPort);
   merged.codexInternalThreadMode = normalizeCodexInternalThreadMode(merged.codexInternalThreadMode);
   merged.codexAuthPath = normalizeCodexAuthPath(merged.codexAuthPath);
   merged.codexOauthRefreshWindowSec = normalizeCodexOauthRefreshWindowSec(merged.codexOauthRefreshWindowSec);
@@ -291,6 +300,7 @@ module.exports = {
   defaultRouterProviderForAgentProvider,
   defaultRouterModelForProvider,
   normalizeControllerMode,
+  normalizeMcpPort,
   normalizeCodexInternalThreadMode,
   normalizeCodexAuthPath,
   normalizeCodexOauthRefreshWindowSec,

package/src/coordination/bus/subscriber.js

@@ -100,6 +100,15 @@ function hasProviderSession(meta) {
   return typeof meta?.provider_session_id === "string" && meta.provider_session_id.trim() !== "";
 }
 
+function isManagedMcpRegistration(meta) {
+  return Boolean(meta && meta.mcp_bridge === true && meta.mcp_agent_handle_hash);
+}
+
+function isRecentMcpHeartbeat(meta, nowMs = Date.now()) {
+  const lastSeenMs = Date.parse(String(meta?.last_seen || ""));
+  return Number.isFinite(lastSeenMs) && nowMs - lastSeenMs <= 30 * 1000;
+}
+
 /**
  * 订阅者管理
  */
@@ -458,6 +467,29 @@ class SubscriberManager {
     if (!this.busData.agents) return;
 
     for (const [id, meta] of Object.entries(this.busData.agents)) {
+      if (isManagedMcpRegistration(meta)) {
+        const expiresAtMs = Date.parse(String(meta.mcp_lease_expires_at || ""));
+        const expired = !Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now();
+        if (!expired || isRecentMcpHeartbeat(meta)) {
+          continue;
+        }
+        if (meta.status === "active") {
+          this.logRegistry("cleanup_inactive_mark", {
+            source: "bus.subscriber.cleanupInactive",
+            subscriber: id,
+            reason: "mcp_agent_lease_expired",
+            status: meta.status || "",
+            launch_mode: meta.launch_mode || "",
+            last_seen: meta.last_seen || "",
+            lease_expires_at: meta.mcp_lease_expires_at || "",
+          });
+          meta.status = "inactive";
+          meta.activity_state = "";
+          meta.mcp_revoked_at = getTimestamp();
+          this.cleanupSubscriberArtifacts(id);
+        }
+        continue;
+      }
       if (isInternalLaunchMode(meta)) {
         const recoverable = hasProviderSession(meta);
         if (meta.status === "inactive") {

package/src/coordination/state/paths.js

@@ -24,6 +24,8 @@ function getUfooPaths(projectRoot) {
   const ufooDaemonPid = path.join(runDir, "ufoo-daemon.pid");
   const ufooDaemonLog = path.join(runDir, "ufoo-daemon.log");
   const ufooSock = path.join(runDir, "ufoo.sock");
+  const mcpToken = path.join(runDir, "mcp-token");
+  const mcpEndpoint = path.join(runDir, "mcp-endpoint.json");
 
   return {
     ufooDir,
@@ -46,6 +48,8 @@ function getUfooPaths(projectRoot) {
     ufooDaemonPid,
     ufooDaemonLog,
     ufooSock,
+    mcpToken,
+    mcpEndpoint,
   };
 }
 

package/src/runtime/contracts/eventContract.js

@@ -20,6 +20,10 @@ const IPC_REQUEST_TYPES = {
   AGENT_REPORT: "agent_report",
   ASSIGN_ROLE: "assign_role",
   REFRESH_STATUS: "refresh_status",
+  CONTROL_PLANE_CALL: "control_plane_call",
+  CONTROL_PLANE_CANCEL: "control_plane_cancel",
+  MCP_STATUS: "mcp_status",
+  MCP_RESTART: "mcp_restart",
 };
 
 const IPC_RESPONSE_TYPES = {
@@ -29,6 +33,7 @@ const IPC_RESPONSE_TYPES = {
   ERROR: "error",
   BUS_SEND_OK: "bus_send_ok",
   REGISTER_OK: "register_ok",
+  CONTROL_PLANE_RESULT: "control_plane_result",
 };
 
 const BUS_STATUS_PHASES = {

package/src/runtime/daemon/controlPlaneService.js

@@ -22,6 +22,8 @@ const WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS = 600;
 const WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS = 600;
 const WAIT_FOR_MESSAGE_POLL_INTERVAL_MS = 1000;
 const WAIT_FOR_MESSAGE_HEARTBEAT_INTERVAL_MS = 15000;
+const MCP_AGENT_LEASE_TTL_MS = 24 * 60 * 60 * 1000;
+const MCP_AGENT_RECENT_HEARTBEAT_MS = 30 * 1000;
 
 function nowIso() {
   return new Date().toISOString();
@@ -70,6 +72,61 @@ function createCryptoSessionId() {
   return crypto.randomBytes(4).toString("hex");
 }
 
+function createAgentHandle() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+
+function hashAgentHandle(handle = "") {
+  return crypto.createHash("sha256").update(String(handle || ""), "utf8").digest("hex");
+}
+
+function leaseExpiryIso(nowMs = Date.now()) {
+  return new Date(nowMs + MCP_AGENT_LEASE_TTL_MS).toISOString();
+}
+
+function extendMcpAgentLease(meta, nowMs = Date.now()) {
+  meta.mcp_lease_expires_at = leaseExpiryIso(nowMs);
+  delete meta.mcp_revoked_at;
+  return meta.mcp_lease_expires_at;
+}
+
+function assertAgentHandle(bus, subscriber, args = {}, options = {}) {
+  const meta = assertSubscriberExists(bus, subscriber);
+  if (meta.mcp_bridge !== true || !meta.mcp_agent_handle_hash) {
+    const err = new Error(`subscriber is not an MCP-registered Agent: ${subscriber}`);
+    err.code = "agent_handle_not_available";
+    throw err;
+  }
+  const handle = String(args.agent_handle || args.agentHandle || "").trim();
+  if (!handle) {
+    const err = new Error("agent_handle is required");
+    err.code = "agent_handle_required";
+    throw err;
+  }
+  const actual = Buffer.from(hashAgentHandle(handle), "hex");
+  const expected = Buffer.from(String(meta.mcp_agent_handle_hash || ""), "hex");
+  if (actual.length !== expected.length || !crypto.timingSafeEqual(actual, expected)) {
+    const err = new Error("agent_handle does not own this subscriber");
+    err.code = "invalid_agent_handle";
+    throw err;
+  }
+  if (options.allowInactive !== true && meta.status !== "active") {
+    const err = new Error(`Agent registration is inactive: ${subscriber}`);
+    err.code = "agent_lease_inactive";
+    throw err;
+  }
+  const expiresAtMs = Date.parse(String(meta.mcp_lease_expires_at || ""));
+  if (
+    options.allowExpired !== true
+    && (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now())
+  ) {
+    const err = new Error(`Agent lease expired: ${subscriber}`);
+    err.code = "agent_lease_expired";
+    throw err;
+  }
+  return meta;
+}
+
 function notifyDaemonRefresh(projectRoot) {
   if (!isRunning(projectRoot)) return;
   const sock = socketPath(projectRoot);
@@ -99,6 +156,10 @@ async function registerAgentFull(projectRoot, args = {}, options = {}) {
   const hostCapabilities = args.hostCapabilities && typeof args.hostCapabilities === "object"
     ? args.hostCapabilities
     : capabilities;
+  const clientInstanceId = String(
+    args.client_instance_id || args.clientInstanceId || ""
+  ).trim();
+  const bus = ensureBusLoaded(projectRoot);
 
   // Session ID: explicit > reuse > generate
   let sessionId;
@@ -113,7 +174,22 @@ async function registerAgentFull(projectRoot, args = {}, options = {}) {
   const reuseProviderSessionId = typeof reuseSession?.providerSessionId === "string"
     ? reuseSession.providerSessionId.trim() : "";
 
-  if (explicitSessionId) {
+  const recoveredEntry = !validateParentPid && clientInstanceId
+    ? Object.entries(bus.busData.agents || {}).find(([, meta]) => (
+      meta
+      && meta.mcp_bridge === true
+      && meta.agent_type === agentType
+      && meta.mcp_client_instance_id === clientInstanceId
+    ))
+    : null;
+  const recoveredSubscriber = recoveredEntry ? recoveredEntry[0] : "";
+  const recoveredSessionId = recoveredSubscriber.startsWith(`${agentType}:`)
+    ? recoveredSubscriber.slice(agentType.length + 1)
+    : "";
+
+  if (recoveredSessionId) {
+    sessionId = recoveredSessionId;
+  } else if (explicitSessionId) {
     sessionId = explicitSessionId;
   } else if (reuseSessionId && reuseSubscriberId === `${agentType}:${reuseSessionId}`) {
     sessionId = reuseSessionId;
@@ -165,7 +241,18 @@ async function registerAgentFull(projectRoot, args = {}, options = {}) {
   if (reuseSessionId) joinOptions.reuseSessionId = reuseSessionId;
   if (reuseProviderSessionId) joinOptions.reuseProviderSessionId = reuseProviderSessionId;
 
-  const bus = ensureBusLoaded(projectRoot);
+  const candidateSubscriber = `${agentType}:${sessionId}`;
+  const existingCandidate = bus.subscriberManager.getSubscriber(candidateSubscriber);
+  if (
+    !validateParentPid
+    && existingCandidate
+    && existingCandidate.mcp_agent_handle_hash
+    && (!clientInstanceId || existingCandidate.mcp_client_instance_id !== clientInstanceId)
+  ) {
+    const err = new Error(`subscriber is already registered: ${candidateSubscriber}`);
+    err.code = "subscriber_already_registered";
+    throw err;
+  }
   const result = await bus.subscriberManager.join(sessionId, agentType, finalNickname, joinOptions);
   const subscriber = result.subscriber;
   if (finalNickname) {
@@ -175,6 +262,14 @@ async function registerAgentFull(projectRoot, args = {}, options = {}) {
   meta.activity_state = String(args.activity_state || "ready");
   meta.activity_since = nowIso();
   meta.mcp_bridge = !validateParentPid;
+  let agentHandle = "";
+  if (!validateParentPid) {
+    agentHandle = createAgentHandle();
+    meta.mcp_agent_handle_hash = hashAgentHandle(agentHandle);
+    meta.mcp_client_instance_id = clientInstanceId;
+    meta.mcp_registered_at = meta.mcp_registered_at || nowIso();
+    extendMcpAgentLease(meta);
+  }
   if (hostCapabilities) meta.mcp_capabilities = hostCapabilities;
   bus.saveBusData();
   notifyDaemonRefresh(projectRoot);
@@ -188,6 +283,12 @@ async function registerAgentFull(projectRoot, args = {}, options = {}) {
     nickname: meta.nickname || result.nickname || finalNickname || "",
     scoped_nickname: meta.scoped_nickname || result.scopedNickname || scopedNickname || "",
     launch_mode: launchMode,
+    ...(agentHandle ? {
+      agent_handle: agentHandle,
+      lease_expires_at: meta.mcp_lease_expires_at,
+      client_instance_id: clientInstanceId,
+      recovered: Boolean(recoveredSubscriber),
+    } : {}),
     reuseProviderSessionId,
     skipSessionResolve: !!args.skipSessionResolve,
   };
@@ -203,9 +304,10 @@ async function registerAgent(projectRoot, args = {}) {
 async function heartbeatAgent(projectRoot, args = {}) {
   const subscriber = resolveSubscriberArg(args);
   const bus = ensureBusLoaded(projectRoot);
-  const meta = assertSubscriberExists(bus, subscriber);
+  const meta = assertAgentHandle(bus, subscriber, args);
   bus.subscriberManager.updateLastSeen(subscriber);
   meta.status = "active";
+  const leaseExpiresAt = extendMcpAgentLease(meta);
   bus.saveBusData();
   notifyDaemonRefresh(projectRoot);
   return {
@@ -213,6 +315,7 @@ async function heartbeatAgent(projectRoot, args = {}) {
     project_root: projectRoot,
     subscriber,
     last_seen: meta.last_seen,
+    lease_expires_at: leaseExpiresAt,
   };
 }
 
@@ -225,7 +328,7 @@ async function publishActivityState(projectRoot, args = {}) {
     throw err;
   }
   const bus = ensureBusLoaded(projectRoot);
-  const meta = assertSubscriberExists(bus, subscriber);
+  const meta = assertAgentHandle(bus, subscriber, args);
   bus.subscriberManager.updateLastSeen(subscriber);
   meta.status = "active";
   meta.activity_state = activityState;
@@ -246,7 +349,7 @@ async function publishActivityState(projectRoot, args = {}) {
 async function updateAgentMetadata(projectRoot, args = {}) {
   const subscriber = resolveSubscriberArg(args);
   const bus = ensureBusLoaded(projectRoot);
-  const meta = assertSubscriberExists(bus, subscriber);
+  const meta = assertAgentHandle(bus, subscriber, args);
   const nickname = String(args.nickname || "").trim();
   if (nickname) {
     await bus.subscriberManager.rename(subscriber, nickname);
@@ -278,7 +381,7 @@ async function pollInbox(projectRoot, args = {}) {
     ? Math.floor(Number(args.limit))
     : 50;
   const bus = ensureBusLoaded(projectRoot);
-  assertSubscriberExists(bus, subscriber);
+  assertAgentHandle(bus, subscriber, args);
   bus.subscriberManager.updateLastSeen(subscriber);
   bus.saveBusData();
   const pending = await bus.messageManager.check(subscriber);
@@ -365,14 +468,15 @@ function eventSeq(event = {}) {
   return Number.isInteger(seq) && seq > 0 ? seq : 0;
 }
 
-function touchWaitingSubscriber(bus, subscriber) {
+function touchWaitingSubscriber(bus, subscriber, args = {}) {
   // Long waits span concurrent metadata updates from other agents. Reload
   // before writing heartbeat state so a stale in-memory registry cannot
   // overwrite those updates.
   bus.loadBusData();
-  const meta = assertSubscriberExists(bus, subscriber);
+  const meta = assertAgentHandle(bus, subscriber, args);
   meta.status = "active";
   bus.subscriberManager.updateLastSeen(subscriber);
+  extendMcpAgentLease(meta);
   bus.saveBusData();
 }
 
@@ -393,7 +497,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
   const timeoutMs = timeoutSeconds * 1000;
 
   const bus = ensureBusLoaded(projectRoot);
-  touchWaitingSubscriber(bus, subscriber);
+  touchWaitingSubscriber(bus, subscriber, args);
   const lease = acquirePollLease(path.join(
     bus.busDir,
     "pids",
@@ -418,7 +522,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
       if (unseen.length > 0) {
         const messages = unseen.slice(0, limit);
         const lastSeq = Math.max(afterSeq, ...messages.map(eventSeq));
-        touchWaitingSubscriber(bus, subscriber);
+        touchWaitingSubscriber(bus, subscriber, args);
         return {
           ok: true,
           project_root: projectRoot,
@@ -436,7 +540,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
 
       const current = now();
       if (current >= deadline) {
-        touchWaitingSubscriber(bus, subscriber);
+        touchWaitingSubscriber(bus, subscriber, args);
         return {
           ok: true,
           project_root: projectRoot,
@@ -453,7 +557,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
       }
 
       if (current >= nextHeartbeatAt) {
-        touchWaitingSubscriber(bus, subscriber);
+        touchWaitingSubscriber(bus, subscriber, args);
         nextHeartbeatAt = current + heartbeatIntervalMs;
       }
 
@@ -469,6 +573,8 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
 
 async function reportAgentStatus(projectRoot, args = {}) {
   const subscriber = resolveSubscriberArg(args);
+  const bus = ensureBusLoaded(projectRoot);
+  assertAgentHandle(bus, subscriber, args);
   const report = normalizeReportInput({
     ...args,
     agent_id: subscriber,
@@ -488,6 +594,12 @@ async function reportAgentStatus(projectRoot, args = {}) {
 async function unregisterAgent(projectRoot, args = {}) {
   const subscriber = resolveSubscriberArg(args);
   const bus = ensureBusLoaded(projectRoot);
+  const meta = assertAgentHandle(bus, subscriber, args, {
+    allowExpired: true,
+    allowInactive: true,
+  });
+  meta.mcp_revoked_at = nowIso();
+  meta.mcp_lease_expires_at = meta.mcp_revoked_at;
   const ok = await bus.subscriberManager.leave(subscriber);
   bus.saveBusData();
   notifyDaemonRefresh(projectRoot);
@@ -504,6 +616,10 @@ module.exports = {
   assertSubscriberExists,
   resolveSubscriberArg,
   createSessionId,
+  createAgentHandle,
+  hashAgentHandle,
+  assertAgentHandle,
+  extendMcpAgentLease,
   notifyDaemonRefresh,
   registerAgentFull,
   registerAgent,
@@ -517,4 +633,6 @@ module.exports = {
   normalizeWaitForMessageArgs,
   WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
   WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS,
+  MCP_AGENT_LEASE_TTL_MS,
+  MCP_AGENT_RECENT_HEARTBEAT_MS,
 };

package/src/runtime/daemon/index.js

@@ -45,6 +45,10 @@ const {
   checkAndCleanupNickname,
 } = require("./nicknameScope");
 const { resolveNodeExecutable } = require("../process/nodeExecutable");
+const {
+  createProjectRuntimeControlPlane,
+} = require("./projectRuntimeControlPlane");
+const { loadConfig, normalizeMcpPort } = require("../../config");
 
 let providerSessions = null;
 let sessionResolveHandles = new Map();
@@ -1351,9 +1355,63 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     },
   });
   deliveryScheduler.start();
+  const runtimeControlPlane = createProjectRuntimeControlPlane({ projectRoot });
+  let mcpHttpServer = null;
+  if (isGlobalControllerProjectRoot(projectRoot) && process.env.UFOO_MCP_HTTP_DISABLED !== "1") {
+    const { createGlobalMcpHttpServer } = require("./mcpHttpServer");
+    const config = loadConfig(projectRoot);
+    const configuredPort = process.env.UFOO_MCP_PORT || config.mcpPort;
+    mcpHttpServer = createGlobalMcpHttpServer({
+      projectRoot,
+      port: normalizeMcpPort(configuredPort),
+      log,
+    });
+    mcpHttpServer.start().catch((err) => {
+      logSync(`MCP HTTP startup failed: ${formatFatalReason(err)}`);
+      setImmediate(() => {
+        throw err;
+      });
+    });
+  }
 
   handleIpcRequest = async (req, socket) => {
     if (!req || typeof req !== "object") return;
+    if (await runtimeControlPlane.handleRequest(req, socket)) return;
+    if (req.type === IPC_REQUEST_TYPES.MCP_STATUS || req.type === IPC_REQUEST_TYPES.MCP_RESTART) {
+      if (!isGlobalControllerProjectRoot(projectRoot)) {
+        socket.write(`${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.ERROR,
+          error: "MCP control is owned by the global controller daemon",
+        })}\n`);
+        return;
+      }
+      try {
+        if (req.type === IPC_REQUEST_TYPES.MCP_RESTART) {
+          if (!mcpHttpServer) {
+            throw new Error("MCP HTTP listener is disabled");
+          }
+          await mcpHttpServer.stop();
+          await mcpHttpServer.start();
+        }
+        socket.write(`${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.RESPONSE,
+          data: {
+            ok: true,
+            operation: req.type === IPC_REQUEST_TYPES.MCP_RESTART ? "restart" : "status",
+            mcp: mcpHttpServer
+              ? mcpHttpServer.getStatus()
+              : { running: false, disabled: true },
+          },
+        })}\n`);
+      } catch (err) {
+        socket.write(`${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.ERROR,
+          error: err.message || String(err),
+          code: err.code || "mcp_control_error",
+        })}\n`);
+      }
+      return;
+    }
     if (req.type === IPC_REQUEST_TYPES.STATUS) {
       cleanupInactiveSubscribers();
       const status = buildRuntimeStatus();
@@ -2595,6 +2653,13 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
     daemonGroupOrchestrator = null;
 
+    runtimeControlPlane.stop();
+    if (mcpHttpServer) {
+      void mcpHttpServer.stop().catch((err) => {
+        writeLog(`MCP HTTP shutdown failed: ${formatFatalReason(err)}`);
+      });
+    }
+
     // 清理所有子进程
     processManager.cleanup();