letagents 0.12.11 → 0.12.13

package/dist/mcp/server/register-tools.js

@@ -4,16 +4,29 @@ import { registerOnboardingTools } from "./tools/onboarding.js";
 import { registerRentalTools } from "./tools/rental.js";
 import { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./tools/rooms.js";
 import { registerTaskTools } from "./tools/tasks.js";
-export function registerTools(server) {
-    registerRoomJoinTools(server);
-    registerAgentSessionTools(server);
-    registerRoomInspectionTools(server);
-    registerStatusTools(server);
-    registerTaskTools(server);
-    registerRepoInitializationTool(server);
-    registerMessageTools(server);
-    registerOnboardingTools(server);
-    registerRoomResumeTool(server);
-    registerRentalTools(server);
-    registerRepoVisibilityTool(server);
+import { registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
+import { toolSurfaceForExecutionProfile } from "./runtime/tool-surface-policy.js";
+import { profileAwareToolServer } from "./supervised-tool-facade.js";
+export function registerTools(server, profile = "autonomous_mcp_worker", supervisedProvider = process.env.LETAGENTS_SUPERVISOR_PROVIDER?.trim() || null, options = {}) {
+    const tools = options.executionOwner === "daemon"
+        ? server
+        : profileAwareToolServer(server, profile, undefined, supervisedProvider);
+    const surface = toolSurfaceForExecutionProfile(profile);
+    registerRoomJoinTools(tools);
+    if (surface.agentSessionLifecycle)
+        registerAgentSessionTools(tools);
+    registerRoomInspectionTools(tools);
+    registerStatusTools(tools);
+    registerTaskTools(tools);
+    registerRepoInitializationTool(tools);
+    registerMessageTools(tools, { includeDeliveryLoop: surface.deliveryLoop });
+    if (profile === "supervised_room_turn" && supervisedProvider === "cursor")
+        registerSupervisedRoomTurnTools(tools);
+    if (surface.onboarding)
+        registerOnboardingTools(tools);
+    if (surface.roomResume)
+        registerRoomResumeTool(tools);
+    if (surface.rental)
+        registerRentalTools(tools);
+    registerRepoVisibilityTool(tools);
 }

package/dist/mcp/server/runtime/agent-sessions.js

@@ -1,17 +1,20 @@
-import { getStoredAgentSession, isLocalRoomStorageEnabled, saveAgentSession, } from "../../local-state.js";
+import { getStoredAgentSession, isLocalRoomStorageEnabled, replaceLocalWorkerAgentSession, saveAgentSession, } from "../../local-state.js";
 import { getGitCurrentBranch } from "../../git-remote.js";
 import { randomUUID } from "node:crypto";
 import { normalizeAgentBaseName } from "../../../shared/codenames.js";
 import { formatOwnerAttribution } from "../../../shared/agent-identity.js";
 import { LETAGENTS_AGENT_SESSION_ID_HEADER, LETAGENTS_AGENT_SESSION_TOKEN_HEADER, } from "../../../shared/request-headers.js";
 import { AGENT_INSTANCE_UUID, detectAgentIdeLabel, detectAgentRuntimeLabel, ensureAgentIdentity, } from "./identity.js";
-import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { isSupervisedBoundedTurn, requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { resolveCurrentSupervisedWorkerSession } from "./supervisor-bridge.js";
+import { getDaemonToolExecutionContext, getRuntimeWorkingDirectory } from "./daemon-tool-context.js";
 // A worker bearer already represents a server-side worker session. This local
 // marker lets the MCP tool contract stay session-shaped without persisting or
 // transmitting a second set of credentials.
 export const WORKER_BEARER_AGENT_SESSION_ID = "worker_bearer";
 export function buildAgentDeliveryHeaders(agentSession) {
-    if (!agentSession || requireValidWorkerBearerRuntime().mode === "worker") {
+    const runtime = requireValidWorkerBearerRuntime();
+    if (!agentSession || runtime.mode === "worker" || runtime.mode === "supervised") {
         return {};
     }
     return {
@@ -62,6 +65,33 @@ export function resolveAgentSession(roomId, sessionId) {
     }
     return session;
 }
+/**
+ * The stable base this client declares as `requested_base_display_name` when
+ * registering. Rules (task_66):
+ * - An explicit display_name that replays the EXACT label of any prior stored
+ *   session for this room+identity is a resume, not a rename: reuse the base
+ *   recorded when THAT label was allocated, so a server-decorated label
+ *   converges. The whole lineage is consulted (most recent first) because a
+ *   latest-only lookup would lose an older concurrent sibling's base and
+ *   misread its restart as a deliberate rename.
+ * - Any other explicit display_name is deliberate intent and IS the base —
+ *   a numeric-ending custom name ("Agent 47") is therefore never demoted.
+ * - With no explicit name, fall back to the most recent recorded base in the
+ *   lineage, then to the durable identity's display name.
+ */
+export function resolveClientRequestedBase(input) {
+    const explicit = input.explicitDisplayName?.trim() || "";
+    const lineage = input.priorSessions ?? [];
+    if (explicit) {
+        const replayed = lineage.find((session) => session.display_name?.trim() === explicit);
+        const replayedBase = replayed?.requested_base_display_name?.trim() || "";
+        return replayedBase || explicit;
+    }
+    const latestBase = lineage
+        .map((session) => session.requested_base_display_name?.trim() || "")
+        .find((base) => base.length > 0);
+    return latestBase || input.identityDisplayName.trim();
+}
 export function identityFromAgentSession(session) {
     return {
         name: normalizeAgentBaseName(session.display_name),
@@ -88,7 +118,22 @@ export function requireWorkerAgentSession(roomId, sessionId) {
     return session;
 }
 export async function resolveWorkerToolIdentity(input) {
-    if (requireValidWorkerBearerRuntime().mode === "worker" &&
+    const runtimeMode = requireValidWorkerBearerRuntime().mode;
+    if (runtimeMode === "supervised") {
+        const daemonContext = getDaemonToolExecutionContext();
+        const agentSession = daemonContext?.agentSession
+            ?? await resolveCurrentSupervisedWorkerSession(input.roomId);
+        if (input.roomId && input.roomId !== agentSession.room_id) {
+            throw new Error(`Daemon-supervised worker session is registered for ${agentSession.room_id}, not ${input.roomId}.`);
+        }
+        if (input.agentSessionId
+            && input.agentSessionId !== WORKER_BEARER_AGENT_SESSION_ID
+            && input.agentSessionId !== agentSession.session_id) {
+            throw new Error(`Daemon-supervised worker session is ${agentSession.session_id}, not ${input.agentSessionId}.`);
+        }
+        return { identity: identityFromAgentSession(agentSession), agentSession };
+    }
+    if (runtimeMode === "worker" &&
         (!input.agentSessionId || input.agentSessionId === WORKER_BEARER_AGENT_SESSION_ID)) {
         const identity = await ensureAgentIdentity();
         const now = new Date().toISOString();
@@ -121,7 +166,7 @@ export async function resolveWorkerToolIdentity(input) {
     }
     const agentSession = input.agentSessionId
         ? requireWorkerAgentSession(input.roomId, input.agentSessionId)
-        : input.roomId && await isLocalRoomStorageEnabled(input.roomId)
+        : input.roomId && !isSupervisedBoundedTurn() && await isLocalRoomStorageEnabled(input.roomId)
             ? await ensureLocalWorkerAgentSession(input.roomId)
             : requireWorkerAgentSession(input.roomId, input.agentSessionId);
     return {
@@ -134,7 +179,7 @@ export async function ensureLocalWorkerAgentSession(roomId, input = {}) {
     const now = new Date().toISOString();
     const runtime = input.runtime?.trim() || detectAgentRuntimeLabel();
     const displayName = input.displayName?.trim() || identity.display_name;
-    return saveAgentSession({
+    const session = {
         session_id: `local_${randomUUID()}`,
         session_token: `local_${randomUUID()}`,
         room_id: roomId,
@@ -156,14 +201,18 @@ export async function ensureLocalWorkerAgentSession(roomId, input = {}) {
         updated_at: now,
         last_seen_at: now,
         ended_at: null,
-    });
+    };
+    return session.session_kind === "worker"
+        ? replaceLocalWorkerAgentSession(session)
+        : saveAgentSession(session);
 }
 export function getAgentSessionRepoBranch(cwd) {
-    const workingDir = cwd?.trim() || process.cwd();
+    const workingDir = cwd?.trim() || getRuntimeWorkingDirectory();
     return getGitCurrentBranch(workingDir);
 }
 export function agentSessionCredentials(agentSession) {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    const runtime = requireValidWorkerBearerRuntime();
+    if (runtime.mode === "worker" || runtime.mode === "supervised") {
         return {};
     }
     return {

package/dist/mcp/server/runtime/api.js

@@ -1,10 +1,38 @@
 import { clearAuthenticatedAccountCache } from "./auth-cache.js";
+import { getDaemonToolExecutionContext } from "./daemon-tool-context.js";
 import { requireValidWorkerBearerRuntime } from "./worker-bearer.js";
+import { borrowCurrentSupervisedWorkerCredential, } from "./supervisor-bridge.js";
 let ownerAuthStoreLoader = () => import("../../local-state.js");
+let supervisedCredentialBorrower = () => borrowCurrentSupervisedWorkerCredential();
 export function setOwnerAuthStoreLoaderForTest(loader) {
     ownerAuthStoreLoader = loader ?? (() => import("../../local-state.js"));
 }
+export function setSupervisedCredentialBorrowerForTest(borrower) {
+    supervisedCredentialBorrower = borrower ?? (() => borrowCurrentSupervisedWorkerCredential());
+}
+export class SupervisedWorkerCredentialError extends Error {
+    code;
+    constructor(code) {
+        super(code === "SUPERVISED_CREDENTIAL_UNAVAILABLE"
+            ? "The daemon-supervised worker credential is not available yet."
+            : "The daemon-supervised worker credential is stale or missing its exact context.");
+        this.code = code;
+        this.name = "SupervisedWorkerCredentialError";
+    }
+}
+async function getSupervisedCredential() {
+    const daemonContext = getDaemonToolExecutionContext();
+    if (daemonContext)
+        return daemonContext.bearer;
+    const result = await supervisedCredentialBorrower();
+    if (result.state === "available")
+        return result.credential;
+    throw new SupervisedWorkerCredentialError(result.state === "deferred" ? "SUPERVISED_CREDENTIAL_UNAVAILABLE" : "SUPERVISED_CREDENTIAL_STALE");
+}
 export const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
+export function getApiUrl() {
+    return getDaemonToolExecutionContext()?.apiUrl.replace(/\/+$/, "") ?? API_URL;
+}
 export class ApiError extends Error {
     status;
     body;
@@ -20,6 +48,8 @@ export async function getLetagentsToken() {
     if (runtime.mode === "worker") {
         return runtime.bearer;
     }
+    if (runtime.mode === "supervised")
+        return getSupervisedCredential();
     const envToken = process.env.LETAGENTS_TOKEN?.trim();
     if (envToken) {
         return envToken;
@@ -53,8 +83,9 @@ export function resolveApiPath(urlOrPath) {
         return "/auth/device/start";
     }
     try {
-        const parsed = new URL(urlOrPath, `${API_URL}/`);
-        const apiBase = new URL(`${API_URL}/`);
+        const apiUrl = getApiUrl();
+        const parsed = new URL(urlOrPath, `${apiUrl}/`);
+        const apiBase = new URL(`${apiUrl}/`);
         if (parsed.origin !== apiBase.origin) {
             return "/auth/device/start";
         }
@@ -75,19 +106,24 @@ export async function apiCall(path, options) {
         // every caller spelling of Authorization is overwritten.
         headers.set("Authorization", `Bearer ${runtime.bearer}`);
     }
+    else if (runtime.mode === "supervised") {
+        // Resolve on every API request: the daemon may rotate the in-memory
+        // credential while Codex remains running.
+        headers.set("Authorization", `Bearer ${await getSupervisedCredential()}`);
+    }
     else {
         const authorizationHeader = await getAuthorizationHeader();
         if (authorizationHeader && !headers.has("Authorization")) {
             headers.set("Authorization", authorizationHeader);
         }
     }
-    const res = await fetch(`${API_URL}${path}`, {
+    const res = await fetch(`${getApiUrl()}${path}`, {
         ...options,
         headers,
     });
     if (!res.ok) {
         const body = await res.text();
-        if (res.status === 401 && requireValidWorkerBearerRuntime().mode !== "worker") {
+        if (res.status === 401 && requireValidWorkerBearerRuntime().mode === "owner") {
             // Only clear on 401 (invalid/expired credential), NOT on 403
             // (valid credential but insufficient permissions, e.g., private repo access)
             const { clearStoredAuth } = await ownerAuthStoreLoader();

package/dist/mcp/server/runtime/daemon-tool-context.js

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const daemonToolContext = new AsyncLocalStorage();
+export function getDaemonToolExecutionContext() {
+    return daemonToolContext.getStore() ?? null;
+}
+export function runWithDaemonToolExecutionContext(context, callback) {
+    return daemonToolContext.run(context, callback);
+}
+export function getRuntimeWorkingDirectory() {
+    return getDaemonToolExecutionContext()?.cwd ?? process.cwd();
+}

package/dist/mcp/server/runtime/execution-profile.js

@@ -0,0 +1,19 @@
+export const EXECUTION_PROFILES = [
+    "supervised_room_turn",
+    "autonomous_mcp_worker",
+    "interactive_desktop",
+];
+export const LETAGENTS_EXECUTION_PROFILE_ENV = "LETAGENTS_EXECUTION_PROFILE";
+export const LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV = "LETAGENTS_SUPERVISED_BOUNDED_TURNS";
+export function executionProfile(env = process.env) {
+    const configured = env[LETAGENTS_EXECUTION_PROFILE_ENV]?.trim();
+    const bounded = env[LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV]?.trim() === "1";
+    if (configured && !EXECUTION_PROFILES.includes(configured)) {
+        throw new Error(`Invalid ${LETAGENTS_EXECUTION_PROFILE_ENV}: ${configured}`);
+    }
+    const profile = (configured || "autonomous_mcp_worker");
+    if (bounded !== (profile === "supervised_room_turn")) {
+        throw new Error(`${LETAGENTS_EXECUTION_PROFILE_ENV}=supervised_room_turn and ${LETAGENTS_SUPERVISED_BOUNDED_TURNS_ENV}=1 must be configured together.`);
+    }
+    return profile;
+}

package/dist/mcp/server/runtime/identity/directory.js

@@ -5,7 +5,7 @@ import { requireValidWorkerBearerRuntime } from "../worker-bearer.js";
 import { getAuthenticatedAccountCache, setAuthenticatedAccountCache, } from "../auth-cache.js";
 import { AGENT_OWNER_LABEL, readCommandOutput, } from "./config.js";
 export async function getAuthenticatedAgentDirectory() {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    if (requireValidWorkerBearerRuntime().mode !== "owner") {
         return null;
     }
     try {
@@ -25,7 +25,7 @@ export async function getAuthenticatedAgentDirectory() {
     }
 }
 async function getAuthenticatedAccountProfile() {
-    if (requireValidWorkerBearerRuntime().mode === "worker") {
+    if (requireValidWorkerBearerRuntime().mode !== "owner") {
         return null;
     }
     const envToken = (process.env.LETAGENTS_TOKEN || "").trim();

package/dist/mcp/server/runtime/messages.js

@@ -151,6 +151,61 @@ export function toAgentReadableMessages(messages, contextMessages = []) {
     const summaries = buildThreadSummaries(records, recordsById);
     return (messages ?? []).map((message) => toAgentReadableMessage(message, recordsById, summaries));
 }
+export const AGENT_MESSAGE_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
+export const AGENT_MESSAGE_BODY_MAX_BYTES = AGENT_MESSAGE_OUTPUT_MAX_BYTES / 2;
+function jsonUtf8Bytes(value) {
+    const serialized = JSON.stringify(value);
+    return Buffer.byteLength(serialized === undefined ? "null" : serialized, "utf8");
+}
+function compactOversizedAgentMessage(message) {
+    if (!isRecord(message)) {
+        return { content_truncated: true, value_type: typeof message };
+    }
+    const text = typeof message.text === "string" ? message.text : "";
+    return {
+        ...(typeof message.id === "string" ? { id: message.id } : {}),
+        ...(typeof message.sender === "string" ? { sender: message.sender } : {}),
+        ...(typeof message.source === "string" ? { source: message.source } : {}),
+        ...(typeof message.timestamp === "string" ? { timestamp: message.timestamp } : {}),
+        ...(typeof message.thread_root_id === "string"
+            ? { thread_root_id: message.thread_root_id }
+            : {}),
+        ...(typeof message.thread_reply_to_id === "string"
+            ? { thread_reply_to_id: message.thread_reply_to_id }
+            : {}),
+        text: text.slice(0, 16 * 1024),
+        content_truncated: true,
+        original_utf8_bytes: jsonUtf8Bytes(message),
+    };
+}
+export function boundAgentMessageOutput(messages, options = {}) {
+    const direction = options.direction ?? "prefix";
+    const maxBytes = Math.max(1024, Math.floor(options.maxBytes ?? AGENT_MESSAGE_OUTPUT_MAX_BYTES));
+    const ordered = direction === "suffix" ? [...messages].reverse() : [...messages];
+    const selected = [];
+    let outputBytes = 2; // JSON array brackets.
+    for (const message of ordered) {
+        let candidate = message;
+        let candidateBytes = jsonUtf8Bytes(candidate);
+        if (candidateBytes + 2 > maxBytes) {
+            candidate = compactOversizedAgentMessage(candidate);
+            candidateBytes = jsonUtf8Bytes(candidate);
+        }
+        const separatorBytes = selected.length > 0 ? 1 : 0;
+        if (outputBytes + separatorBytes + candidateBytes > maxBytes)
+            break;
+        selected.push(candidate);
+        outputBytes += separatorBytes + candidateBytes;
+    }
+    if (direction === "suffix")
+        selected.reverse();
+    return {
+        messages: selected,
+        truncated: selected.length < messages.length,
+        omittedMessageCount: messages.length - selected.length,
+        outputBytes,
+    };
+}
 export function appendIncludePromptOnly(path) {
     return `${path}${path.includes("?") ? "&" : "?"}include_prompt_only=1`;
 }

package/dist/mcp/server/runtime/presence.js

@@ -4,6 +4,7 @@ import { isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, touchRoo
 import { apiCall, isMissingRouteError } from "./api.js";
 import { agentSessionCredentials, identityFromAgentSession } from "./agent-sessions.js";
 import { getSessionLivenessRegistration } from "./identity.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
 const roomPresenceByIdentity = new Map();
 export function getRememberedRoomPresence(roomId, identity) {
     if (!roomId || !identity) {
@@ -18,7 +19,7 @@ export async function syncRoomPresence(roomId, identity, presence, agentSession)
     }
     roomPresenceByIdentity.set(getRoomIdentityPresenceCacheKey(roomId, resolvedIdentity.actor_label), presence);
     const { localRoomId, cloudRoomId } = await resolveLocalRoomStorageIdentifiers(roomId);
-    if (await isLocalRoomStorageEnabled(roomId)) {
+    if (!isSupervisedBoundedTurn() && await isLocalRoomStorageEnabled(roomId)) {
         touchRoomSession(localRoomId || roomId);
         return;
     }
@@ -38,7 +39,8 @@ export async function syncRoomPresence(roomId, identity, presence, agentSession)
                 ...agentSessionCredentials(agentSession),
             }),
         });
-        touchRoomSession(apiRoomId);
+        if (!isSupervisedBoundedTurn())
+            touchRoomSession(apiRoomId);
     }
     catch (error) {
         if (isMissingRouteError(error)) {

package/dist/mcp/server/runtime/room-api.js

@@ -3,13 +3,24 @@ import { LETAGENTS_ORIGIN_ROOM_ID_HEADER } from "../../../shared/request-headers
 import { apiCall, isMissingRouteError, } from "./api.js";
 import { maybeHandleRepoRoomAuthRequired } from "./device-auth.js";
 import { getLastMessageId } from "./messages.js";
-import { currentRoom } from "./room-state.js";
+import { currentRoom, getCurrentSupervisedRoomAuthority } from "./room-state.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
 export async function roomScopedApiCall(input) {
+    const supervised = isSupervisedBoundedTurn();
+    const exactRoomAuthority = supervised ? getCurrentSupervisedRoomAuthority() : null;
+    if (supervised && (!exactRoomAuthority || input.room_id !== exactRoomAuthority)) {
+        throw new Error("The daemon-supervised API request is missing its exact per-call room authority.");
+    }
     const headers = {
         ...input.options?.headers,
     };
-    if (currentRoom?.room_id &&
-        !Object.keys(headers).some((key) => key.toLowerCase() === LETAGENTS_ORIGIN_ROOM_ID_HEADER.toLowerCase())) {
+    const originHeaderKey = Object.keys(headers).find((key) => key.toLowerCase() === LETAGENTS_ORIGIN_ROOM_ID_HEADER.toLowerCase());
+    if (exactRoomAuthority) {
+        if (originHeaderKey)
+            delete headers[originHeaderKey];
+        headers[LETAGENTS_ORIGIN_ROOM_ID_HEADER] = exactRoomAuthority;
+    }
+    else if (currentRoom?.room_id && !originHeaderKey) {
         headers[LETAGENTS_ORIGIN_ROOM_ID_HEADER] = currentRoom.room_id;
     }
     const options = {
@@ -17,16 +28,20 @@ export async function roomScopedApiCall(input) {
         headers,
     };
     if (input.room_id) {
-        const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(input.room_id);
+        const cloudRoomId = supervised
+            ? null
+            : (await resolveLocalRoomStorageIdentifiers(input.room_id)).cloudRoomId;
         const apiRoomId = cloudRoomId || input.room_id;
         try {
             const result = await apiCall(input.room_path(apiRoomId), options);
-            touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+            if (!supervised) {
+                touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+            }
             return result;
         }
         catch (error) {
             await maybeHandleRepoRoomAuthRequired(error, apiRoomId);
-            if (!input.project_id || !isMissingRouteError(error)) {
+            if (supervised || !input.project_id || !isMissingRouteError(error)) {
                 throw error;
             }
         }
@@ -36,7 +51,9 @@ export async function roomScopedApiCall(input) {
     }
     const result = await apiCall(input.project_path(input.project_id), options);
     if (input.room_id) {
-        touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+        if (!supervised) {
+            touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+        }
     }
     return result;
 }

package/dist/mcp/server/runtime/room-state.js

@@ -1,8 +1,10 @@
 import { SseClient } from "../../sse-client.js";
 import { getStoredAgentIdentity, saveRoomSession, touchRoomSession, } from "../../local-state.js";
 import { getCanonicalRoomWebPath, } from "../../room-id.js";
-import { API_URL, getLetagentsToken } from "./api.js";
+import { getApiUrl, getLetagentsToken } from "./api.js";
 import { AGENT_INSTANCE_UUID, currentAgentIdentity, currentAgentIdentityKey, } from "./identity.js";
+import { isSupervisedBoundedTurn } from "./worker-bearer.js";
+import { getCurrentSupervisedRoomAuthority, runWithSupervisedRoomAuthority, } from "./supervised-room-authority.js";
 let mcpServer = null;
 let sseClient = null;
 export let currentRoom = null;
@@ -13,7 +15,7 @@ export function shutdownRuntime() {
     sseClient?.unsubscribeAll();
 }
 function getSseClient() {
-    sseClient ??= new SseClient(API_URL, () => getLetagentsToken());
+    sseClient ??= new SseClient(getApiUrl(), () => getLetagentsToken());
     return sseClient;
 }
 function getCurrentStreamAgentIdentity() {
@@ -30,6 +32,7 @@ function getCurrentStreamAgentIdentity() {
 export function toRoomState(input) {
     return {
         room_id: input.room_id,
+        navigation_locator: input.navigation_locator ?? null,
         project_id: input.project_id ?? null,
         code: input.code ?? null,
         display_name: input.display_name ?? null,
@@ -38,8 +41,12 @@ export function toRoomState(input) {
         is_local: input.is_local ?? false,
     };
 }
+export function currentRoomMatchesLocator(locator) {
+    const value = locator?.trim();
+    return Boolean(value && currentRoom && (currentRoom.room_id === value || currentRoom.navigation_locator === value));
+}
 function getCanonicalRoomWebUrl(roomId) {
-    return new URL(getCanonicalRoomWebPath(roomId), `${API_URL}/`).toString();
+    return new URL(getCanonicalRoomWebPath(roomId), `${getApiUrl()}/`).toString();
 }
 export function withCanonicalRoomLink(roomId, payload) {
     return {
@@ -85,6 +92,8 @@ export function toPublicRoomResponse(response, fallbackRoomId) {
 }
 export function rememberRoom(state, lastMessageId) {
     currentRoom = state;
+    if (isSupervisedBoundedTurn())
+        return state;
     saveRoomSession({
         room_id: state.room_id,
         project_id: state.project_id ?? null,
@@ -105,18 +114,65 @@ export function rememberRoom(state, lastMessageId) {
     }, (_message) => {
         touchRoomSession(state.room_id);
         mcpServer?.server.sendResourceListChanged();
+    }, () => {
+        // The SSE cursor crossed a broker/bridge loss boundary. MCP resources
+        // are pull-based, so invalidating the list is the full-state repair.
+        touchRoomSession(state.room_id);
+        mcpServer?.server.sendResourceListChanged();
     });
     return state;
 }
 export function touchCurrentRoom(lastMessageId) {
+    if (isSupervisedBoundedTurn())
+        return;
     if (!currentRoom) {
         return;
     }
     touchRoomSession(currentRoom.room_id, lastMessageId);
 }
 export function getTargetRoomId(roomId) {
+    if (isSupervisedBoundedTurn()) {
+        const exactRoomAuthority = getCurrentSupervisedRoomAuthority();
+        if (!exactRoomAuthority) {
+            throw new Error("The daemon-supervised tool has not received its exact room authority.");
+        }
+        if (roomId && roomId !== exactRoomAuthority) {
+            throw new Error(`The daemon-supervised tool is authorized for ${exactRoomAuthority}, not ${roomId}.`);
+        }
+        return exactRoomAuthority;
+    }
     return roomId || currentRoom?.room_id || null;
 }
+/** The last room authority returned by this process's exact daemon effect. */
+export { getCurrentSupervisedRoomAuthority } from "./supervised-room-authority.js";
+/** Public room metadata without inventing join provenance or locality. */
+export function toPublicCurrentRoomState() {
+    const exactRoomAuthority = getCurrentSupervisedRoomAuthority();
+    if (!exactRoomAuthority)
+        return toPublicRoomState(currentRoom);
+    return {
+        ...toPublicRoomState(toRoomState({ room_id: exactRoomAuthority, joined_via: "join_room" })),
+        joined_via: null,
+        is_local: null,
+    };
+}
+/**
+ * Bind only the in-memory default used by one supervised MCP process. The
+ * daemon response is the authority; this performs no join, storage, SSE, or
+ * repository inspection and can safely rebind after a durable room move.
+ */
+export function runWithCurrentSupervisedRoom(roomId, callback) {
+    if (!isSupervisedBoundedTurn()) {
+        throw new Error("Only a daemon-supervised bounded turn can bind supervisor room authority.");
+    }
+    const normalized = roomId.trim();
+    if (!normalized || normalized.length > 1_024 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+        throw new Error("The daemon-supervised room authority is malformed.");
+    }
+    return runWithSupervisedRoomAuthority(normalized, callback);
+}
 export function getFallbackProjectId() {
+    if (isSupervisedBoundedTurn())
+        return null;
     return currentRoom?.project_id ?? null;
 }