letagents 0.12.12 → 0.12.14

package/dist/mcp/server/tools/messages/wait-tool.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { getPollTimeoutCapMs } from "../../../../shared/poll-timeout-cap.js";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { agentSessionCredentials, appendIncludePromptOnly, buildAgentDeliveryHeaders, bindSupervisedWorkerSession, scheduleSupervisedWorkerCursorCheckpoint, currentRoom, ensureAgentIdentity, getFallbackProjectId, getLatestLocalChatMessages, getLocalChatMessages, getLastMessageId, getRememberedRoomPresence, getTargetRoomId, identityFromAgentSession, isLocalRoomStorageEnabled, listLocalTasks, resolveLocalRoomStorageIdentifiers, resolveAgentSession, roomScopedApiCall, syncRoomPresence, toAgentReadableMessages, touchRoomSession, WORKER_BEARER_AGENT_SESSION_ID, waitForLocalChatMessages, } from "../../runtime.js";
-import { requireValidWorkerBearerRuntime, supervisedBoundedDeliveryDisabledToolResult, } from "../../runtime/worker-bearer.js";
-import { attachAgentMessageActivations } from "../../../../shared/activation-routing.js";
+import { agentSessionCredentials, AGENT_MESSAGE_BODY_MAX_BYTES, appendIncludePromptOnly, boundAgentMessageOutput, buildAgentDeliveryHeaders, bindSupervisedWorkerSession, scheduleSupervisedWorkerCursorCheckpoint, currentRoom, ensureAgentIdentity, getFallbackProjectId, getLatestLocalChatMessages, getLocalImportedRoutingAuthority, getLocalChatMessages, getLocalChatThreadRoutingMembership, getLastMessageId, getRememberedRoomPresence, getStoredAgentRoutingStateSnapshot, getTargetRoomId, identityFromAgentSession, isLocalRoomStorageEnabled, listLocalActiveTaskOwnerLeases, resolveLocalRoomStorageIdentifiers, resolveAgentSession, roomScopedApiCall, syncRoomPresence, toAgentReadableMessages, touchRoomSession, WORKER_BEARER_AGENT_SESSION_ID, waitForLocalChatMessages, } from "../../runtime.js";
+import { requireValidWorkerBearerRuntime, isCustodialPolling, supervisedBoundedDeliveryDisabledToolResult, } from "../../runtime/worker-bearer.js";
+import { resolveWorkerToolIdentity } from "../../runtime/agent-sessions.js";
+import { attachAgentMessageActivations, createGlobalAgentAddressResolver, decideAgentMessageActivation, isTaskOwnerFollowUpMessageText, } from "../../../../shared/activation-routing.js";
+import { normalizeRoutingSender } from "../../../../../shared/routing-aliases.mjs";
 import { findLocalMessageById, findRemoteMessageById } from "./message-lookup.js";
 import { fetchRecentRemoteMessages } from "./read-tool.js";
 import { jsonToolResponse } from "./response.js";
@@ -13,9 +15,9 @@ const DEFAULT_POLL_TIMEOUT_MS = 30000;
 // room history (busy rooms archive millions of characters, which blows the
 // tool's token budget). This bounds that no-cursor catch-up to a recent tail.
 export const DEFAULT_WAIT_CATCHUP_LIMIT = 100;
-// Decide how the initial fetch should behave. With a cursor we return
-// everything after it (genuine "new since I last polled", already bounded);
-// without one we fetch only the bounded recent tail.
+export const MAX_WAIT_MESSAGES_PER_CALL = 100;
+// Decide how the initial fetch should behave. Both paths return one bounded
+// page; callers continue from last_observed_message_id when truncated.
 export function planWaitForMessagesFetch(input) {
     if (input.effectiveAfterMessageId) {
         return { mode: "after_cursor", after: input.effectiveAfterMessageId };
@@ -25,23 +27,12 @@ export function planWaitForMessagesFetch(input) {
         limit: input.catchupLimit ?? DEFAULT_WAIT_CATCHUP_LIMIT,
     };
 }
-const LOCAL_TASK_OWNER_STATUSES = new Set(["assigned", "in_progress", "blocked", "in_review"]);
 export function buildWaitForMessagesRequestOptions(input) {
     return {
         ...(input.signal ? { signal: input.signal } : {}),
         headers: input.deliveryHeaders,
     };
 }
-export function buildWaitForMessagesHistoryPageRequest(input) {
-    const querySuffix = input.queryString ? `?${input.queryString}` : "";
-    return {
-        room_id: input.targetRoomId,
-        project_id: input.targetProjectId,
-        room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages${querySuffix}`),
-        project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages${querySuffix}`),
-        options: buildWaitForMessagesRequestOptions({ deliveryHeaders: input.deliveryHeaders }),
-    };
-}
 function isRecord(value) {
     return Boolean(value && typeof value === "object");
 }
