letagents 0.12.10 → 0.12.12

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { agentSessionCredentials, addLocalChatMessage, appendIncludePromptOnly, currentRoom, getFallbackProjectId, getLocalChatMessages, getRememberedRoomPresence, getTargetRoomId, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, resolveWorkerToolIdentity, roomScopedApiCall, syncRoomPresence, toPublicAgentIdentity, touchCurrentRoom, } from "../../runtime.js";
+import { agentSessionCredentials, addLocalChatMessage, currentRoom, getFallbackProjectId, getRememberedRoomPresence, getTargetRoomId, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, resolveWorkerToolIdentity, roomScopedApiCall, syncRoomPresence, toPublicAgentIdentity, touchCurrentRoom, } from "../../runtime.js";
+import { findLocalMessageById, findRemoteMessageById } from "./message-lookup.js";
 import { jsonToolResponse } from "./response.js";
 export function buildSendMessageRequestBody(input) {
     return {
@@ -22,50 +23,6 @@ function explicitThreadRootId(message) {
     }
     return null;
 }
-async function findLocalMessageById(roomId, messageId) {
-    let afterCursor;
-    for (;;) {
-        const result = await getLocalChatMessages(roomId, {
-            after: afterCursor,
-            include_prompt_only: true,
-        });
-        const messages = (result.messages ?? []);
-        const match = messages.find((message) => message.id === messageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
-        if (!afterCursor)
-            return null;
-    }
-}
-async function findRemoteMessageById(input) {
-    let afterCursor;
-    for (;;) {
-        const query = new URLSearchParams();
-        if (afterCursor)
-            query.set("after", afterCursor);
-        const qs = query.toString();
-        const result = await roomScopedApiCall({
-            room_id: input.roomId,
-            project_id: input.projectId,
-            room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages${qs ? `?${qs}` : ""}`),
-            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`),
-        });
-        const messages = result.messages ?? [];
-        const match = messages.find((message) => message.id === input.messageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
-        if (!afterCursor)
-            return null;
-    }
-}
 async function findMessageById(input) {
     if (input.localRoomId && await isLocalRoomStorageEnabled(input.localRoomId)) {
         const { localRoomId } = await resolveLocalRoomStorageIdentifiers(input.localRoomId);
@@ -155,6 +112,9 @@ async function sendMessageFromTool(input) {
     });
     touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
     await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity), agentSession);
+    // The `replied` receipt transition is server-owned: message creation marks
+    // the publisher's receipt on the reply target atomically with the reply
+    // itself, for MCP workers and supervised daemon publications alike.
     return jsonToolResponse({
         ...message,
         agent_identity: toPublicAgentIdentity(identity),

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

@@ -1,10 +1,30 @@
 import { z } from "zod";
 import { getPollTimeoutCapMs } from "../../../../shared/poll-timeout-cap.js";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { appendIncludePromptOnly, buildAgentDeliveryHeaders, currentRoom, ensureAgentIdentity, getFallbackProjectId, getLocalChatMessages, getLastMessageId, getRememberedRoomPresence, getTargetRoomId, identityFromAgentSession, isLocalRoomStorageEnabled, listLocalTasks, resolveLocalRoomStorageIdentifiers, resolveAgentSession, roomScopedApiCall, syncRoomPresence, toAgentReadableMessages, touchRoomSession, waitForLocalChatMessages, } from "../../runtime.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 { findLocalMessageById, findRemoteMessageById } from "./message-lookup.js";
+import { fetchRecentRemoteMessages } from "./read-tool.js";
 import { jsonToolResponse } from "./response.js";
 const DEFAULT_POLL_TIMEOUT_MS = 30000;
+// When wait_for_messages is called WITHOUT an after_message_id cursor, it must
+// catch up on only the most RECENT messages instead of replaying the entire
+// 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 function planWaitForMessagesFetch(input) {
+    if (input.effectiveAfterMessageId) {
+        return { mode: "after_cursor", after: input.effectiveAfterMessageId };
+    }
+    return {
+        mode: "catch_up_tail",
+        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 {
@@ -88,6 +108,10 @@ function addActivationRoutingTelemetry(output, routing) {
     return output;
 }
 export function resolveWaitAgentSession(roomId, agentSessionId) {
+    if (requireValidWorkerBearerRuntime().mode === "worker" &&
+        (!agentSessionId?.trim() || agentSessionId === WORKER_BEARER_AGENT_SESSION_ID)) {
+        return null;
+    }
     if (!agentSessionId?.trim()) {
         return null;
     }
@@ -130,57 +154,53 @@ async function attachLocalActivationMetadata(roomId, messages, agentSession, opt
         session_kind: agentSession.session_kind,
     }, activationContext);
 }
-async function findLocalMessageById(roomId, targetMessageId) {
-    let afterCursor;
-    for (;;) {
-        const result = await getLocalChatMessages(roomId, {
-            after: afterCursor,
-            include_prompt_only: true,
-        });
-        const messages = (result.messages ?? []).filter(isRecord);
-        const match = messages.find((message) => message.id === targetMessageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = messageId(lastMessage) ?? undefined;
-        if (!afterCursor)
-            return null;
-    }
+// 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)
+// messages are cached per process to keep repeat polls from re-resolving the
+// same thread roots. Message ids are
+// room-scoped, so the key includes the room scope. Message records are treated
+// as immutable once posted; a bounded insertion-ordered map keeps memory flat
+// for long-running workers.
+const THREAD_CONTEXT_CACHE_MAX = 500;
+const threadContextCache = new Map();
+function threadContextCacheKey(scopeId, targetMessageId) {
+    return `${scopeId}:${targetMessageId}`;
 }
-async function findRemoteMessageById(input) {
-    let afterCursor;
-    for (;;) {
-        const params = new URLSearchParams();
-        if (afterCursor)
-            params.set("after", afterCursor);
-        const queryString = params.toString();
-        const result = await roomScopedApiCall({
-            room_id: input.roomId,
-            project_id: input.projectId,
-            room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages${queryString ? `?${queryString}` : ""}`),
-            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${queryString ? `?${queryString}` : ""}`),
-        });
-        const messages = (result.messages ?? []).filter(isRecord);
-        const match = messages.find((message) => message.id === input.targetMessageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = messageId(lastMessage) ?? undefined;
-        if (!afterCursor)
-            return null;
+export function rememberThreadContextMessages(scopeId, records) {
+    for (const record of records) {
+        if (!isRecord(record))
+            continue;
+        const id = messageId(record);
+        if (!id)
+            continue;
+        const key = threadContextCacheKey(scopeId, id);
+        threadContextCache.delete(key);
+        threadContextCache.set(key, record);
+    }
+    while (threadContextCache.size > THREAD_CONTEXT_CACHE_MAX) {
+        const oldest = threadContextCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        threadContextCache.delete(oldest);
     }
 }
-async function collectThreadContextMessages(input) {
+export function resetThreadContextCacheForTests() {
+    threadContextCache.clear();
+}
+export async function collectThreadContextMessages(input) {
     const records = input.messages.filter(isRecord);
     const knownIds = new Set(records.map(messageId).filter((id) => Boolean(id)));
     const seenIds = new Set(knownIds);
     const pendingIds = records
         .map(replyReferenceId)
         .filter((id) => Boolean(id && !knownIds.has(id)));
+    const scopeId = input.roomId ?? input.localRoomId ?? input.projectId ?? "";
+    rememberThreadContextMessages(scopeId, records);
+    if (pendingIds.length === 0) {
+        // Nothing quotes an out-of-window message (idle polls land here), so skip
+        // storage-mode resolution entirely.
+        return [];
+    }
     const contextMessages = [];
     const useLocalStorage = Boolean(input.localRoomId && await isLocalRoomStorageEnabled(input.localRoomId));
     const localIdentifiers = useLocalStorage
@@ -192,15 +212,20 @@ async function collectThreadContextMessages(input) {
         if (!nextId || seenIds.has(nextId))
             continue;
         seenIds.add(nextId);
-        const message = useLocalStorage && input.localRoomId
-            ? await findLocalMessageById(sqliteRoomId || input.localRoomId, nextId)
-            : await findRemoteMessageById({
-                roomId: input.roomId,
-                projectId: input.projectId,
-                targetMessageId: nextId,
-            });
+        const cached = threadContextCache.get(threadContextCacheKey(scopeId, nextId));
+        const message = cached
+            ?? (useLocalStorage && input.localRoomId
+                ? await findLocalMessageById(sqliteRoomId || input.localRoomId, nextId)
+                : await findRemoteMessageById({
+                    roomId: input.roomId,
+                    projectId: input.projectId,
+                    messageId: nextId,
+                }));
         if (!message)
             continue;
+        if (!cached) {
+            rememberThreadContextMessages(scopeId, [message]);
+        }
         contextMessages.push(message);
         const parentId = replyReferenceId(message);
         if (parentId && !seenIds.has(parentId)) {
@@ -210,12 +235,12 @@ async function collectThreadContextMessages(input) {
     return contextMessages;
 }
 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()
             .optional()
-            .describe("Only return messages after this message ID (e.g. 'msg_3'). If omitted, returns all existing messages immediately."),
+            .describe(`Only return messages after this message ID (e.g. 'msg_3'). If omitted, returns just the most recent ${DEFAULT_WAIT_CATCHUP_LIMIT} messages (bounded recent tail) instead of the full room history, and advances the session cursor to the newest message.`),
         timeout: z
             .number()
             .optional()
@@ -225,12 +250,32 @@ 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 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)) {
@@ -239,10 +284,19 @@ export function registerWaitForMessagesTool(server) {
             const effectiveAfterMessageId = resolveEffectiveAfterMessageId({
                 requestedAfterMessageId: after_message_id,
             });
-            const existing = await getLocalChatMessages(effectiveLocalRoomId, {
-                after: effectiveAfterMessageId,
-                include_prompt_only: true,
-            });
+            const fetchPlan = planWaitForMessagesFetch({ effectiveAfterMessageId });
+            // Without a cursor, page BACKWARDS from the tail (getLatest…) so we
+            // return the most-recent messages, not the oldest N; with a cursor we
+            // keep the unchanged forward "everything after the cursor" behavior.
+            const existing = fetchPlan.mode === "catch_up_tail"
+                ? await getLatestLocalChatMessages(effectiveLocalRoomId, {
+                    limit: fetchPlan.limit,
+                    include_prompt_only: true,
+                })
+                : await getLocalChatMessages(effectiveLocalRoomId, {
+                    after: effectiveAfterMessageId,
+                    include_prompt_only: true,
+                });
             const replayingExistingMessages = existing.messages.length > 0;
             const result = replayingExistingMessages
                 ? existing
@@ -255,7 +309,8 @@ export function registerWaitForMessagesTool(server) {
                 includeTaskOwnerLeases: !replayingExistingMessages,
             });
             const routing = filterSilentActivationMessages(messages);
-            touchRoomSession(effectiveLocalRoomId, routing.last_observed_message_id ?? getLastMessageId(result));
+            const observedCursor = routing.last_observed_message_id ?? getLastMessageId(result);
+            touchRoomSession(effectiveLocalRoomId, observedCursor);
             const threadContext = await collectThreadContextMessages({
                 messages: routing.messages,
                 localRoomId: effectiveLocalRoomId,
@@ -271,46 +326,82 @@ export function registerWaitForMessagesTool(server) {
         }
         await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, agentSession ? identityFromAgentSession(agentSession) : identity), agentSession);
         const clientTimeout = serverTimeout + (serverTimeout > 120_000 ? 120_000 : 5_000);
-        const params = new URLSearchParams();
         const effectiveAfterMessageId = resolveEffectiveAfterMessageId({
             requestedAfterMessageId: after_message_id,
         });
-        if (effectiveAfterMessageId)
-            params.set("after", effectiveAfterMessageId);
-        params.set("timeout", String(serverTimeout));
-        const queryString = params.toString();
+        const fetchPlan = planWaitForMessagesFetch({ effectiveAfterMessageId });
         const deliveryHeaders = buildAgentDeliveryHeaders(agentSession);
-        const firstResult = await roomScopedApiCall({
-            room_id: targetRoomId,
-            project_id: targetProjectId,
-            room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
-            project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
-            options: buildWaitForMessagesRequestOptions({
-                deliveryHeaders,
-                signal: AbortSignal.timeout(clientTimeout),
-            }),
-        });
-        const allMessages = [...(firstResult.messages ?? [])];
-        const 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,
+        const allMessages = [];
+        let roomIdFromResponse;
+        // 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
+        // busy-spinning. When `after` is provided this also catches up any backlog
+        // after the cursor via forward pagination.
+        const longPollFromCursor = async (after) => {
+            const params = new URLSearchParams();
+            if (after)
+                params.set("after", after);
+            params.set("timeout", String(serverTimeout));
+            const queryString = params.toString();
+            const firstResult = await roomScopedApiCall({
+                room_id: targetRoomId,
+                project_id: targetProjectId,
+                room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
+                project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
+                options: buildWaitForMessagesRequestOptions({
                     deliveryHeaders,
-                }));
-                const msgs = page.messages ?? [];
-                allMessages.push(...msgs);
-                if (!page.has_more || msgs.length === 0)
-                    break;
-                afterCursor = msgs[msgs.length - 1]?.id;
+                    signal: AbortSignal.timeout(clientTimeout),
+                }),
+            });
+            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;
+                }
+            }
+        };
+        if (fetchPlan.mode === "catch_up_tail") {
+            // No cursor: catch up on only the bounded recent tail. Mirror
+            // read_messages by paging BACKWARDS from the tail (before=latest) so we
+            // return the newest N and never walk the full room history. This also
+            // advances the session cursor to the newest message returned.
+            const recent = await fetchRecentRemoteMessages({
+                targetRoomId,
+                targetProjectId,
+                limit: fetchPlan.limit,
+            });
+            if (recent.messages.length > 0) {
+                allMessages.push(...recent.messages);
+                roomIdFromResponse = recent.roomIdFromResponse;
+            }
+            else {
+                // Empty tail => the room is effectively empty, so there is nothing to
+                // dump. Fall through to the long-poll (no cursor) so a worker looping
+                // in a quiet room blocks up to the timeout instead of busy-spinning,
+                // exactly as the local path does via waitForLocalChatMessages.
+                roomIdFromResponse = recent.roomIdFromResponse;
+                await longPollFromCursor();
             }
         }
+        else {
+            await longPollFromCursor(fetchPlan.after);
+        }
         const routing = filterSilentActivationMessages(allMessages);
         const threadContext = await collectThreadContextMessages({
             messages: routing.messages,
@@ -325,7 +416,37 @@ export function registerWaitForMessagesTool(server) {
             output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
         }
         if (targetRoomId) {
-            touchRoomSession(targetRoomId, routing.last_observed_message_id ?? getLastMessageId(output));
+            const observedCursor = 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/device-auth-tools.js

@@ -3,6 +3,7 @@ import { getRoomFromConfig } from "../../../config-reader.js";
 import { looksLikeInviteCode } from "../../../room-id.js";
 import { apiCall, clearAuthenticatedAccountCache, clearPendingDeviceAuth, clearStoredAuth, currentRoom, ensureAgentIdentity, getPendingDeviceAuth, joinRoomIdentifierWithoutImplicitGitRefCreate, setAuthenticatedAccountCache, setPendingDeviceAuth, setStoredAuth, toPublicAgentIdentity, withCanonicalRoomLink, } from "../../runtime.js";
 import { jsonTextResponse } from "./responses.js";
+import { workerModeDisabledToolResult } from "../../runtime/worker-bearer.js";
 export function registerDeviceAuthTools(server) {
     registerStartDeviceAuthTool(server);
     registerPollDeviceAuthTool(server);
@@ -19,6 +20,9 @@ function registerStartDeviceAuthTool(server) {
             .optional()
             .describe("If true, replaces any existing pending device auth request."),
     }, async ({ room_id, force }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const existing = getPendingDeviceAuth();
         if (existing && !force) {
             return jsonTextResponse({
@@ -60,6 +64,9 @@ function registerPollDeviceAuthTool(server) {
             .optional()
             .describe("If true, tries to join the room immediately after the auth succeeds."),
     }, async ({ request_id, room_id, auto_join }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const pendingAuth = request_id
             ? getPendingDeviceAuth()?.request_id === request_id
                 ? getPendingDeviceAuth()
@@ -137,6 +144,9 @@ function registerPollDeviceAuthTool(server) {
 }
 function registerClearSavedAuthTool(server) {
     server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token and pending device auth request.", {}, async () => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         clearPendingDeviceAuth();
         clearStoredAuth();
         clearAuthenticatedAccountCache();

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

@@ -3,6 +3,7 @@ import { buildAgentActorLabel, formatOwnerAttribution } from "../../../../shared
 import { normalizeAgentBaseName } from "../../../../shared/codenames.js";
 import { apiCall, currentAgentIdentity, currentAgentIdentityKey, detectAgentIdeLabel, getConversationIdentity, getLetagentsToken, resolveOwnerContext, setConversationIdentity, storeCurrentAgentIdentity, toPublicAgentIdentity, } from "../../runtime.js";
 import { jsonTextResponse } from "./responses.js";
+import { workerModeDisabledToolResult } from "../../runtime/worker-bearer.js";
 export function registerSetAgentNameTool(server) {
     server.tool("set_agent_name", "Set or change the agent's display name. The agent will be known by this name in the room. Use this to pick a custom name instead of the auto-generated codename.", {
         name: z
@@ -15,6 +16,9 @@ export function registerSetAgentNameTool(server) {
             .optional()
             .describe("Optional conversation ID to scope this name change. When provided, only this conversation uses the new name; other conversations keep their own identity."),
     }, async ({ name: desiredName, conversation_id }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const trimmedName = desiredName.trim();
         if (trimmedName.length < 2 || trimmedName.length > 64) {
             return jsonTextResponse({
@@ -22,7 +26,7 @@ export function registerSetAgentNameTool(server) {
                 error: "Name must be between 2 and 64 characters.",
             });
         }
-        const authAvailable = Boolean(getLetagentsToken());
+        const authAvailable = Boolean(await getLetagentsToken());
         if (!authAvailable) {
             return jsonTextResponse({
                 success: false,

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

@@ -4,6 +4,7 @@ import { buildActiveGitRoomContext, getGitCurrentBranch, getGitDefaultBranch, ge
 import { resolveGitRoot } from "../../repo-context.js";
 import { API_URL, currentAgentIdentity, currentAgentIdentityKey, currentRoom, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, toPublicAgentIdentity, toPublicRoomState, toPublicStoredRoomSession, } from "../../runtime.js";
 import { jsonTextResponse } from "./responses.js";
+import { getWorkerBearerRuntime } from "../../runtime/worker-bearer.js";
 export async function checkOnboardingApiHealth(apiUrl = API_URL, fetchImpl = globalThis.fetch, timeoutMs = 1500) {
     const url = `${apiUrl.replace(/\/+$/, "")}/api/health`;
     const controller = new AbortController();
@@ -51,6 +52,23 @@ export function registerGetOnboardingStatusTool(server) {
             .optional()
             .describe("Working directory to inspect for repo context. Defaults to the current process directory."),
     }, async ({ cwd }) => {
+        const workerRuntime = getWorkerBearerRuntime();
+        if (workerRuntime.mode === "invalid") {
+            return jsonTextResponse({ success: false, error: "worker_bearer_configuration_invalid", message: workerRuntime.error });
+        }
+        if (workerRuntime.mode === "worker" || workerRuntime.mode === "supervised") {
+            return jsonTextResponse({
+                api_url: API_URL,
+                worker_bearer_mode: workerRuntime.mode === "worker",
+                supervised_bounded_mode: workerRuntime.mode === "supervised",
+                authenticated: true,
+                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 credential mode.",
+            });
+        }
         const workingDir = cwd || process.cwd();
         const repoRoot = resolveGitRoot(workingDir);
         const configRoom = getRoomFromConfig(workingDir);

package/dist/mcp/server/tools/rental/context-tools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { rentalReadFile, rentalSearch } from "../../../rental-tools.js";
+import { rentalReadFile, rentalRequestContext, rentalSearch, } from "../../../rental-tools.js";
 import { rentalTextResponse } from "./response.js";
 export function registerRentalContextTools({ server, deps, }) {
     server.tool("rental_read_file", "Read one repo-relative file from the scoped rental workspace through the Context Broker. The server applies the Secret Firewall, records an Exposure Ledger entry, and returns redacted content when needed. This is the only approved file-read path for provider agents in scoped mode.", {
@@ -32,4 +32,12 @@ export function registerRentalContextTools({ server, deps, }) {
         max_results,
         case_sensitive,
     })));
+    server.tool("rental_request_context", "Request renter approval to access a file outside the approved rental scope. Use this when rental_read_file returns file_not_found for a path you believe exists in the repo. Creates a pending context access request the renter can approve or deny; once approved, the file is materialized into the workspace and becomes readable via rental_read_file. Repeat calls for the same path return the existing pending request, and re-asking for an already-approved path retries delivery into the workspace (useful if the workspace was not ready at approval time).", {
+        session_id: z.string().describe("Rental session id the request belongs to."),
+        path: z.string().describe("Repo-relative path you need access to."),
+        reason: z
+            .string()
+            .optional()
+            .describe("Short justification shown to the renter (max 500 chars)."),
+    }, async ({ session_id, path, reason }) => rentalTextResponse(await rentalRequestContext(deps, { session_id, path, reason })));
 }