letagents 0.8.1 → 0.10.0

package/dist/mcp/server.js

@@ -2,25 +2,593 @@
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { createHash } from "crypto";
 import { writeFileSync, existsSync } from "fs";
+import { userInfo } from "os";
 import { join, dirname } from "path";
 import { execSync } from "child_process";
 import { SseClient } from "./sse-client.js";
 import { getRoomFromConfig } from "./config-reader.js";
 import { getGitRemoteIdentity } from "./git-remote.js";
-import { clearPendingDeviceAuth, clearStoredAuth, getLocalStatePath, getPendingDeviceAuth, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setPendingDeviceAuth, setStoredAuth, touchRoomSession, } from "./local-state.js";
-import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
+import { clearPendingDeviceAuth, clearStoredAuth, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setStoredAgentIdentity, setPendingDeviceAuth, setStoredAuth, touchRoomSession, updateLocalState, } from "./local-state.js";
+import { encodeRoomIdPath, getCanonicalRoomWebPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
+import { buildAgentActorLabel, formatOwnerAttribution, inferAgentIdeLabel, toTitleCaseCodename, } from "../shared/agent-identity.js";
 let currentRoom = null;
+let currentAgentIdentityKey = "";
+let currentAgentIdentity = null;
+let currentAuthenticatedAccount = undefined;
+let currentAuthenticatedAccountSource = null;
+let currentAuthenticatedEnvToken = null;
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
 const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME || process.env.AGENT_NAME || "").trim();
 const AGENT_DISPLAY_NAME = (process.env.LETAGENTS_AGENT_DISPLAY_NAME || "").trim();
+const AGENT_IDE_LABEL = (process.env.LETAGENTS_AGENT_IDE || process.env.AGENT_IDE || "").trim();
 const AGENT_OWNER_LABEL = (process.env.LETAGENTS_AGENT_OWNER_LABEL || "").trim();