@@ -118,41 +109,233 @@ export function resolveWaitAgentSession(roomId, agentSessionId) {
     return resolveAgentSession(roomId, agentSessionId);
 }
 export async function localActivationContext(roomId) {
-    const result = await listLocalTasks(roomId, { openOnly: true });
     return {
-        activeTaskLeases: result.tasks
-            .flatMap((task) => {
-            const agentKey = task.assignee_agent_key?.trim();
-            if (!LOCAL_TASK_OWNER_STATUSES.has(task.status) || !agentKey) {
-                return [];
-            }
-            return [{
-                    kind: "work",
-                    status: "active",
-                    actor_label: task.assignee || agentKey,
-                    agent_key: agentKey,
-                    agent_instance_id: task.assignee_agent_instance_id,
-                    agent_session_id: task.assignee_agent_session_id,
-                }];
-        }),
+        activeTaskLeases: await listLocalActiveTaskOwnerLeases(roomId),
     };
 }
-async function attachLocalActivationMetadata(roomId, messages, agentSession, options = {}) {
+export async function attachLocalActivationMetadata(roomId, messages, agentSession, options = {}) {
     if (!agentSession || agentSession.session_kind !== "worker") {
         return messages;
     }
     const records = messages.filter(isRecord);
-    const activationContext = options.includeTaskOwnerLeases === false
-        ? undefined
-        : await localActivationContext(roomId);
-    return attachAgentMessageActivations(records, {
+    if (records.length === 0)
+        return messages;
+    const identity = {
         actor_label: agentSession.actor_label,
         agent_key: agentSession.agent_key,
         agent_instance_id: agentSession.agent_instance_id ?? null,
         agent_session_id: agentSession.session_id,
         display_name: agentSession.display_name,
         session_kind: agentSession.session_kind,
-    }, activationContext);
+    };
+    // Imported cloud rows carry immutable, account-scoped send-time authority.
+    // A present wrapper always wins over mutable local aliases, including when
+    // the current state population cannot be read completely.
+    const activeSessionRoomId = options.activeSessionRoomId?.trim() || roomId;
+    const routingState = getStoredAgentRoutingStateSnapshot(activeSessionRoomId);
+    const authoritativeLegacyDecisions = new Map();
+    const legacyRecords = [];
+    const normalizedIdentityKey = normalizeRoutingSender(identity.agent_key);
+    const validActivationReasons = new Set([
+        "self_message",
+        "explicit_mention",
+        "explicit_other_mention",
+        "broadcast",
+        "reply_target",
+        "other_reply_target",
+        "thread_participant",
+        "task_owner",
+        "system_event",
+        "unaddressed",
+    ]);
+    for (const message of records) {
+        const id = messageId(message);
+        if (!id)
+            continue;
+        const imported = getLocalImportedRoutingAuthority(message);
+        if (!imported) {
+            if (routingState.complete) {
+                legacyRecords.push(message);
+            }
+            else {
+                authoritativeLegacyDecisions.set(id, {
+                    decision: "silent",
+                    reason: "unaddressed",
+                    addressed: false,
+                });
+            }
+            continue;
+        }
+        if (!routingState.accountReaderKey
+            || imported.readerKey !== routingState.accountReaderKey
+            || imported.routing.authority === "invalid") {
+            authoritativeLegacyDecisions.set(id, {
+                decision: "silent",
+                reason: "unaddressed",
+                addressed: false,
+            });
+            continue;
+        }
+        const target = imported.routing.recipientSessions.find((candidate) => candidate.agentKey === normalizedIdentityKey);
+        const targetSessionId = imported.routing.authority === "receipts"
+            ? target && "successorAgentSessionId" in target
+                ? target.successorAgentSessionId ?? target.agentSessionId
+                : target?.agentSessionId
+            : target?.agentSessionId;
+        if (!target || targetSessionId !== identity.agent_session_id) {
+            authoritativeLegacyDecisions.set(id, {
+                decision: "silent",
+                reason: "unaddressed",
+                addressed: false,
+            });
+            continue;
+        }
+        const importedReason = imported.routing.authority === "legacy"
+            && "activationReason" in target
+            && validActivationReasons.has(target.activationReason)
+            ? target.activationReason
+            : "explicit_mention";
+        authoritativeLegacyDecisions.set(id, {
+            decision: "activate",
+            reason: importedReason,
+            addressed: true,
+        });
+    }
+    if (legacyRecords.length === 0) {
+        return attachAgentMessageActivations(records, identity, { authoritativeLegacyDecisions });
+    }
+    const threadRootIds = legacyRecords.flatMap((message) => {
+        const messageId = typeof message.id === "string" ? message.id : "";
+        const thread = isRecord(message.thread) ? message.thread : null;
+        const rootId = typeof message.thread_root_id === "string"
+            ? message.thread_root_id
+            : typeof thread?.root_message_id === "string"
+                ? thread.root_message_id
+                : "";
+        return rootId && rootId !== messageId ? [rootId] : [];
+    });
+    // Linked local/cloud rooms store messages under the SQLite room id while
+    // registered workers remain keyed by the canonical cloud room id. Routing
+    // ambiguity must always use that complete canonical population.
+    const storedActiveSessions = routingState.sessions;
+    const activeIdentities = storedActiveSessions.map((session) => ({
+        actor_label: session.actor_label,
+        agent_key: session.agent_key,
+        agent_instance_id: session.agent_instance_id ?? null,
+        agent_session_id: session.session_id,
+        display_name: session.display_name,
+        session_kind: session.session_kind,
+    }));
+    if (!activeIdentities.some((candidate) => candidate.agent_session_id === identity.agent_session_id
+        && candidate.agent_key === identity.agent_key)) {
+        // The request's authenticated current session is authoritative even when
+        // an older local-state file has not persisted it yet.
+        activeIdentities.push(identity);
+    }
+    const sameKeySessions = storedActiveSessions.filter((session) => session.agent_key === identity.agent_key);
+    const currentRepresentativeSessionId = sameKeySessions[0]?.session_id
+        ?? identity.agent_session_id;
+    const currentIsActive = currentRepresentativeSessionId === identity.agent_session_id;
+    const resolveGlobalAddress = createGlobalAgentAddressResolver(activeIdentities);
+    const explicitMentionMessageIds = new Set();
+    const replyTargetMessageIds = new Set();
+    const exactReplyTargetMessageIds = new Set();
+    const selfMessageIds = new Set();
+    for (const message of legacyRecords) {
+        const messageId = typeof message.id === "string" ? message.id : "";
+        if (!messageId)
+            continue;
+        const addressed = resolveGlobalAddress(message);
+        const reply = isRecord(message.reply_to) ? message.reply_to : null;
+        const replyPublisherIdentity = isRecord(reply?.agent_identity)
+            ? reply.agent_identity
+            : null;
+        const replyPublisherKey = typeof replyPublisherIdentity?.agent_key === "string"
+            ? replyPublisherIdentity.agent_key.trim()
+            : "";
+        const replyPublisherSessionId = typeof replyPublisherIdentity?.agent_session_id === "string"
+            ? replyPublisherIdentity.agent_session_id.trim()
+            : "";
+        if (replyPublisherKey) {
+            addressed.replyTargetKeys.clear();
+            const exactReplyIdentity = replyPublisherSessionId
+                ? activeIdentities.find((candidate) => candidate.agent_key === replyPublisherKey
+                    && candidate.agent_session_id === replyPublisherSessionId)
+                : undefined;
+            if (exactReplyIdentity) {
+                if (exactReplyIdentity.agent_session_id === identity.agent_session_id) {
+                    exactReplyTargetMessageIds.add(messageId);
+                }
+            }
+            else if (activeIdentities.some((candidate) => candidate.agent_key === replyPublisherKey)) {
+                addressed.replyTargetKeys.add(replyPublisherKey);
+            }
+        }
+        const publisherIdentity = isRecord(message.agent_identity)
+            ? message.agent_identity
+            : null;
+        const publisherAgentKey = typeof publisherIdentity?.agent_key === "string"
+            ? publisherIdentity.agent_key.trim()
+            : "";
+        if (String(message.source ?? "").trim() === "agent"
+            && (publisherAgentKey
+                ? publisherAgentKey === identity.agent_key
+                : addressed.senderKeys.has(identity.agent_key))) {
+            selfMessageIds.add(messageId);
+        }
+        if (addressed.explicitMentionKeys.has(identity.agent_key)) {
+            explicitMentionMessageIds.add(messageId);
+        }
+        const thread = isRecord(message.thread) ? message.thread : null;
+        const rootId = typeof message.thread_root_id === "string"
+            ? message.thread_root_id
+            : typeof thread?.root_message_id === "string"
+                ? thread.root_message_id
+                : "";
+        if ((!rootId || rootId === messageId)
+            && (exactReplyTargetMessageIds.has(messageId)
+                || addressed.replyTargetKeys.has(identity.agent_key))) {
+            replyTargetMessageIds.add(messageId);
+        }
+    }
+    const [activationContext, projectedThreadParticipantRootIds] = await Promise.all([
+        options.includeTaskOwnerLeases === false
+            || !records.some((message) => isTaskOwnerFollowUpMessageText(message.text))
+            ? undefined
+            : localActivationContext(roomId),
+        getLocalChatThreadRoutingMembership(roomId, threadRootIds, identity, activeIdentities),
+    ]);
+    const exactContext = {
+        ...activationContext,
+        selfMessageIds,
+        threadParticipantRootIds: projectedThreadParticipantRootIds,
+        explicitMentionMessageIds,
+        replyTargetMessageIds,
+    };
+    const exactTaskSessionIdsForKey = new Set((activationContext?.activeTaskLeases ?? [])
+        .filter((lease) => lease.status === "active"
+        && lease.agent_key === identity.agent_key
+        && Boolean(lease.agent_session_id))
+        .map((lease) => lease.agent_session_id));
+    for (const message of legacyRecords) {
+        const messageId = typeof message.id === "string" ? message.id : "";
+        if (!messageId)
+            continue;
+        const resolved = decideAgentMessageActivation(message, identity, exactContext);
+        const exactTaskOwner = resolved.reason === "task_owner"
+            && activationContext?.activeTaskLeases?.some((lease) => lease.status === "active"
+                && lease.agent_session_id === identity.agent_session_id
+                && (!lease.agent_key || lease.agent_key === identity.agent_key));
+        const eligibleRepresentative = exactReplyTargetMessageIds.has(messageId)
+            ? true
+            : resolved.reason === "task_owner" && exactTaskSessionIdsForKey.size > 0
+                ? exactTaskSessionIdsForKey.size === 1 && exactTaskOwner
+                : currentIsActive;
+        authoritativeLegacyDecisions.set(messageId, eligibleRepresentative && resolved.decision === "activate"
+            ? resolved
+            : { decision: "silent", reason: "unaddressed", addressed: false });
+    }
+    return attachAgentMessageActivations(records, identity, { authoritativeLegacyDecisions });
 }
 // Resolving an out-of-window parent costs a lookup (a by-id fetch, or a
 // page-by-page history scan against older APIs), so resolved (and observed)
@@ -162,6 +345,9 @@ async function attachLocalActivationMetadata(roomId, messages, agentSession, opt
 // as immutable once posted; a bounded insertion-ordered map keeps memory flat
 // for long-running workers.
 const THREAD_CONTEXT_CACHE_MAX = 500;
+export const THREAD_CONTEXT_LOOKUP_MAX = 16;
+export const THREAD_CONTEXT_BYTES_MAX = 256 * 1024;
+const THREAD_CONTEXT_DEADLINE_MS = 1_000;
 const threadContextCache = new Map();
 function threadContextCacheKey(scopeId, targetMessageId) {
     return `${scopeId}:${targetMessageId}`;
@@ -199,20 +385,30 @@ export async function collectThreadContextMessages(input) {
     if (pendingIds.length === 0) {
         // Nothing quotes an out-of-window message (idle polls land here), so skip
         // storage-mode resolution entirely.
-        return [];
+        return { messages: [], truncated: false };
     }
     const contextMessages = [];
+    let contextBytes = 0;
+    let lookups = 0;
+    let truncated = false;
+    const deadline = Date.now() + THREAD_CONTEXT_DEADLINE_MS;
     const useLocalStorage = Boolean(input.localRoomId && await isLocalRoomStorageEnabled(input.localRoomId));
     const localIdentifiers = useLocalStorage
         ? await resolveLocalRoomStorageIdentifiers(input.localRoomId)
         : { localRoomId: input.localRoomId };
     const sqliteRoomId = localIdentifiers.localRoomId || input.localRoomId;
     while (pendingIds.length > 0) {
+        if (lookups >= THREAD_CONTEXT_LOOKUP_MAX || Date.now() >= deadline) {
+            truncated = true;
+            break;
+        }
         const nextId = pendingIds.shift();
         if (!nextId || seenIds.has(nextId))
             continue;
         seenIds.add(nextId);
         const cached = threadContextCache.get(threadContextCacheKey(scopeId, nextId));
+        if (!cached)
+            lookups += 1;
         const message = cached
             ?? (useLocalStorage && input.localRoomId
                 ? await findLocalMessageById(sqliteRoomId || input.localRoomId, nextId)
@@ -226,13 +422,19 @@ export async function collectThreadContextMessages(input) {
         if (!cached) {
             rememberThreadContextMessages(scopeId, [message]);
         }
+        const messageBytes = Buffer.byteLength(JSON.stringify(message), "utf8");
+        if (contextBytes + messageBytes > THREAD_CONTEXT_BYTES_MAX) {
+            truncated = true;
+            break;
+        }
+        contextBytes += messageBytes;
         contextMessages.push(message);
         const parentId = replyReferenceId(message);
         if (parentId && !seenIds.has(parentId)) {
             pendingIds.push(parentId);
         }
     }
-    return contextMessages;
+    return { messages: contextMessages, truncated };
 }
 export function registerWaitForMessagesTool(server) {
     server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat room (HTTP long-poll). Messages labeled activation.for_current_agent.decision=\"silent\" are skipped for the current worker; when last_observed_message_id is present, use it as cursor progress even if messages is empty. Threaded replies include thread_parent_id/thread.root_message_id; use send_thread_message with that id to keep focused side discussion out of the main room. For multi-hour runs, call in a loop: always pass after_message_id from the last message you processed or last_observed_message_id so an empty result means 'nothing new yet', not 'stop working'. Legacy/manual room workers may send a brief continue instruction when another legacy/manual participant posts a premature 'I will wait' closing line. Never send that nudge to or about a daemon-supervised participant, and daemon-supervised workers must not emit it; their supervisor owns wake and retry. Per-call wait is capped (default max 180s unless LETAGENTS_POLL_MAX_MS is set on API and MCP).", {
@@ -260,10 +462,21 @@ export function registerWaitForMessagesTool(server) {
         const targetRoomId = getTargetRoomId(room_id);
         const targetProjectId = getFallbackProjectId();
         const localRoomId = targetRoomId ?? currentRoom?.room_id ?? targetProjectId;
-        const identity = await ensureAgentIdentity();
         const sessionRoomId = targetRoomId ?? currentRoom?.room_id ?? localRoomId ?? null;
-        const agentSession = resolveWaitAgentSession(sessionRoomId, agent_session_id);
-        if (agentSession) {
+        const custodial = isCustodialPolling();
+        const routingStateSnapshot = custodial ? { complete: true } : getStoredAgentRoutingStateSnapshot(sessionRoomId ?? "");
+        const localStorageEnabled = Boolean(localRoomId && await isLocalRoomStorageEnabled(localRoomId));
+        if (localStorageEnabled && !routingStateSnapshot.complete) {
+            throw new Error("Local agent routing state is unavailable; retry after restoring the state file.");
+        }
+        const exactIdentity = custodial ? await resolveWorkerToolIdentity({ roomId: sessionRoomId, agentSessionId: agent_session_id }) : null;
+        const identity = exactIdentity?.identity ?? await ensureAgentIdentity();
+        const agentSession = exactIdentity?.agentSession ?? resolveWaitAgentSession(sessionRoomId, agent_session_id);
+        if (custodial) {
+            if (!agentSession || !after_message_id)
+                throw new Error("Custodial polling requires exact worker identity and durable cursor.");
+        }
+        else if (agentSession) {
             // Registration (or a successor generation) must bind strictly once.
             // Later waits use a read-only exact verification capped at 250ms, so a
             // wedged daemon cannot consume the room-poll budget and an old worker
@@ -278,8 +491,8 @@ export function registerWaitForMessagesTool(server) {
         }
         const maxPollMs = getPollTimeoutCapMs();
         const serverTimeout = Math.min(Math.max(timeout || DEFAULT_POLL_TIMEOUT_MS, 1000), maxPollMs);
-        if (localRoomId && await isLocalRoomStorageEnabled(localRoomId)) {
-            const { localRoomId: sqliteRoomId } = await resolveLocalRoomStorageIdentifiers(localRoomId);
+        if (localRoomId && localStorageEnabled) {
+            const { localRoomId: sqliteRoomId, cloudRoomId, } = await resolveLocalRoomStorageIdentifiers(localRoomId);
             const effectiveLocalRoomId = sqliteRoomId || localRoomId;
             const effectiveAfterMessageId = resolveEffectiveAfterMessageId({
                 requestedAfterMessageId: after_message_id,
@@ -290,11 +503,12 @@ export function registerWaitForMessagesTool(server) {
             // keep the unchanged forward "everything after the cursor" behavior.
             const existing = fetchPlan.mode === "catch_up_tail"
                 ? await getLatestLocalChatMessages(effectiveLocalRoomId, {
-                    limit: fetchPlan.limit,
+                    limit: Math.min(fetchPlan.limit, MAX_WAIT_MESSAGES_PER_CALL),
                     include_prompt_only: true,
                 })
                 : await getLocalChatMessages(effectiveLocalRoomId, {
                     after: effectiveAfterMessageId,
+                    limit: MAX_WAIT_MESSAGES_PER_CALL,
                     include_prompt_only: true,
                 });
             const replayingExistingMessages = existing.messages.length > 0;
@@ -303,12 +517,18 @@ export function registerWaitForMessagesTool(server) {
                 : await waitForLocalChatMessages(effectiveLocalRoomId, {
                     after: effectiveAfterMessageId,
                     timeoutMs: serverTimeout,
+                    limit: MAX_WAIT_MESSAGES_PER_CALL,
                     include_prompt_only: true,
                 });
             const messages = await attachLocalActivationMetadata(effectiveLocalRoomId, result.messages, agentSession, {
                 includeTaskOwnerLeases: !replayingExistingMessages,
+                activeSessionRoomId: cloudRoomId || sessionRoomId,
+            });
+            const bounded = boundAgentMessageOutput(messages, {
+                direction: fetchPlan.mode === "catch_up_tail" ? "suffix" : "prefix",
+                maxBytes: AGENT_MESSAGE_BODY_MAX_BYTES,
             });
-            const routing = filterSilentActivationMessages(messages);
+            const routing = filterSilentActivationMessages(bounded.messages);
             const observedCursor = routing.last_observed_message_id ?? getLastMessageId(result);
             touchRoomSession(effectiveLocalRoomId, observedCursor);
             const threadContext = await collectThreadContextMessages({
@@ -320,8 +540,13 @@ export function registerWaitForMessagesTool(server) {
             return jsonToolResponse({
                 room_id: effectiveLocalRoomId,
                 ...addActivationRoutingTelemetry({
-                    messages: toAgentReadableMessages(routing.messages, threadContext),
+                    messages: toAgentReadableMessages(routing.messages, threadContext.messages),
                 }, routing),
+                ...(result.has_more || bounded.truncated ? { truncated: true } : {}),
+                ...(bounded.omittedMessageCount > 0
+                    ? { omitted_message_count: bounded.omittedMessageCount }
+                    : {}),
+                ...(threadContext.truncated ? { thread_context_truncated: true } : {}),
             });
         }
         await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, agentSession ? identityFromAgentSession(agentSession) : identity), agentSession);
@@ -333,6 +558,8 @@ export function registerWaitForMessagesTool(server) {
         const deliveryHeaders = buildAgentDeliveryHeaders(agentSession);
         const allMessages = [];
         let roomIdFromResponse;
+        let catchUpTruncated = false;
+        let apiObservedCursor = null;
         // Long-poll the server (blocks up to serverTimeout for new messages),
         // optionally seeded with a cursor. Shared by the cursor path and by the
         // no-cursor empty-tail fallback so a quiet room still blocks instead of
@@ -342,6 +569,7 @@ export function registerWaitForMessagesTool(server) {
             const params = new URLSearchParams();
             if (after)
                 params.set("after", after);
+            params.set("limit", String(MAX_WAIT_MESSAGES_PER_CALL));
             params.set("timeout", String(serverTimeout));
             const queryString = params.toString();
             const firstResult = await roomScopedApiCall({
@@ -349,6 +577,7 @@ export function registerWaitForMessagesTool(server) {
                 project_id: targetProjectId,
                 room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
                 project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
+                preserve_session_cursor: true,
                 options: buildWaitForMessagesRequestOptions({
                     deliveryHeaders,
                     signal: AbortSignal.timeout(clientTimeout),
@@ -356,25 +585,10 @@ export function registerWaitForMessagesTool(server) {
             });
             allMessages.push(...(firstResult.messages ?? []));
             roomIdFromResponse = roomIdFromResponse || firstResult.room_id || firstResult.project_id;
-            if (firstResult.has_more && allMessages.length > 0) {
-                let afterCursor = allMessages[allMessages.length - 1]?.id;
-                while (afterCursor) {
-                    const pageParams = new URLSearchParams();
-                    pageParams.set("after", afterCursor);
-                    const qs = pageParams.toString();
-                    const page = await roomScopedApiCall(buildWaitForMessagesHistoryPageRequest({
-                        targetRoomId,
-                        targetProjectId,
-                        queryString: qs,
-                        deliveryHeaders,
-                    }));
-                    const msgs = page.messages ?? [];
-                    allMessages.push(...msgs);
-                    if (!page.has_more || msgs.length === 0)
-                        break;
-                    afterCursor = msgs[msgs.length - 1]?.id;
-                }
-            }
+            catchUpTruncated = Boolean(firstResult.has_more);
+            apiObservedCursor = typeof firstResult.last_observed_message_id === "string"
+                ? firstResult.last_observed_message_id
+                : null;
         };
         if (fetchPlan.mode === "catch_up_tail") {
             // No cursor: catch up on only the bounded recent tail. Mirror
@@ -385,6 +599,7 @@ export function registerWaitForMessagesTool(server) {
                 targetRoomId,
                 targetProjectId,
                 limit: fetchPlan.limit,
+                deliveryHeaders,
             });
             if (recent.messages.length > 0) {
                 allMessages.push(...recent.messages);
@@ -402,7 +617,11 @@ export function registerWaitForMessagesTool(server) {
         else {
             await longPollFromCursor(fetchPlan.after);
         }
-        const routing = filterSilentActivationMessages(allMessages);
+        const bounded = boundAgentMessageOutput(allMessages, {
+            direction: fetchPlan.mode === "catch_up_tail" ? "suffix" : "prefix",
+            maxBytes: AGENT_MESSAGE_BODY_MAX_BYTES,
+        });
+        const routing = filterSilentActivationMessages(bounded.messages);
         const threadContext = await collectThreadContextMessages({
             messages: routing.messages,
             localRoomId,
@@ -410,13 +629,26 @@ export function registerWaitForMessagesTool(server) {
             projectId: targetProjectId,
         });
         const output = addActivationRoutingTelemetry({
-            messages: toAgentReadableMessages(routing.messages, threadContext),
+            messages: toAgentReadableMessages(routing.messages, threadContext.messages),
         }, routing);
+        if (threadContext.truncated)
+            output.thread_context_truncated = true;
         if (roomIdFromResponse) {
             output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
         }
+        if (catchUpTruncated || bounded.truncated)
+            output.truncated = true;
+        if (bounded.omittedMessageCount > 0) {
+            output.omitted_message_count = bounded.omittedMessageCount;
+        }
+        // The API cursor can cover concealed messages, but not visible messages
+        // omitted by our own byte bound. Resume after the retained page instead.
+        const observedCursor = !bounded.truncated && apiObservedCursor
+            ? apiObservedCursor
+            : routing.last_observed_message_id ?? undefined;
+        if (observedCursor)
+            output.last_observed_message_id = observedCursor;
         if (targetRoomId) {
-            const observedCursor = routing.last_observed_message_id ?? getLastMessageId(output);
             touchRoomSession(targetRoomId, observedCursor);
             if (allMessages.length > 0 && agentSession) {
                 const firstMsg = allMessages[0];

package/dist/mcp/server/tools/onboarding/status-tool.js

@@ -83,7 +83,7 @@ export function registerGetOnboardingStatusTool(server) {
         const storedAuth = getStoredAuth();
         const pendingAuth = getPendingDeviceAuth();
         const savedCurrentRoom = getStoredCurrentRoom();
-        const detectedRoom = configGitContext?.activeRoom ?? gitContext?.activeRoom ?? null;
+        const detectedRoom = configGitContext?.activeRoomLocator ?? gitContext?.activeRoomLocator ?? null;
         const api_health = await checkOnboardingApiHealth();
         const authenticated = Boolean(process.env.LETAGENTS_TOKEN || storedAuth);
         let nextStep = "join_room";
@@ -113,10 +113,10 @@ export function registerGetOnboardingStatusTool(server) {
             saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
             detected_room_from_context: detectedRoom,
             configured_room_from_file: configRoom,
-            configured_active_room_from_context: configGitContext?.activeRoom ?? null,
+            configured_active_room_from_context: configGitContext?.activeRoomLocator ?? null,
             derived_repo_room_from_git: gitContext?.repoRoom ?? null,
-            derived_active_git_room: gitContext?.activeRoom ?? null,
-            derived_branch_room_from_git: gitContext?.activeRefRoom ?? null,
+            derived_active_git_room: gitContext?.activeRoomLocator ?? null,
+            derived_branch_room_from_git: gitContext?.activeRefRoomLocator ?? null,
             git_current_branch: gitContext?.currentBranch ?? configGitContext?.currentBranch ?? null,
             git_default_branch: gitContext?.defaultBranch ?? configGitContext?.defaultBranch ?? null,
             repo_root: repoRoot,

package/dist/mcp/server/tools/rooms/inspection-tools.js

@@ -3,8 +3,10 @@ import { join } from "path";
 import { z } from "zod";
 import { getRoomFromConfig } from "../../../config-reader.js";
 import { buildActiveGitRoomContext, getGitCurrentBranch, getGitDefaultBranch, getGitRoomContext, } from "../../../git-remote.js";
-import { currentAgentIdentity, currentAgentIdentityKey, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicCurrentRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
+import { currentAgentIdentity, currentAgentIdentityKey, currentRoomMatchesLocator, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicCurrentRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
 import { requireValidWorkerBearerRuntime } from "../../runtime/worker-bearer.js";
+import { getDaemonToolExecutionContext, getRuntimeWorkingDirectory } from "../../runtime/daemon-tool-context.js";
+import { identityFromAgentSession } from "../../runtime/agent-sessions.js";
 import { findExistingConfig, resolveGitRoot, } from "../../repo-context.js";
 import { jsonToolResponse } from "./response.js";
 let ownerAuthStoreLoader = () => import("../../../local-state.js");
@@ -29,6 +31,7 @@ export function registerRoomInspectionTools(server) {
 }
 export async function getCurrentRoomPayload(conversationId) {
     const runtime = requireValidWorkerBearerRuntime();
+    const daemonContext = getDaemonToolExecutionContext();
     const publicCurrentRoom = toPublicCurrentRoomState();
     const workerAuth = runtime.mode !== "owner"
         ? { source: runtime.mode === "worker" ? "worker_bearer" : "daemon_supervised", expires_at: null, account: null }
@@ -55,9 +58,11 @@ export async function getCurrentRoomPayload(conversationId) {
         ...publicCurrentRoom,
         ...(runtime.mode === "supervised" ? { room_binding: "daemon_supervised" } : {}),
         ...localCodexDetails,
-        agent_identity: toPublicAgentIdentity(getConversationIdentity(conversationId)
-            ?? currentAgentIdentity
-            ?? getStoredAgentIdentity(currentAgentIdentityKey)),
+        agent_identity: toPublicAgentIdentity(daemonContext
+            ? identityFromAgentSession(daemonContext.agentSession)
+            : getConversationIdentity(conversationId)
+                ?? currentAgentIdentity
+                ?? getStoredAgentIdentity(currentAgentIdentityKey)),
         auth: workerAuth ?? (auth
             ? {
                 source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
@@ -73,7 +78,7 @@ export async function getCurrentRoomPayload(conversationId) {
 }
 function getRepoInspectionPayload(targetDir) {
     const runtime = requireValidWorkerBearerRuntime();
-    const startDir = targetDir || process.cwd();
+    const startDir = targetDir || getRuntimeWorkingDirectory();
     const repoRoot = resolveGitRoot(startDir);
     const configDir = repoRoot ? findExistingConfig(startDir) : null;
     const configPath = configDir ? join(configDir, ".letagents.json") : null;
@@ -86,8 +91,8 @@ function getRepoInspectionPayload(targetDir) {
             defaultBranch: repoRoot ? getGitDefaultBranch(repoRoot) : null,
         })
         : null;
-    const detectedRoom = configGitContext?.activeRoom ?? gitContext?.activeRoom ?? null;
-    const currentRoomMatchesContext = Boolean(currentRoom && detectedRoom && currentRoom.room_id === detectedRoom);
+    const detectedRoom = configGitContext?.activeRoomLocator ?? gitContext?.activeRoomLocator ?? null;
+    const currentRoomMatchesContext = currentRoomMatchesLocator(detectedRoom);
     return {
         cwd: startDir,
         repo_context_status: repoRoot ? "git_repo_detected" : "not_inside_git_repo",
@@ -95,10 +100,10 @@ function getRepoInspectionPayload(targetDir) {
         config_file: configPath ?? null,
         config_contents: readConfigContents(configPath),
         configured_room_from_file: configuredRoom ?? null,
-        configured_active_room_from_context: configGitContext?.activeRoom ?? null,
-        derived_room_from_git: gitContext?.activeRoom ?? null,
+        configured_active_room_from_context: configGitContext?.activeRoomLocator ?? null,
+        derived_room_from_git: gitContext?.activeRoomLocator ?? null,
         derived_repo_room_from_git: gitContext?.repoRoom ?? null,
-        derived_branch_room_from_git: gitContext?.activeRefRoom ?? null,
+        derived_branch_room_from_git: gitContext?.activeRefRoomLocator ?? null,
         git_current_branch: gitContext?.currentBranch ?? configGitContext?.currentBranch ?? null,
         git_default_branch: gitContext?.defaultBranch ?? configGitContext?.defaultBranch ?? null,
         detected_room_from_context: detectedRoom ?? null,