u-foo 3.0.22 → 3.0.24

package/OPTIONAL_SKILLS/ufoo-bus-poll/SKILL.md

@@ -22,7 +22,7 @@ one active receive wait per subscriber.
 Keep idle checks inside a pending tool call or host background task. Do not
 implement a model-driven timer, repeated chat turn, or fixed
 `AGENT_LOOP_TICK_*`. Waiting must not invoke the LLM until a message arrives or
-the host's maximum pending-call window ends.
+the caller cancels the wait.
 
 ## Attach the subscriber
 
@@ -63,16 +63,17 @@ prints stdout. Keep the wait inside one foreground MCP tool call instead:
    - `subscriber`: the caller-owned MCP subscriber
    - `agent_handle`: the opaque handle returned with that registration
    - `after_seq`: `0` for the first wait, then the last returned `last_seq`
-   - `timeout_seconds`: `600`
+   - `timeout_seconds`: `0` (wait until a message arrives or the call is cancelled)
 2. Leave that tool call pending. Do not background it and do not start
    `ufoo bus poll --follow`; while the tool is pending, internal queue checks do
    not invoke the model or consume model tokens.
 3. If it returns `status: "message"`, handle every returned message, then call
    MCP `ack_bus` with `through_seq: <last_seq>`. This preserves messages that
    arrived after the returned batch. Include the same `agent_handle`.
-4. If it returns `status: "timeout"`, no message was received. If monitoring is
-   still required, immediately call `wait_for_message` again with the same
-   `after_seq`. The timeout return is the only periodic model wake.
+4. The default wait has no periodic timeout result and therefore no periodic
+   model wake. If it ends with a cancellation or transport error, do not advance
+   `after_seq`; re-arm only when monitoring is still required and the receive
+   lease is healthy.
 5. After handling a message batch and completing any active work, re-arm one
    wait with the returned `last_seq`. Advance the cursor only after `ack_bus`
    succeeds; if acknowledgement fails, resolve that failure before re-arming.

package/README.md

@@ -266,11 +266,13 @@ capability: do not send it to peers or print it in reports.
 
 - **Codex App:** call MCP `wait_for_message` in the foreground with
   the registered subscriber and handle, `after_seq: 0`, and
-  `timeout_seconds: 600`. The tool call stays pending inside ufoo; a message
-  returns immediately and wakes the task without shell stdout. On timeout,
-  re-arm with the same cursor. After handling a message response, call MCP
-  `ack_bus` with the same handle and its `last_seq` as `through_seq`, then
-  re-arm with that `last_seq` when the Agent is idle again.
+  `timeout_seconds: 0`. The tool call stays pending inside the dedicated
+  `ufoo_wait` MCP connection until a message arrives or the caller cancels it;
+  idle time produces no periodic model wake or token consumption. A message
+  returns immediately and wakes the task without shell stdout. After handling
+  a message response, call MCP `ack_bus` with the same handle and its
+  `last_seq` as `through_seq`, then re-arm with that `last_seq` when the Agent
+  is idle again.
 - **Cursor:** bind the MCP subscriber and run
   `export UFOO_SUBSCRIBER_ID="<subscriber-id>"; exec ufoo bus poll
   "$UFOO_SUBSCRIBER_ID" --follow --interval 30` through the monitored

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agents/launch/launcher.js

@@ -18,7 +18,10 @@ const {
   routeDaemonRequest,
 } = require("../../runtime/daemon/endpoint");
 const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
