letagents 0.12.11 → 0.12.13

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

@@ -1,9 +1,10 @@
 import { z } from "zod";
 import { getPollTimeoutCapMs } from "../../../../shared/poll-timeout-cap.js";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { appendIncludePromptOnly, buildAgentDeliveryHeaders, 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 } 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, supervisedBoundedDeliveryDisabledToolResult, } from "../../runtime/worker-bearer.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 +14,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 +26,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 +108,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 +344,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 +384,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,16 +421,22 @@ 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'. If someone posted a premature 'I will wait' closing line, use send_message with a brief continue instruction. Per-call wait is capped (default max 180s unless LETAGENTS_POLL_MAX_MS is set on API and MCP).", {
+    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).", {
         room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
         after_message_id: z
             .string()
@@ -250,16 +451,41 @@ export function registerWaitForMessagesTool(server) {
             .optional()
             .describe("Registered agent session to use. Without this, the MCP transport is treated as controller traffic and is hidden from connected-agent activity."),
     }, async ({ room_id, after_message_id, timeout, agent_session_id }) => {
+        // This guard intentionally runs before room resolution, identity setup,
+        // local SQLite reads, presence writes, or HTTP traffic. In supervised
+        // bounded-turn mode the daemon is the sole inbox owner.
+        const boundedDeliveryDisabled = supervisedBoundedDeliveryDisabledToolResult();
+        if (boundedDeliveryDisabled) {
+            return jsonToolResponse(boundedDeliveryDisabled);
+        }
         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 routingStateSnapshot = 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 identity = await ensureAgentIdentity();
         const agentSession = resolveWaitAgentSession(sessionRoomId, agent_session_id);
+        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
+            // cannot read after a successor generation takes ownership.
+            await bindSupervisedWorkerSession(agentSession, process.env, { allowConfirmedFastPath: true });
+            // A cursor is acknowledged only when the worker explicitly uses it to
+            // request the next page. Persisting a cursor from the response we are
+            // still constructing could skip a message if serialization, presence,
+            // or the provider turn fails afterward.
+            if (after_message_id)
+                scheduleSupervisedWorkerCursorCheckpoint(agentSession, after_message_id);
+        }
         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,
@@ -270,11 +496,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;
@@ -283,13 +510,20 @@ 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);
-            touchRoomSession(effectiveLocalRoomId, routing.last_observed_message_id ?? getLastMessageId(result));
+            const routing = filterSilentActivationMessages(bounded.messages);
+            const observedCursor = routing.last_observed_message_id ?? getLastMessageId(result);
+            touchRoomSession(effectiveLocalRoomId, observedCursor);
             const threadContext = await collectThreadContextMessages({
                 messages: routing.messages,
                 localRoomId: effectiveLocalRoomId,
@@ -299,8 +533,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);
@@ -312,6 +551,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
@@ -321,6 +562,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({
@@ -335,25 +577,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
@@ -364,6 +591,7 @@ export function registerWaitForMessagesTool(server) {
                 targetRoomId,
                 targetProjectId,
                 limit: fetchPlan.limit,
+                deliveryHeaders,
             });
             if (recent.messages.length > 0) {
                 allMessages.push(...recent.messages);
@@ -381,7 +609,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,
@@ -389,13 +621,54 @@ 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;
+        }
+        if (apiObservedCursor)
+            output.last_observed_message_id = apiObservedCursor;
         if (targetRoomId) {
-            touchRoomSession(targetRoomId, routing.last_observed_message_id ?? getLastMessageId(output));
+            const observedCursor = apiObservedCursor
+                ?? routing.last_observed_message_id
+                ?? getLastMessageId(output);
+            touchRoomSession(targetRoomId, observedCursor);
+            if (allMessages.length > 0 && agentSession) {
+                const firstMsg = allMessages[0];
+                const lastMsg = allMessages[allMessages.length - 1];
+                if (typeof firstMsg?.id === "string" && typeof lastMsg?.id === "string") {
+                    try {
+                        await roomScopedApiCall({
+                            room_id: targetRoomId,
+                            project_id: targetProjectId,
+                            room_path: (r) => `/rooms/${encodeRoomIdPath(r)}/agents/self/observation`,
+                            project_path: (p) => `/projects/${encodeURIComponent(p)}/agents/self/observation`,
+                            options: {
+                                method: "PUT",
+                                body: JSON.stringify({
+                                    first_message_id: firstMsg.id,
+                                    last_message_id: lastMsg.id,
+                                    ...agentSessionCredentials(agentSession),
+                                }),
+                            },
+                        });
+                    }
+                    catch {
+                        // Non-blocking telemetry
+                    }
+                }
+            }
+            // Delivery alone is observation evidence (the span above), never a
+            // "responding" receipt: an agent that ignores an activation must not
+            // present as responding. Receipts advance only on real transitions —
+            // send-tool marks "replied" when the agent actually publishes a reply.
         }
         await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, agentSession ? identityFromAgentSession(agentSession) : identity), agentSession);
         return jsonToolResponse(output);

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

@@ -56,16 +56,17 @@ export function registerGetOnboardingStatusTool(server) {
         if (workerRuntime.mode === "invalid") {
             return jsonTextResponse({ success: false, error: "worker_bearer_configuration_invalid", message: workerRuntime.error });
         }
-        if (workerRuntime.mode === "worker") {
+        if (workerRuntime.mode === "worker" || workerRuntime.mode === "supervised") {
             return jsonTextResponse({
                 api_url: API_URL,
-                worker_bearer_mode: true,
+                worker_bearer_mode: workerRuntime.mode === "worker",
+                supervised_bounded_mode: workerRuntime.mode === "supervised",
                 authenticated: true,
-                auth_source: "worker_bearer",
+                auth_source: workerRuntime.mode === "worker" ? "worker_bearer" : "daemon_supervised",
                 account: null,
                 pending_device_auth: null,
                 next_step: "join_room",
-                note: "Owner-auth onboarding and saved-auth state are disabled in worker bearer mode.",
+                note: "Owner-auth onboarding and saved-auth state are disabled in worker credential mode.",
             });
         }
         const workingDir = cwd || process.cwd();
@@ -82,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";
@@ -112,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,