+const EXPLICIT_AGENT_IDENTITY_KEY = getExplicitAgentIdentityStorageKey();
+currentAgentIdentityKey =
+    EXPLICIT_AGENT_IDENTITY_KEY ?? getFallbackAgentIdentityNamespaceKey(detectAgentIdeLabel());
+currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+function readCommandOutput(command, cwd = process.cwd()) {
+    try {
+        const output = execSync(command, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSlugSegment(input, fallback) {
+    const normalized = input
+        .normalize("NFKD")
+        .replace(/[^\x00-\x7F]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+    return normalized || fallback;
+}
+function normalizeAgentBaseName(input) {
+    return normalizeSlugSegment(input, "agent").replace(/-agent$/, "") || "agent";
+}
+function isCodexRuntime() {
+    return Boolean(process.env.CODEX_THREAD_ID ||
+        process.env.CODEX_SHELL ||
+        process.env.CODEX_CI ||
+        process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE);
+}
+const AGENT_CODENAMES = [
+    "amber",
+    "anchor",
+    "autumn",
+    "badger",
+    "bay",
+    "bear",
+    "brook",
+    "calm",
+    "canyon",
+    "cedar",
+    "clear",
+    "cloud",
+    "comet",
+    "copper",
+    "creek",
+    "crisp",
+    "crest",
+    "dawn",
+    "delta",
+    "dune",
+    "ember",
+    "falcon",
+    "fern",
+    "field",
+    "firefly",
+    "fjord",
+    "forest",
+    "fox",
+    "garden",
+    "glade",
+    "golden",
+    "granite",
+    "grove",
+    "harbor",
+    "hawk",
+    "hollow",
+    "indigo",
+    "ivory",
+    "jade",
+    "juniper",
+    "lagoon",
+    "lake",
+    "lantern",
+    "leaf",
+    "lively",
+    "lunar",
+    "lynx",
+    "maple",
+    "marsh",
+    "meadow",
+    "mesa",
+    "misty",
+    "moon",
+    "morrow",
+    "moss",
+    "noble",
+    "oak",
+    "olive",
+    "opal",
+    "otter",
+    "owl",
+    "peak",
+    "pearl",
+    "pine",
+    "quiet",
+    "raven",
+    "reef",
+    "ridge",
+    "river",
+    "rook",
+    "sage",
+    "scarlet",
+    "shore",
+    "silver",
+    "sky",
+    "solar",
+    "sparrow",
+    "spring",
+    "star",
+    "stone",
+    "storm",
+    "summit",
+    "sun",
+    "sunlit",
+    "swift",
+    "thicket",
+    "tidal",
+    "timber",
+    "trail",
+    "valley",
+    "verdant",
+    "vista",
+    "warm",
+    "wave",
+    "west",
+    "wild",
+    "willow",
+    "wind",
+    "winter",
+    "wolf",
+    "wood",
+    "wren",
+];
+const AGENT_CODENAME_SPACE = AGENT_CODENAMES.length * AGENT_CODENAMES.length;
+const AGENT_IDENTITY_SLOT_SUFFIX = ":slot:";
+function getExplicitAgentIdentityStorageKey() {
+    const runtimeSignals = [
+        process.env.LETAGENTS_AGENT_INSTANCE_ID,
+        process.env.CODEX_THREAD_ID && `codex:${process.env.CODEX_THREAD_ID}`,
+        process.env.ANTIGRAVITY_THREAD_ID && `antigravity:${process.env.ANTIGRAVITY_THREAD_ID}`,
+        process.env.CLAUDECODE_SESSION_ID && `claude:${process.env.CLAUDECODE_SESSION_ID}`,
+        process.env.MCP_SESSION_ID && `mcp:${process.env.MCP_SESSION_ID}`,
+    ].filter((value) => Boolean(value?.trim()));
+    if (runtimeSignals.length) {
+        return runtimeSignals[0];
+    }
+    return null;
+}
+function getFallbackAgentIdentityNamespaceKey(ideLabel) {
+    return `cwd:${process.cwd()}:ide:${normalizeAgentBaseName(ideLabel)}`;
+}
+function hashStringToIndex(value, modulo) {
+    const digest = createHash("sha256").update(value).digest();
+    return digest.readUInt16BE(0) % modulo;
+}
+function codenameFromIndex(index) {
+    const normalizedIndex = ((index % AGENT_CODENAME_SPACE) + AGENT_CODENAME_SPACE) % AGENT_CODENAME_SPACE;
+    const firstIndex = Math.floor(normalizedIndex / AGENT_CODENAMES.length);
+    const secondIndex = normalizedIndex % AGENT_CODENAMES.length;
+    const first = AGENT_CODENAMES[firstIndex];
+    const second = AGENT_CODENAMES[secondIndex];
+    return {
+        name: normalizeAgentBaseName(`${first}-${second}`),
+        display_name: `${toTitleCaseCodename(first)} ${toTitleCaseCodename(second)}`,
+    };
+}
+function detectAgentIdeLabel() {
+    if (AGENT_IDE_LABEL) {
+        return toTitleCaseCodename(AGENT_IDE_LABEL);
+    }
+    if (isCodexRuntime()) {
+        return "Codex";
+    }
+    const explicitName = normalizeAgentBaseName(AGENT_NAME || AGENT_DISPLAY_NAME);
+    const inferred = inferAgentIdeLabel(explicitName);
+    return inferred || "Agent";
+}
+function getFallbackSlotPrefix(namespaceKey) {
+    return `${namespaceKey}${AGENT_IDENTITY_SLOT_SUFFIX}`;
+}
+function getFallbackSlotKey(namespaceKey, slotIndex) {
+    return `${getFallbackSlotPrefix(namespaceKey)}${slotIndex}`;
+}
+function parseFallbackSlotIndex(identityKey, namespaceKey) {
+    const prefix = getFallbackSlotPrefix(namespaceKey);
+    if (!identityKey.startsWith(prefix)) {
+        return null;
+    }
+    const slotIndex = Number.parseInt(identityKey.slice(prefix.length), 10);
+    return Number.isInteger(slotIndex) && slotIndex >= 0 ? slotIndex : null;
+}
+function isProcessAlive(pid) {
+    if (!pid || !Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        return err.code === "EPERM";
+    }
+}
+function claimFallbackIdentityKey(namespaceKey) {
+    let claimedKey = getFallbackSlotKey(namespaceKey, 0);
+    let claimedIdentity = null;
+    const now = new Date().toISOString();
+    updateLocalState((state) => {
+        const identities = state.agent_identities ?? {};
+        const leases = state.agent_identity_leases ?? {};
+        const namespacePrefix = getFallbackSlotPrefix(namespaceKey);
+        for (const [identityKey, lease] of Object.entries(leases)) {
+            if (!identityKey.startsWith(namespacePrefix) || lease.namespace_key !== namespaceKey) {
+                continue;
+            }
+            if (!isProcessAlive(lease.pid)) {
+                delete leases[identityKey];
+            }
+        }
+        const activeLeaseForPid = Object.entries(leases).find(([identityKey, lease]) => identityKey.startsWith(namespacePrefix) &&
+            lease.namespace_key === namespaceKey &&
+            lease.pid === process.pid);
+        if (activeLeaseForPid) {
+            const [identityKey, lease] = activeLeaseForPid;
+            lease.updated_at = now;
+            claimedKey = identityKey;
+            claimedIdentity = identities[identityKey] ?? null;
+            state.agent_identity_leases = leases;
+            return state;
+        }
+        const slotKeys = new Set();
+        for (const identityKey of Object.keys(identities)) {
+            if (identityKey.startsWith(namespacePrefix)) {
+                slotKeys.add(identityKey);
+            }
+        }
+        for (const identityKey of Object.keys(leases)) {
+            if (identityKey.startsWith(namespacePrefix)) {
+                slotKeys.add(identityKey);
+            }
+        }
+        const sortedSlotKeys = [...slotKeys].sort((left, right) => {
+            const leftIndex = parseFallbackSlotIndex(left, namespaceKey) ?? Number.MAX_SAFE_INTEGER;
+            const rightIndex = parseFallbackSlotIndex(right, namespaceKey) ?? Number.MAX_SAFE_INTEGER;
+            return leftIndex - rightIndex;
+        });
+        for (const identityKey of sortedSlotKeys) {
+            if (leases[identityKey]) {
+                continue;
+            }
+            leases[identityKey] = {
+                namespace_key: namespaceKey,
+                pid: process.pid,
+                acquired_at: now,
+                updated_at: now,
+            };
+            claimedKey = identityKey;
+            claimedIdentity = identities[identityKey] ?? null;
+            state.agent_identity_leases = leases;
+            return state;
+        }
+        let nextSlotIndex = 0;
+        while (slotKeys.has(getFallbackSlotKey(namespaceKey, nextSlotIndex))) {
+            nextSlotIndex += 1;
+        }
+        claimedKey = getFallbackSlotKey(namespaceKey, nextSlotIndex);
+        leases[claimedKey] = {
+            namespace_key: namespaceKey,
+            pid: process.pid,
+            acquired_at: now,
+            updated_at: now,
+        };
+        claimedIdentity = identities[claimedKey] ?? null;
+        state.agent_identity_leases = leases;
+        return state;
+    });
+    return {
+        identityKey: claimedKey,
+        identity: claimedIdentity,
+    };
+}
+function ensureAgentIdentityKey(ideLabel) {
+    if (EXPLICIT_AGENT_IDENTITY_KEY) {
+        currentAgentIdentityKey = EXPLICIT_AGENT_IDENTITY_KEY;
+        currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
+        return currentAgentIdentityKey;
+    }
+    const claimed = claimFallbackIdentityKey(getFallbackAgentIdentityNamespaceKey(ideLabel));
+    currentAgentIdentityKey = claimed.identityKey;
+    currentAgentIdentity = claimed.identity;
+    return currentAgentIdentityKey;
+}
+async function getAuthenticatedAgentDirectory() {
+    try {
+        const result = await apiCall("/agents/me");
+        const account = result?.account;
+        if (!account?.login?.trim()) {
+            return null;
+        }
+        currentAuthenticatedAccount = account;
+        currentAuthenticatedAccountSource = process.env.LETAGENTS_TOKEN?.trim() ? "env" : "stored";
+        currentAuthenticatedEnvToken = process.env.LETAGENTS_TOKEN?.trim() || null;
+        return {
+            account,
+            agents: Array.isArray(result?.agents) ? result.agents : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function shouldReuseStoredIdentity(identity, identityKey) {
+    return Boolean(identity &&
+        identity.runtime_key === identityKey &&
+        identity.display_name?.trim() &&
+        identity.ide_label?.trim() &&
+        identity.owner_attribution?.trim());
+}
+function resolveExplicitAgentIdentity() {
+    if (AGENT_NAME) {
+        const name = normalizeAgentBaseName(AGENT_NAME);
+        return {
+            name,
+            display_name: AGENT_DISPLAY_NAME || toTitleCaseCodename(AGENT_NAME),
+        };
+    }
+    if (AGENT_DISPLAY_NAME) {
+        return {
+            name: normalizeAgentBaseName(AGENT_DISPLAY_NAME),
+            display_name: AGENT_DISPLAY_NAME.trim(),
+        };
+    }
+    return null;
+}
+function pickLocalCodename(runtimeKey, offset = 0) {
+    const index = hashStringToIndex(runtimeKey, AGENT_CODENAME_SPACE) + offset;
+    return codenameFromIndex(index);
+}
+async function resolveAgentName(authAvailable, identityKey) {
+    const explicit = resolveExplicitAgentIdentity();
+    if (explicit) {
+        return explicit;
+    }
+    if (shouldReuseStoredIdentity(currentAgentIdentity, identityKey)) {
+        return {
+            name: currentAgentIdentity.name,
+            display_name: currentAgentIdentity.display_name,
+        };
+    }
+    if (!authAvailable) {
+        return pickLocalCodename(identityKey);
+    }
+    const directory = await getAuthenticatedAgentDirectory();
+    const existingNames = new Set((directory?.agents ?? [])
+        .map((agent) => normalizeAgentBaseName(agent.name || ""))
+        .filter(Boolean));
+    for (let offset = 0; offset < AGENT_CODENAME_SPACE; offset += 1) {
+        const candidate = pickLocalCodename(identityKey, offset);
+        if (!existingNames.has(candidate.name)) {
+            return candidate;
+        }
+    }
+    const fallbackHash = createHash("sha256")
+        .update(identityKey)
+        .digest("hex")
+        .slice(0, 4);
+    const fallback = pickLocalCodename(identityKey);
+    return {
+        name: `${fallback.name}-${fallbackHash}`,
+        display_name: `${fallback.display_name} ${fallbackHash.toUpperCase()}`,
+    };
+}
+async function getAuthenticatedAccountProfile() {
+    const envToken = (process.env.LETAGENTS_TOKEN || "").trim();
+    if (envToken) {
+        if (currentAuthenticatedAccountSource === "env" &&
+            currentAuthenticatedEnvToken === envToken &&
+            currentAuthenticatedAccount?.login?.trim()) {
+            return currentAuthenticatedAccount;
+        }
+        const directory = await getAuthenticatedAgentDirectory();
+        if (directory?.account?.login?.trim()) {
+            return directory.account;
+        }
+        return null;
+    }
+    const storedAccount = getStoredAuth()?.account;
+    if (storedAccount?.login?.trim()) {
+        currentAuthenticatedAccount = storedAccount;
+        currentAuthenticatedAccountSource = "stored";
+        currentAuthenticatedEnvToken = null;
+        return storedAccount;
+    }
+    if (!getLetagentsToken()) {
+        currentAuthenticatedAccount = undefined;
+        currentAuthenticatedAccountSource = null;
+        currentAuthenticatedEnvToken = null;
+        return null;
+    }
+    if (currentAuthenticatedAccountSource === "stored" &&
+        currentAuthenticatedAccount?.login?.trim()) {
+        return currentAuthenticatedAccount;
+    }
+    const directory = await getAuthenticatedAgentDirectory();
+    if (directory?.account?.login?.trim()) {
+        return directory.account;
+    }
+    return null;
+}
+async function resolveOwnerContext() {
+    const account = await getAuthenticatedAccountProfile();
+    const authLogin = account?.login?.trim() || null;
+    const authLabel = account?.display_name?.trim() || authLogin;
+    if (authLogin || authLabel || AGENT_OWNER_LABEL) {
+        const label = AGENT_OWNER_LABEL || authLabel || authLogin || "Owner";
+        const slug = normalizeSlugSegment(authLogin || label, "owner");
+        return { slug, label, login: authLogin };
+    }
+    const gitUserName = readCommandOutput("git config --get user.name");
+    const gitUserEmail = readCommandOutput("git config --get user.email");
+    const gitIdentity = gitUserName || gitUserEmail?.split("@")[0] || null;
+    if (gitIdentity) {
+        return {
+            slug: normalizeSlugSegment(gitIdentity, "owner"),
+            label: gitIdentity,
+            login: null,
+        };
+    }
+    const osIdentity = process.env.USER ||
+        process.env.LOGNAME ||
+        process.env.USERNAME ||
+        (() => {
+            try {
+                return userInfo().username;
+            }
+            catch {
+                return null;
+            }
+        })() ||
+        "owner";
+    return {
+        slug: normalizeSlugSegment(osIdentity, "owner"),
+        label: osIdentity,
+        login: null,
+    };
+}
+function sameAgentIdentity(left, right) {
+    return Boolean(left &&
+        left.name === right.name &&
+        left.display_name === right.display_name &&
+        left.owner_label === right.owner_label &&
+        left.owner_attribution === right.owner_attribution &&
+        left.ide_label === right.ide_label &&
+        left.actor_label === right.actor_label &&
+        left.canonical_key === right.canonical_key &&
+        left.runtime_key === right.runtime_key &&
+        left.source === right.source);
+}
+function toPublicAgentIdentity(identity) {
+    if (!identity) {
+        return null;
+    }
+    return {
+        name: identity.name,
+        display_name: identity.display_name,
+        owner_label: identity.owner_label,
+        owner_attribution: identity.owner_attribution ?? formatOwnerAttribution(identity.owner_label),
+        ide_label: identity.ide_label ?? inferAgentIdeLabel(identity.display_name) ?? "Agent",
+        actor_label: identity.actor_label,
+        canonical_key: identity.canonical_key ?? null,
+        runtime_key: identity.runtime_key ?? null,
+        source: identity.source,
+    };
+}
+async function ensureAgentIdentity() {
+    const owner = await resolveOwnerContext();
+    const authAvailable = Boolean(getLetagentsToken());
+    const ideLabel = detectAgentIdeLabel();
+    const identityKey = ensureAgentIdentityKey(ideLabel);
+    const ownerAttribution = formatOwnerAttribution(owner.label);
+    const { name, display_name: displayName } = await resolveAgentName(authAvailable, identityKey);
+    const actorLabel = buildAgentActorLabel({
+        display_name: displayName,
+        owner_label: owner.label,
+        ide_label: ideLabel,
+    });
+    let resolved = {
+        name,
+        display_name: displayName,
+        owner_label: owner.label,
+        owner_attribution: ownerAttribution,
+        ide_label: ideLabel,
+        actor_label: actorLabel,
+        canonical_key: owner.login ? `${owner.login}/${name}` : null,
+        runtime_key: identityKey,
+        source: "local",
+        resolved_at: new Date().toISOString(),
+    };
+    if (currentAgentIdentity &&
+        currentAgentIdentity.name === resolved.name &&
+        currentAgentIdentity.display_name === resolved.display_name &&
+        currentAgentIdentity.owner_label === resolved.owner_label &&
+        currentAgentIdentity.owner_attribution === resolved.owner_attribution &&
+        currentAgentIdentity.ide_label === resolved.ide_label &&
+        currentAgentIdentity.actor_label === resolved.actor_label &&
+        currentAgentIdentity.runtime_key === resolved.runtime_key &&
+        (!authAvailable || currentAgentIdentity.source === "api")) {
+        return currentAgentIdentity;
+    }
+    if (authAvailable) {
+        try {
+            const registered = await apiCall("/agents", {
+                method: "POST",
+                body: JSON.stringify({
+                    name: resolved.name,
+                    display_name: resolved.display_name,
+                    owner_label: resolved.owner_label,
+                }),
+            });
+            resolved = {
+                ...resolved,
+                canonical_key: typeof registered.canonical_key === "string"
+                    ? registered.canonical_key
+                    : resolved.canonical_key,
+                display_name: typeof registered.display_name === "string"
+                    ? registered.display_name
+                    : resolved.display_name,
+                owner_label: typeof registered.owner_label === "string"
+                    ? registered.owner_label
+                    : resolved.owner_label,
+                source: "api",
+            };
+            resolved.owner_attribution = formatOwnerAttribution(resolved.owner_label);
+            resolved.actor_label = buildAgentActorLabel({
+                display_name: resolved.display_name,
+                owner_label: resolved.owner_label,
+                ide_label: resolved.ide_label,
+            });
+        }
+        catch (error) {
+            console.error("Agent identity registration failed:", error instanceof Error ? error.message : error);
+        }
+    }
+    if (!sameAgentIdentity(currentAgentIdentity, resolved)) {
+        currentAgentIdentity = setStoredAgentIdentity({
+            ...resolved,
+            resolved_at: new Date().toISOString(),
+        }, identityKey);
+    }
+    return currentAgentIdentity ?? resolved;
+}
 /**
  * Resolve the root of the git repository containing `dir`.
  * Returns null if `dir` is not inside a git repo.
@@ -136,6 +704,9 @@ async function apiCall(path, options) {
             // Only clear on 401 (invalid/expired credential), NOT on 403
             // (valid credential but insufficient permissions, e.g., private repo access)
             clearStoredAuth();
+            currentAuthenticatedAccount = undefined;
+            currentAuthenticatedAccountSource = null;
+            currentAuthenticatedEnvToken = null;
         }
         throw new ApiError(res.status, body);
     }
@@ -190,22 +761,32 @@ function toRoomState(input) {
         joined_via: input.joined_via,
     };
 }
+function getCanonicalRoomWebUrl(roomId) {
+    return new URL(getCanonicalRoomWebPath(roomId), `${API_URL}/`).toString();
+}
+function withCanonicalRoomLink(roomId, payload) {
+    return {
+        ...payload,
+        room_path: getCanonicalRoomWebPath(roomId),
+        room_url: getCanonicalRoomWebUrl(roomId),
+    };
+}
 function toPublicRoomState(state) {
     if (!state) {
         return null;
     }
-    return {
+    return withCanonicalRoomLink(state.room_id, {
         room_id: state.room_id,
         code: state.code ?? null,
         display_name: state.display_name ?? null,
         joined_via: state.joined_via,
-    };
+    });
 }
 function toPublicStoredRoomSession(session) {
     if (!session) {
         return null;
     }
-    return {
+    return withCanonicalRoomLink(session.room_id, {
         room_id: session.room_id,
         code: session.code ?? null,
         display_name: session.display_name ?? null,
@@ -213,15 +794,21 @@ function toPublicStoredRoomSession(session) {
         joined_at: session.joined_at,
         last_seen_at: session.last_seen_at,
         last_message_id: session.last_message_id ?? null,
-    };
+    });
 }
 function toPublicRoomResponse(response, fallbackRoomId) {
     const { id: _legacyId, project_id: _legacyProjectId, ...rest } = response;
     return {
-        ...rest,
+        ...withCanonicalRoomLink(typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId, rest),
         room_id: typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId,
     };
 }
+async function withAgentIdentity(payload) {
+    return {
+        ...payload,
+        agent_identity: toPublicAgentIdentity(await ensureAgentIdentity()),
+    };
+}
 function rememberRoom(state, lastMessageId) {
     currentRoom = state;
     saveRoomSession({
@@ -303,9 +890,14 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             display_name: typeof response.display_name === "string" ? response.display_name : null,
             joined_via: joinedVia,
         }));
+        const agentIdentity = await ensureAgentIdentity();
         return {
             room,
-            response: { ...response, room_id: joinedRoomId },
+            response: {
+                ...response,
+                room_id: joinedRoomId,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            },
         };
     }
     catch (error) {
@@ -326,12 +918,14 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             display_name: typeof project.display_name === "string" ? project.display_name : null,
             joined_via: joinedVia,
         }));
+        const agentIdentity = await ensureAgentIdentity();
         return {
             room,
             response: {
                 ...project,
                 room_id: legacyRoomId,
                 project_id: typeof project.id === "string" ? project.id : null,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
             },
         };
     }
@@ -352,12 +946,14 @@ async function joinRoomIdentifier(identifier, joinedVia) {
         display_name: typeof project.display_name === "string" ? project.display_name : null,
         joined_via: joinedVia,
     }));
+    const agentIdentity = await ensureAgentIdentity();
     return {
         room,
         response: {
             ...project,
             room_id: legacyRoomId,
             project_id: typeof project.id === "string" ? project.id : null,
+            agent_identity: toPublicAgentIdentity(agentIdentity),
         },
     };
 }
@@ -375,45 +971,28 @@ async function createInviteRoom() {
         display_name: typeof project.display_name === "string" ? project.display_name : null,
         joined_via: "join_code",
     }));
-    await autoRegisterAgentIdentity();
+    const agentIdentity = await ensureAgentIdentity();
     return {
         room,
-        response: toPublicRoomResponse(project, roomId),
+        response: {
+            ...toPublicRoomResponse(project, roomId),
+            agent_identity: toPublicAgentIdentity(agentIdentity),
+        },
     };
 }
 async function joinInviteCode(code) {
     const joined = await joinRoomIdentifier(code, "join_code");
-    await autoRegisterAgentIdentity();
-    return {
+    return withAgentIdentity({
         ...toPublicRoomResponse(joined.response, joined.room.room_id),
         joined_via: "join_code",
-    };
+    });
 }
 async function joinNamedRoom(name) {
     const joined = await joinRoomIdentifier(name, "join_room");
-    await autoRegisterAgentIdentity();
-    return {
+    return withAgentIdentity({
         ...toPublicRoomResponse(joined.response, joined.room.room_id),
         joined_via: "join_room",
-    };
-}
-async function autoRegisterAgentIdentity() {
-    if (!AGENT_NAME || !currentRoom) {
-        return;
-    }
-    try {
-        await apiCall("/agents", {
-            method: "POST",
-            body: JSON.stringify({
-                name: AGENT_NAME,
-                display_name: AGENT_DISPLAY_NAME || AGENT_NAME,
-                owner_label: AGENT_OWNER_LABEL || undefined,
-            }),
-        });
-    }
-    catch (error) {
-        console.error("Agent identity registration failed:", error);
-    }
+    });
 }
 // ---------------------------------------------------------------------------
 // MCP Server
@@ -432,18 +1011,35 @@ server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_i
     const normalizedRoomId = String(room_id);
     const storedSession = getStoredRoomSession(normalizedRoomId) ??
         (currentRoom?.room_id === normalizedRoomId ? getStoredCurrentRoom() : null);
-    const result = await roomScopedApiCall({
-        room_id: normalizedRoomId,
-        project_id: storedSession?.project_id ?? null,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
-        project_path: (projectId) => `/projects/${encodeURIComponent(projectId)}/messages`,
-    });
+    // Paginate through all pages to return full message history
+    const allMessages = [];
+    let afterCursor;
+    for (;;) {
+        const query = new URLSearchParams();
+        if (afterCursor)
+            query.set("after", afterCursor);
+        const qs = query.toString();
+        const result = await roomScopedApiCall({
+            room_id: normalizedRoomId,
+            project_id: storedSession?.project_id ?? null,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`,
+            project_path: (projectId) => `/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`,
+        });
+        const msgs = result.messages ?? [];
+        allMessages.push(...msgs);
+        if (!result.has_more || msgs.length === 0)
+            break;
+        const lastMsg = msgs[msgs.length - 1];
+        if (!lastMsg?.id)
+            break;
+        afterCursor = lastMsg.id;
+    }
     return {
         contents: [
             {
                 uri: uri.href,
                 mimeType: "application/json",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify({ messages: allMessages }, null, 2),
             },
         ],
     };
@@ -536,6 +1132,7 @@ server.tool("get_current_room", "Get information about the currently joined room
                     ? {
                         connected: true,
                         ...toPublicRoomState(currentRoom),
+                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                         auth: getStoredAuth()
                             ? {
                                 source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
@@ -599,13 +1196,16 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     "Use this to let other agents and humans know what you are currently doing, " +
     "e.g. 'reviewing PR #2', 'waiting for tests', 'writing WISHLIST.md'. " +
     "Status updates are distinct from chat messages and can be filtered separately.", {
-    sender: z.string().describe("Name of the agent posting the status (e.g. 'codex-agent')"),
+    sender: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     status: z.string().describe("Short status description (e.g. 'reviewing PR #2', 'idle', 'thinking...')"),
     room_id: z
         .string()
         .optional()
         .describe("Canonical room ID. Defaults to the current room."),
-}, async ({ sender, status, room_id }) => {
+}, async ({ sender: _sender, status, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -624,6 +1224,8 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     }
     // Status messages use a reserved prefix so the UI (and agents) can distinguish
     // them from normal chat messages without changing the data model.
+    const identity = await ensureAgentIdentity();
+    const sender = identity.actor_label;
     const statusText = `[status] ${status}`;
     const message = await roomScopedApiCall({
         room_id: targetRoomId,
@@ -644,6 +1246,7 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
                     success: true,
                     status_posted: status,
                     sender,
+                    agent_identity: toPublicAgentIdentity(identity),
                     message_id: typeof message.id === "string" ? message.id : null,
                     timestamp: typeof message.timestamp === "string" ? message.timestamp : null,
                 }, null, 2),
@@ -662,10 +1265,13 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
     "work that needs to be done.", {
     title: z.string().describe("Short task title, e.g. 'Wire up Jest test runner'"),
     description: z.string().optional().describe("Longer description of what needs to be done"),
-    created_by: z.string().describe("Name of the agent or human creating the task"),
+    created_by: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     source_message_id: z.string().optional().describe("Optional message ID where task was agreed, e.g. 'msg_42'"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
-}, async ({ title, description, created_by, source_message_id, room_id }) => {
+}, async ({ title, description, created_by: _createdBy, source_message_id, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -673,6 +1279,7 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
             content: [{ type: "text", text: JSON.stringify({ success: false, error: "Not in a room. Join one first." }) }],
         };
     }
+    const identity = await ensureAgentIdentity();
     const task = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
@@ -680,11 +1287,21 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks`,
         options: {
             method: "POST",
-            body: JSON.stringify({ title, description, created_by, source_message_id }),
+            body: JSON.stringify({
+                title,
+                description,
+                created_by: identity.actor_label,
+                source_message_id,
+            }),
         },
     });
     return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, task }, null, 2) }],
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, task, agent_identity: toPublicAgentIdentity(identity) }, null, 2),
+            },
+        ],
     };
 });
 server.tool("get_board", "Get the current task board for the room. By default shows only open tasks " +
@@ -706,24 +1323,43 @@ server.tool("get_board", "Get the current task board for the room. By default sh
         params.set("status", status);
     if (open_only !== false)
         params.set("open", "true");
-    const qs = params.toString();
-    const result = await roomScopedApiCall({
-        room_id: targetRoomId,
-        project_id: targetProjectId,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks${qs ? `?${qs}` : ""}`,
-        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`,
-    });
+    // Paginate through all pages to return the full board
+    const allTasks = [];
+    let afterCursor;
+    for (;;) {
+        const pageParams = new URLSearchParams(params);
+        if (afterCursor)
+            pageParams.set("after", afterCursor);
+        const qs = pageParams.toString();
+        const result = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks${qs ? `?${qs}` : ""}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`,
+        });
+        const tasks = result.tasks ?? [];
+        allTasks.push(...tasks);
+        if (!result.has_more || tasks.length === 0)
+            break;
+        const lastTask = tasks[tasks.length - 1];
+        if (!lastTask?.id)
+            break;
+        afterCursor = lastTask.id;
+    }
     return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }],
+        content: [{ type: "text", text: JSON.stringify({ success: true, tasks: allTasks }, null, 2) }],
     };
 });
 server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted' " +
     "status. This sets the assignee to you and moves the status to 'assigned'. " +
     "Do NOT claim proposed tasks — they need to be accepted first.", {
     task_id: z.string().describe("The task ID to claim, e.g. 'task_1'"),
-    assignee: z.string().describe("Your agent name, e.g. 'antigravity'"),
+    assignee: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
-}, async ({ task_id, assignee, room_id }) => {
+}, async ({ task_id, assignee: _assignee, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -732,6 +1368,7 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
         };
     }
     try {
+        const identity = await ensureAgentIdentity();
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -739,11 +1376,16 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "assigned", assignee }),
+                body: JSON.stringify({ status: "assigned", assignee: identity.actor_label }),
             },
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, task: updated, agent_identity: toPublicAgentIdentity(identity) }, null, 2),
+                },
+            ],
         };
     }
     catch (error) {
@@ -757,7 +1399,10 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
     "but NOT proposed → in_progress).", {
     task_id: z.string().describe("The task ID to update"),
     status: z.enum(TASK_STATUSES).optional().describe("New status for the task"),
-    assignee: z.string().optional().describe("New assignee for the task"),
+    assignee: z
+        .string()
+        .optional()
+        .describe("New assignee for the task. Defaults to the current agent when status=assigned."),
     pr_url: z.string().optional().describe("PR URL to link to the task"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
 }, async ({ task_id, status, assignee, pr_url, room_id }) => {
@@ -769,6 +1414,9 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
         };
     }
     try {
+        const identity = status === "assigned" && !assignee
+            ? await ensureAgentIdentity()
+            : null;
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -776,11 +1424,24 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status, assignee, pr_url }),
+                body: JSON.stringify({
+                    status,
+                    assignee: assignee ?? identity?.actor_label,
+                    pr_url,
+                }),
             },
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        task: updated,
+                        agent_identity: identity ? toPublicAgentIdentity(identity) : null,
+                    }, null, 2),
+                },
+            ],
         };
     }
     catch (error) {
@@ -971,14 +1632,18 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
 // -- send_message -----------------------------------------------------------
 server.tool("send_message", "Send a message to a Let Agents Chat room.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
-    sender: z.string().describe("Name identifying the sending agent (e.g. 'antigravity-agent')"),
+    sender: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     text: z.string().describe("The message text to send"),
-}, async ({ room_id, sender, text }) => {
+}, async ({ room_id, sender: _sender, text }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
         throw new Error("No room is currently selected. Join a room first or pass room_id.");
     }
+    const identity = await ensureAgentIdentity();
     const message = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
@@ -986,7 +1651,7 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
         options: {
             method: "POST",
-            body: JSON.stringify({ sender, text }),
+            body: JSON.stringify({ sender: identity.actor_label, text }),
         },
     });
     touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
@@ -994,7 +1659,10 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(message, null, 2),
+                text: JSON.stringify({
+                    ...message,
+                    agent_identity: toPublicAgentIdentity(identity),
+                }, null, 2),
             },
         ],
     };
@@ -1005,17 +1673,41 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
 }, async ({ room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
-    const result = await roomScopedApiCall({
-        room_id: targetRoomId,
-        project_id: targetProjectId,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
-        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
-    });
+    // Paginate through all pages to honor the "read all messages" contract
+    const allMessages = [];
+    let afterCursor;
+    let roomIdFromResponse;
+    for (;;) {
+        const query = new URLSearchParams();
+        if (afterCursor)
+            query.set("after", afterCursor);
+        const qs = query.toString();
+        const result = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages${qs ? `?${qs}` : ""}`,
+        });
+        roomIdFromResponse = roomIdFromResponse || result.room_id || result.project_id;
+        const msgs = result.messages ?? [];
+        allMessages.push(...msgs);
+        if (!result.has_more || msgs.length === 0)
+            break;
+        // Use the last message ID as the cursor for the next page
+        const lastMsg = msgs[msgs.length - 1];
+        if (!lastMsg?.id)
+            break;
+        afterCursor = lastMsg.id;
+    }
+    const output = { messages: allMessages };
+    if (roomIdFromResponse) {
+        output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
+    }
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify(output, null, 2),
             },
         ],
     };
@@ -1043,21 +1735,49 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
         params.set("after", after_message_id);
     params.set("timeout", String(serverTimeout));
     const queryString = params.toString();
-    const result = await roomScopedApiCall({
+    const firstResult = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
         room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`,
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`,
         options: { signal: AbortSignal.timeout(clientTimeout) },
     });
+    const allMessages = [...(firstResult.messages ?? [])];
+    const roomIdFromResponse = firstResult.room_id || firstResult.project_id;
+    // If the immediate response has more pages, paginate through them
+    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({
+                room_id: targetRoomId,
+                project_id: targetProjectId,
+                room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages?${qs}`,
+                project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages?${qs}`,
+            });
+            const msgs = page.messages ?? [];
+            allMessages.push(...msgs);
+            if (!page.has_more || msgs.length === 0)
+                break;
+            afterCursor = msgs[msgs.length - 1]?.id;
+            if (!afterCursor)
+                break;
+        }
+    }
+    const output = { messages: allMessages };
+    if (roomIdFromResponse) {
+        output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
+    }
     if (targetRoomId) {
-        touchRoomSession(targetRoomId, getLastMessageId(result));
+        touchRoomSession(targetRoomId, getLastMessageId(output));
     }
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify(output, null, 2),
             },
         ],
     };
@@ -1100,6 +1820,7 @@ server.tool("get_onboarding_status", "Inspect local Let Agents MCP auth and room
                     account: storedAuth?.account ?? null,
                     token_expires_at: storedAuth?.expires_at ?? null,
                     pending_device_auth: pendingAuth,
+                    agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                     current_room: toPublicRoomState(currentRoom),
                     saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
                     detected_room_from_context: detectedRoom,
@@ -1222,6 +1943,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
     if (result.status === "denied" || result.status === "expired") {
         clearPendingDeviceAuth();
         clearStoredAuth();
+        currentAuthenticatedAccount = undefined;
+        currentAuthenticatedAccountSource = null;
+        currentAuthenticatedEnvToken = null;
         return {
             content: [
                 {
@@ -1242,6 +1966,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
         stored_at: new Date().toISOString(),
         source: "device_flow",
     });
+    currentAuthenticatedAccount = storedAuth.account ?? undefined;
+    currentAuthenticatedAccountSource = storedAuth.account ? "stored" : null;
+    currentAuthenticatedEnvToken = null;
     let joinedRoom = null;
     const roomToJoin = room_id ||
         pendingAuth?.suggested_room_id ||
@@ -1252,8 +1979,8 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
         const joinedVia = looksLikeInviteCode(roomToJoin) ? "join_code" : "join_room";
         const joined = await joinRoomIdentifier(roomToJoin, joinedVia);
         joinedRoom = joined.room;
-        await autoRegisterAgentIdentity();
     }
+    const agentIdentity = await ensureAgentIdentity();
     return {
         content: [
             {
@@ -1264,6 +1991,7 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
                     account: storedAuth.account ?? null,
                     expires_at: storedAuth.expires_at ?? null,
                     auto_joined_room: joinedRoom,
+                    agent_identity: toPublicAgentIdentity(agentIdentity),
                 }, null, 2),
             },
         ],
@@ -1272,6 +2000,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
 server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token and pending device auth request.", {}, async () => {
     clearPendingDeviceAuth();
     clearStoredAuth();
+    currentAuthenticatedAccount = undefined;
+    currentAuthenticatedAccountSource = null;
+    currentAuthenticatedEnvToken = null;
     return {
         content: [
             {
@@ -1304,7 +2035,7 @@ server.tool("resume_room_session", "Rejoin the last locally saved room context,
     }
     try {
         const joined = await joinRoomIdentifier(savedRoom.room_id, savedRoom.joined_via);
-        await autoRegisterAgentIdentity();
+        const agentIdentity = await ensureAgentIdentity();
         return {
             content: [
                 {
@@ -1314,7 +2045,8 @@ server.tool("resume_room_session", "Rejoin the last locally saved room context,
                         rejoined_from_local_state: true,
                         server_session_resumed: false,
                         last_message_id_before_restart: savedRoom.last_message_id ?? null,
-                        room: joined.room,
+                        room: toPublicRoomState(joined.room),
+                        agent_identity: toPublicAgentIdentity(agentIdentity),
                     }, null, 2),
                 },
             ],
@@ -1378,6 +2110,7 @@ async function main() {
         const configRoom = getRoomFromConfig();
         if (configRoom) {
             await joinRoomIdentifier(configRoom, "config");
+            await ensureAgentIdentity();
             console.error(`🏠 Auto-joined room '${configRoom}' (from .letagents.json)`);
             return;
         }
@@ -1385,6 +2118,7 @@ async function main() {
         const gitRoom = getGitRemoteIdentity();
         if (gitRoom) {
             await joinRoomIdentifier(gitRoom, "git-remote");
+            await ensureAgentIdentity();
             console.error(`🏠 Auto-joined room '${gitRoom}' (inferred from git remote — consider adding a .letagents.json)`);
             return;
         }
@@ -1392,6 +2126,7 @@ async function main() {
         const savedCurrentRoom = getStoredCurrentRoom();
         if (savedCurrentRoom) {
             await joinRoomIdentifier(savedCurrentRoom.room_id, savedCurrentRoom.joined_via);
+            await ensureAgentIdentity();
             console.error(`🏠 Rejoined saved room '${savedCurrentRoom.room_id}' (from local state)`);
             return;
         }