-const { probeHostCapabilities } = require("../../runtime/terminal/adapters/hostAdapter");
+const {
+  probeHostCapabilities,
+  requestSnapshot,
+} = require("../../runtime/terminal/adapters/hostAdapter");
 const PtyWrapper = require("./ptyWrapper");
 const ReadyDetector = require("./readyDetector");
 const {
@@ -112,6 +115,12 @@ function normalizeTty(ttyPath) {
   return trimmed;
 }
 
+function stripTerminalControl(text = "") {
+  return String(text)
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
 function getEnvTtyOverride() {
   const override = normalizeTty(process.env.UFOO_TTY_OVERRIDE || "");
   return override;
@@ -572,7 +581,9 @@ class AgentLauncher {
    * 直接spawn启动（回退逻辑）
    * @private
    */
-  _spawnDirect(args, subscriberId) {
+  _spawnDirect(args, subscriberId, options = {}) {
+    const notifier = options.notifier || null;
+    const launchMode = resolveLaunchMode();
     const child = spawn(this.command, args, {
       cwd: this.cwd,
       stdio: "inherit",
@@ -582,17 +593,82 @@ class AgentLauncher {
       },
     });
 
-    if (resolveLaunchMode() === "host" && child.pid) {
+    if (launchMode === "host" && child.pid) {
       const daemonEndpoint = resolveDaemonEndpoint(this.cwd);
       notifyDaemonAgentReady(daemonEndpoint, subscriberId, child.pid).catch(() => {});
     }
 
+    // Host direct-spawn inherits stdio, so readiness cannot be observed from
+    // the child stream. Ask the host for its terminal snapshot and feed that
+    // through the same prompt detector as the PTY path. Never manufacture
+    // readiness from elapsed time; the daemon queue-age fallback is the safety
+    // net when snapshots are unavailable.
+    const hostInjectSock = process.env.UFOO_HOST_INJECT_SOCK
+      || process.env.HORIZON_INJECT_SOCK
+      || "";
+    const snapshotFn = typeof options.requestSnapshot === "function"
+      ? options.requestSnapshot
+      : requestSnapshot;
+    const readyPollIntervalMs = Number.isFinite(options.readyPollIntervalMs)
+      ? Math.max(1, options.readyPollIntervalMs)
+      : 1000;
+    const readyMonitorMaxMs = Number.isFinite(options.readyMonitorMaxMs)
+      ? Math.max(1, options.readyMonitorMaxMs)
+      : 5 * 60 * 1000;
+    let readyPollTimer = null;
+    let readyMonitorStopped = false;
+
+    const stopReadyMonitor = () => {
+      readyMonitorStopped = true;
+      if (readyPollTimer) {
+        clearTimeout(readyPollTimer);
+        readyPollTimer = null;
+      }
+    };
+
+    if (notifier && launchMode === "host" && hostInjectSock) {
+      const detector = new ReadyDetector(this.agentType);
+      const monitorStartedAt = Date.now();
+      detector.onReady(() => {
+        stopReadyMonitor();
+        notifier.markLauncherReady();
+        notifier.updateActivityState("ready");
+      });
+
+      const pollReady = async () => {
+        if (readyMonitorStopped) return;
+        try {
+          const snapshot = await snapshotFn(hostInjectSock);
+          const lines = snapshot && Array.isArray(snapshot.lines) ? snapshot.lines : [];
+          if (lines.length > 0) {
+            // A snapshot is a complete screen, not a stream continuation.
+            // Preserve a line boundary between polls so prompt anchors cannot
+            // be glued to the previous snapshot's final character.
+            detector.processOutput(`\n${stripTerminalControl(lines.join("\n"))}\n`);
+          }
+        } catch {
+          // A transient host snapshot failure must not manufacture readiness.
+        }
+        if (!readyMonitorStopped && Date.now() - monitorStartedAt < readyMonitorMaxMs) {
+          readyPollTimer = setTimeout(pollReady, readyPollIntervalMs);
+          if (readyPollTimer && typeof readyPollTimer.unref === "function") {
+            readyPollTimer.unref();
+          }
+        } else {
+          stopReadyMonitor();
+        }
+      };
+      pollReady();
+    }
+
     child.on("error", (err) => {
+      stopReadyMonitor();
       console.error(`[${this.command}] Failed to start:`, err.message);
       process.exit(1);
     });
 
     child.on("exit", async (code, signal) => {
+      stopReadyMonitor();
       // 清理 bus 状态
       try {
         const bus = new EventBus(this.cwd);
@@ -1010,11 +1086,11 @@ class AgentLauncher {
           process.on("SIGINT", () => handleTermSignal("SIGINT"));
         } catch (err) {
           console.error(`[PTY] Failed to start, falling back to spawn:`, err.message);
-          this._spawnDirect(args, subscriberId);
+          this._spawnDirect(args, subscriberId, { notifier });
         }
       } else {
         // 非PTY环境：tmux、internal、管道、显式禁用等
-        this._spawnDirect(args, subscriberId);
+        this._spawnDirect(args, subscriberId, { notifier });
       }
     } catch (err) {
       console.error(`[${this.command}] Error:`, err.message);

package/src/agents/launch/readyDetector.js

@@ -80,8 +80,9 @@ class ReadyDetector {
     if (text.includes("codex>")) {
       return true;
     }
-    // 2. 行首或行尾的单独 ">" prompt（避免匹配JSON/HTML中的>）
-    if (/(?:^|\n)>\s*$/.test(text)) {
+    // 2. Codex TUI uses the single-chevron "›" prompt. Keep both markers
+    // anchored to a line start to avoid matching prose, JSON, or HTML.
+    if (/(?:^|\n)[ \t]*(?:>[ \t]*$|›(?:[ \t]+[^\n]*)?[ \t]*$)/m.test(text)) {
       return true;
     }
     return false;

package/src/runtime/contracts/mcpContract.js

@@ -1,6 +1,12 @@
 "use strict";
 
 const MCP_PROTOCOL_VERSION = "2024-11-05";
+// Zero keeps the receive tool pending until a message arrives or the caller
+// cancels. This preserves the model-token boundary: idle time never produces a
+// timeout result that would wake the Agent. Positive values retain the bounded
+// wait mode for diagnostics and non-Codex MCP clients.
+const MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS = 0;
+const MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS = 270;
 
 const MCP_ERROR_CODES = Object.freeze({
   PARSE_ERROR: -32700,
@@ -33,6 +39,8 @@ function createJsonRpcError(id, code, message, data = undefined) {
 
 module.exports = {
   MCP_PROTOCOL_VERSION,
+  MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
+  MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS,
   MCP_ERROR_CODES,
   createJsonRpcResult,
   createJsonRpcError,

package/src/runtime/daemon/controlPlaneService.js

@@ -17,13 +17,17 @@ const {
   routeDaemonRequest,
 } = require("./endpoint");
 const { IPC_REQUEST_TYPES } = require("../contracts/eventContract");
+const {
+  MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
+  MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS,
+} = require("../contracts/mcpContract");
 const {
   applyProjectNicknamePrefix,
   checkAndCleanupNickname,
 } = require("./nicknameScope");
 
-const WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS = 600;
-const WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS = 600;
+const WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS = MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS;
+const WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS = MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS;
 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;
@@ -447,11 +451,12 @@ function normalizeWaitForMessageArgs(args = {}) {
   const timeoutSeconds = Number(rawTimeout);
   if (
     !Number.isFinite(timeoutSeconds)
-    || timeoutSeconds < 1
+    || timeoutSeconds < 0
+    || (timeoutSeconds > 0 && timeoutSeconds < 1)
     || timeoutSeconds > WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS
   ) {
     const err = new Error(
-      `wait_for_message timeout_seconds must be between 1 and ${WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS}`
+      `wait_for_message timeout_seconds must be 0 (until message) or between 1 and ${WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS}`
     );
     err.code = "invalid_timeout";
     throw err;
@@ -503,7 +508,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
     1000,
     Number(options.heartbeatIntervalMs) || WAIT_FOR_MESSAGE_HEARTBEAT_INTERVAL_MS
   );
-  const timeoutMs = timeoutSeconds * 1000;
+  const timeoutMs = timeoutSeconds > 0 ? timeoutSeconds * 1000 : null;
 
   const bus = ensureBusLoaded(projectRoot);
   touchWaitingSubscriber(bus, subscriber, args);
@@ -516,7 +521,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
   process.once("exit", cleanupLease);
 
   const startedAt = now();
-  const deadline = startedAt + timeoutMs;
+  const deadline = timeoutMs == null ? null : startedAt + timeoutMs;
   let nextHeartbeatAt = startedAt + heartbeatIntervalMs;
 
   try {
@@ -548,7 +553,7 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
       }
 
       const current = now();
-      if (current >= deadline) {
+      if (deadline != null && current >= deadline) {
         touchWaitingSubscriber(bus, subscriber, args);
         return {
           ok: true,
@@ -570,7 +575,9 @@ async function waitForMessage(projectRoot, args = {}, options = {}) {
         nextHeartbeatAt = current + heartbeatIntervalMs;
       }
 
-      const delayMs = Math.max(1, Math.min(pollIntervalMs, deadline - current));
+      const delayMs = deadline == null
+        ? pollIntervalMs
+        : Math.max(1, Math.min(pollIntervalMs, deadline - current));
       // eslint-disable-next-line no-await-in-loop
       await sleep(delayMs, signal);
     }

package/src/runtime/daemon/deliveryScheduler.js

@@ -23,6 +23,12 @@ const DEFAULT_WARN_INTERVAL_MS = 60 * 1000;
 // After this long stuck in waiting_input/blocked, deliver anyway (better a
 // message in a stuck terminal than a lost one). Env UFOO_DELIVERY_BLOCKED_GRACE_MS overrides.
 const DEFAULT_BLOCKED_GRACE_MS = 15 * 60 * 1000;
+// A queued wrapper message must never be blocked indefinitely by stale
+// activity state. Once the oldest injectable message has waited this long,
+// bypass only the activity gate and attempt direct injection.
+const DEFAULT_FORCE_DELIVERY_AFTER_MS = 5 * 60 * 1000;
+const DEFAULT_FORCE_RETRY_BASE_MS = 5 * 1000;
+const DEFAULT_FORCE_RETRY_MAX_MS = 60 * 1000;
 // Warn when an inject lock is held longer than this (usually means a stuck inject).
 const DEFAULT_LOCKED_WARN_AFTER_MS = 60 * 1000;
 
@@ -75,6 +81,15 @@ class DeliveryScheduler {
       options.blockedGraceMs,
       positiveMs(Number(process.env.UFOO_DELIVERY_BLOCKED_GRACE_MS), DEFAULT_BLOCKED_GRACE_MS),
     );
+    this.forceDeliveryAfterMs = positiveMs(
+      options.forceDeliveryAfterMs,
+      positiveMs(
+        Number(process.env.UFOO_DELIVERY_FORCE_AFTER_MS),
+        DEFAULT_FORCE_DELIVERY_AFTER_MS,
+      ),
+    );
+    this.forceRetryBaseMs = positiveMs(options.forceRetryBaseMs, DEFAULT_FORCE_RETRY_BASE_MS);
+    this.forceRetryMaxMs = positiveMs(options.forceRetryMaxMs, DEFAULT_FORCE_RETRY_MAX_MS);
     this.lockedWarnAfterMs = positiveMs(options.lockedWarnAfterMs, DEFAULT_LOCKED_WARN_AFTER_MS);
     this.intervalMs = Number.isFinite(options.intervalMs) && options.intervalMs > 0
       ? options.intervalMs
@@ -84,6 +99,9 @@ class DeliveryScheduler {
     this.deferrals = new Map();
     this.blockedStateSeen = new Map();
     this.graceWarned = new Map();
+    this.pendingSeen = new Map();
+    this.forceWarned = new Set();
+    this.forceRetries = new Map();
     this.timer = null;
     this.running = false;
   }
@@ -123,6 +141,13 @@ class DeliveryScheduler {
     this.log(`WARN delivery grace override subscriber=${subscriber} activity_state=${activityState} pending=${this.pendingCount(subscriber)} grace_ms=${this.blockedGraceMs} - agent stuck, delivering anyway`);
   }
 
+  noteForceOverride(subscriber, activityState, pending) {
+    const key = `${subscriber}:${pending.key}`;
+    if (this.forceWarned.has(key)) return;
+    this.forceWarned.add(key);
+    this.log(`WARN delivery queue timeout override subscriber=${subscriber} activity_state=${activityState || "unknown"} seq=${pending.seq || 0} waited_ms=${pending.waitedMs} force_after_ms=${this.forceDeliveryAfterMs} - injecting despite stale activity gate`);
+  }
+
   noteLocked(subscriber, lock) {
     const now = this.now();
     const lockedMs = now - lock.sinceMs;
@@ -146,6 +171,9 @@ class DeliveryScheduler {
     if (!meta || meta.status === "inactive") {
       return { ok: false, reason: "missing_or_inactive" };
     }
+    if (meta.mcp_bridge === true) {
+      return { ok: false, reason: "external_receive" };
+    }
     const launchMode = String(meta.launch_mode || "").trim();
     const adapter = this.adapterRouter.getAdapter({ launchMode, agentId: subscriber, meta });
     if (!adapter.capabilities.supportsNotifierInjector) {
@@ -161,7 +189,11 @@ class DeliveryScheduler {
       } else {
         this.blockedStateSeen.delete(subscriber);
       }
-      return { ok: false, reason: activityState || "unknown_activity_state" };
+      return {
+        ok: false,
+        reason: activityState || "unknown_activity_state",
+        activityBlocked: true,
+      };
     }
     this.blockedStateSeen.delete(subscriber);
     return { ok: true, reason: "deliverable" };
@@ -179,6 +211,108 @@ class DeliveryScheduler {
     return now;
   }
 
+  pendingEventKey(event = {}) {
+    const seq = Number(event.seq);
+    if (Number.isFinite(seq) && seq > 0) return `seq:${seq}`;
+    return `event:${JSON.stringify(event)}`;
+  }
+
+  clearPendingTracking(subscriber, event = null) {
+    const tracked = this.pendingSeen.get(subscriber);
+    const key = event ? this.pendingEventKey(event) : tracked?.key;
+    if (key) {
+      const trackingKey = `${subscriber}:${key}`;
+      this.forceWarned.delete(trackingKey);
+      this.forceRetries.delete(trackingKey);
+    }
+    this.pendingSeen.delete(subscriber);
+  }
+
+  clearTrackedKey(subscriber, key) {
+    if (!key) return;
+    const trackingKey = `${subscriber}:${key}`;
+    this.forceWarned.delete(trackingKey);
+    this.forceRetries.delete(trackingKey);
+  }
+
+  noteForceFailure(subscriber, pending) {
+    if (!pending || !pending.key) return;
+    const key = `${subscriber}:${pending.key}`;
+    const previous = this.forceRetries.get(key);
+    const attempts = previous ? previous.attempts + 1 : 1;
+    const delayMs = Math.min(
+      this.forceRetryMaxMs,
+      this.forceRetryBaseMs * (2 ** Math.max(0, attempts - 1)),
+    );
+    this.forceRetries.set(key, {
+      attempts,
+      nextAtMs: this.now() + delayMs,
+    });
+    this.log(`WARN forced delivery inject failed subscriber=${subscriber} seq=${pending.seq || 0} retry_in_ms=${delayMs} attempt=${attempts}`);
+  }
+
+  resolvePendingWait(subscriber, queue, eventOverride = null) {
+    let event = eventOverride;
+    if (!event) {
+      try {
+        const pending = queue && typeof queue.readPending === "function"
+          ? queue.readPending()
+          : [];
+        event = pending.find((item) => {
+          const envelope = normalizeQueueEnvelope(item || {});
+          return envelope.event === "message"
+            && envelope.delivery
+            && envelope.delivery.mode === "inject";
+        }) || null;
+      } catch {
+        event = null;
+      }
+    }
+    if (!event) {
+      this.clearPendingTracking(subscriber);
+      return null;
+    }
+
+    const key = this.pendingEventKey(event);
+    const timestampMs = Date.parse(String(event.timestamp || ""));
+    const existing = this.pendingSeen.get(subscriber);
+    if (existing && existing.key !== key) {
+      this.clearTrackedKey(subscriber, existing.key);
+    }
+    const sinceMs = Number.isFinite(timestampMs) && timestampMs <= this.now()
+      ? timestampMs
+      : (existing && existing.key === key ? existing.sinceMs : this.now());
+    this.pendingSeen.set(subscriber, { key, sinceMs });
+    return {
+      key,
+      seq: Number.isFinite(Number(event.seq)) ? Number(event.seq) : 0,
+      sinceMs,
+      waitedMs: Math.max(0, this.now() - sinceMs),
+    };
+  }
+
+  resolveGate(subscriber, queue, eventOverride = null) {
+    const gate = this.shouldDeliver(subscriber);
+    if (gate.ok || !gate.activityBlocked) return gate;
+    const pending = this.resolvePendingWait(subscriber, queue, eventOverride);
+    if (!pending || pending.waitedMs < this.forceDeliveryAfterMs) return gate;
+    const retry = this.forceRetries.get(`${subscriber}:${pending.key}`);
+    if (retry && this.now() < retry.nextAtMs) {
+      return {
+        ok: false,
+        reason: "force_retry_backoff",
+        retryAtMs: retry.nextAtMs,
+      };
+    }
+    this.noteForceOverride(subscriber, gate.reason, pending);
+    return {
+      ok: true,
+      reason: "queue_timeout_override",
+      forceOverride: gate.reason,
+      pending,
+    };
+  }
+
   async deliverSubscriber(subscriber) {
     if (!subscriber) return { ok: false, delivered: 0, reason: "missing_subscriber" };
     if (this.locks.has(subscriber)) {
@@ -188,7 +322,8 @@ class DeliveryScheduler {
 
     this.locks.set(subscriber, { sinceMs: this.now(), lastWarnAtMs: 0 });
     try {
-      const gate = this.shouldDeliver(subscriber);
+      const queue = this.queueFactory(subscriber);
+      const gate = this.resolveGate(subscriber, queue);
       if (!gate.ok) {
         this.noteDeferral(subscriber, gate.reason);
         return { ok: true, delivered: 0, deferred: true, reason: gate.reason };
@@ -200,9 +335,9 @@ class DeliveryScheduler {
       }
       this.clearDeferral(subscriber);
 
-      const queue = this.queueFactory(subscriber);
       const claim = queue.claimNext();
       if (!claim) {
+        this.clearPendingTracking(subscriber);
         return { ok: true, delivered: 0, reason: "empty" };
       }
 
@@ -219,13 +354,17 @@ class DeliveryScheduler {
       }
 
       if (delivery.gate === "idle") {
-        const secondGate = this.shouldDeliver(subscriber);
+        const secondGate = this.resolveGate(subscriber, queue, evt);
         if (!secondGate.ok) {
           this.noteDeferral(subscriber, secondGate.reason);
           queue.restoreClaim(claim);
           return { ok: true, delivered: 0, deferred: true, reason: secondGate.reason };
         }
         if (secondGate.graceOverride) this.noteGraceOverride(subscriber, secondGate.graceOverride);
+        if (secondGate.forceOverride && !gate.forceOverride) {
+          gate.forceOverride = secondGate.forceOverride;
+          gate.pending = secondGate.pending;
+        }
       }
 
       const { agents } = this.getAgentMeta(subscriber);
@@ -233,6 +372,7 @@ class DeliveryScheduler {
       try {
         await this.injector.inject(subscriber, injectionText);
         queue.completeClaim(claim);
+        this.clearPendingTracking(subscriber, evt);
         // Close the idle gate immediately. PTY ActivityDetector will refresh
         // working from output, then quiet-window back to idle; without this
         // stamp a second pending message can slip through on the next tick
@@ -250,6 +390,7 @@ class DeliveryScheduler {
         return { ok: true, delivered: 1, event: envelope };
       } catch (err) {
         queue.restoreClaim(claim);
+        if (gate.forceOverride) this.noteForceFailure(subscriber, gate.pending);
         await this.emitDelivery({
           subscriber,
           event: envelope,
@@ -282,10 +423,29 @@ class DeliveryScheduler {
     const data = this.readAgents() || { agents: {} };
     const agents = data.agents && typeof data.agents === "object" ? data.agents : {};
     const subscribers = [];
+    const pendingSubscribers = new Set();
     for (const [subscriber, meta] of Object.entries(agents)) {
-      if (!meta || meta.status === "inactive") continue;
+      if (!meta || meta.status === "inactive") {
+        this.clearPendingTracking(subscriber);
+        continue;
+      }
+      // MCP-registered Agents own their receive path through wait_for_message
+      // or an explicitly armed CLI poll. They must never enter direct
+      // terminal-injection scheduling.
+      if (meta.mcp_bridge === true) {
+        this.clearPendingTracking(subscriber);
+        continue;
+      }
       const queue = this.queueFactory(subscriber);
-      if (queue.readPending().length > 0) subscribers.push(subscriber);
+      if (queue.readPending().length > 0) {
+        subscribers.push(subscriber);
+        pendingSubscribers.add(subscriber);
+      } else {
+        this.clearPendingTracking(subscriber);
+      }
+    }
+    for (const subscriber of this.pendingSeen.keys()) {
+      if (!pendingSubscribers.has(subscriber)) this.clearPendingTracking(subscriber);
     }
     return subscribers;
   }

package/src/runtime/daemon/mcpConfigure.js

@@ -13,6 +13,12 @@ const {
 
 const MANAGED_BLOCK_START = "# >>> ufoo MCP (managed)";
 const MANAGED_BLOCK_END = "# <<< ufoo MCP (managed)";
+const CODEX_STANDARD_TOOL_TIMEOUT_SECONDS = 610;
+// Codex currently requires a finite server-level MCP timeout. One year is
+// effectively session-lifetime while avoiding periodic model wakeups. Keep the
+// long timeout isolated from normal ufoo tools so a broken short call cannot
+// hang for the same duration.
+const CODEX_WAIT_TOOL_TIMEOUT_SECONDS = 365 * 24 * 60 * 60;
 const RETIRED_UFOO_SKILL_NAMES = new Set([
   "ubus",
   "uctx",
@@ -32,13 +38,25 @@ function codexConfigPath(options = {}) {
 }
 
 function buildCodexManagedBlock(connection) {
+  const authorization = tomlString(`Bearer ${connection.token}`);
   return [
     MANAGED_BLOCK_START,
     "[mcp_servers.ufoo]",
     `url = ${tomlString(connection.endpoint)}`,
-    `http_headers = { Authorization = ${tomlString(`Bearer ${connection.token}`)} }`,
-    "tool_timeout_sec = 610",
+    `http_headers = { Authorization = ${authorization} }`,
+    `tool_timeout_sec = ${CODEX_STANDARD_TOOL_TIMEOUT_SECONDS}`,
+    'disabled_tools = ["wait_for_message"]',
     "enabled = true",
+    "",
+    "[mcp_servers.ufoo_wait]",
+    `url = ${tomlString(connection.endpoint)}`,
+    `http_headers = { Authorization = ${authorization} }`,
+    `tool_timeout_sec = ${CODEX_WAIT_TOOL_TIMEOUT_SECONDS}`,
+    'enabled_tools = ["wait_for_message"]',
+    "enabled = true",
+    "",
+    "[mcp_servers.ufoo_wait.tools.wait_for_message]",
+    'approval_mode = "approve"',
     MANAGED_BLOCK_END,
   ].join("\n");
 }
@@ -80,7 +98,12 @@ function isUfooStdioEnvSection(header = "") {
 function removeLegacyUfooTransportSections(text = "") {
   const sections = findTomlSections(text);
   const ranges = sections
-    .filter((section) => isUfooMainSection(section.header) || isUfooStdioEnvSection(section.header))
+    .filter((section) => (
+      isUfooMainSection(section.header)
+      || isUfooStdioEnvSection(section.header)
+      || /^(?:mcp_servers\.ufoo_wait|mcp_servers\."ufoo_wait")(?:\.|$)/
+        .test(String(section.header || ""))
+    ))
     .map((section) => [section.start, section.end])
     .sort((a, b) => b[0] - a[0]);
   let next = text;
@@ -207,6 +230,8 @@ function runMcpConfigureCli(host, options = {}) {
 }
 
 module.exports = {
+  CODEX_STANDARD_TOOL_TIMEOUT_SECONDS,
+  CODEX_WAIT_TOOL_TIMEOUT_SECONDS,
   MANAGED_BLOCK_END,
   MANAGED_BLOCK_START,
   buildCodexManagedBlock,

package/src/runtime/daemon/mcpServer.js

@@ -25,6 +25,8 @@ const {
 const { CALLER_TIERS } = require("../../tools/types");
 const {
   MCP_PROTOCOL_VERSION,
+  MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
+  MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS,
   MCP_ERROR_CODES,
   createJsonRpcResult,
   createJsonRpcError,
@@ -153,11 +155,16 @@ const CUSTOM_TOOL_DEFINITIONS = Object.freeze([
           description: "Return only messages with a sequence greater than this cursor.",
         },
         timeout_seconds: {
-          type: "number",
-          minimum: 1,
-          maximum: 600,
-          default: 600,
-          description: "Keep the tool call pending for at most this many seconds.",
+          anyOf: [
+            { const: 0 },
+            {
+              type: "number",
+              minimum: 1,
+              maximum: MCP_WAIT_FOR_MESSAGE_MAX_TIMEOUT_SECONDS,
+            },
+          ],
+          default: MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
+          description: "Use 0 to wait until a message arrives or the call is cancelled. Positive values enable a bounded diagnostic wait.",
         },
         limit: { type: "integer", minimum: 1, maximum: 100, default: 50 },
       },
@@ -643,8 +650,8 @@ class UfooMcpServer {
             toolCallId: id,
             signal: abortController.signal,
           });
-          // A long-lived wait must not hold the process-global console shim for
-          // up to ten minutes while unrelated MCP calls continue concurrently.
+          // A long-lived wait must not hold the process-global console shim
+          // while unrelated MCP calls continue concurrently.
           result = name === "wait_for_message"
             ? await runTool()
             : await suppressConsoleToStderr(runTool);

package/src/runtime/daemon/projectRuntimeGateway.js

@@ -7,6 +7,9 @@ const {
   IPC_REQUEST_TYPES,
   IPC_RESPONSE_TYPES,
 } = require("../contracts/eventContract");
+const {
+  MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS,
+} = require("../contracts/mcpContract");
 const {
   assertToolAllowedForCallerTier,
 } = require("../../tools/registry");
@@ -247,10 +250,16 @@ function connectProjectRuntimeSocket(sockPath, timeoutMs = 5000) {
 
 function resolveCallTimeoutMs(operation, args = {}, fallbackMs = 15000) {
   if (operation !== "wait_for_message") return fallbackMs;
-  const timeoutSeconds = Number(args.timeout_seconds ?? args.timeoutSeconds ?? 600);
+  const timeoutSeconds = Number(
+    args.timeout_seconds
+      ?? args.timeoutSeconds
+      ?? MCP_WAIT_FOR_MESSAGE_DEFAULT_TIMEOUT_SECONDS
+  );
+  if (timeoutSeconds === 0) return null;
   const waitMs = Number.isFinite(timeoutSeconds) && timeoutSeconds > 0
     ? timeoutSeconds * 1000
-    : 600000;
+    : 0;
+  if (waitMs === 0) return null;
   return waitMs + 5000;
 }
 
@@ -379,10 +388,12 @@ class SocketProjectRuntimeGateway {
         ));
       });
 
-      timer = setTimeout(() => {
-        onAbort();
-      }, timeoutMs);
-      if (typeof timer.unref === "function") timer.unref();
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          onAbort();
+        }, timeoutMs);
+        if (typeof timer.unref === "function") timer.unref();
+      }
 
       socket.write(`${JSON.stringify({
         type: IPC_REQUEST_TYPES.CONTROL_PLANE_CALL,