letagents 0.9.0 → 0.11.0

package/dist/mcp/codenames.js

@@ -0,0 +1,154 @@
+/**
+ * Agent codenames — extracted from server.ts per Emmy's directive.
+ *
+ * Each agent instance gets a two-word codename (e.g. "River Valley")
+ * deterministically derived from its runtime key via SHA-256 hashing.
+ */
+import { createHash } from "crypto";
+import { toTitleCaseCodename } from "../shared/agent-identity.js";
+// ---------------------------------------------------------------------------
+// Codenames
+// ---------------------------------------------------------------------------
+export 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",
+];
+export const AGENT_CODENAME_SPACE = AGENT_CODENAMES.length * AGENT_CODENAMES.length;
+// ---------------------------------------------------------------------------
+// Slug helpers
+// ---------------------------------------------------------------------------
+export 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;
+}
+export function normalizeAgentBaseName(input) {
+    return normalizeSlugSegment(input, "agent").replace(/-agent$/, "") || "agent";
+}
+// ---------------------------------------------------------------------------
+// Codename derivation
+// ---------------------------------------------------------------------------
+export function hashStringToIndex(value, modulo) {
+    const digest = createHash("sha256").update(value).digest();
+    return digest.readUInt16BE(0) % modulo;
+}
+export 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)}`,
+    };
+}
+export function pickLocalCodename(runtimeKey, offset = 0) {
+    const index = hashStringToIndex(runtimeKey, AGENT_CODENAME_SPACE) + offset;
+    return codenameFromIndex(index);
+}

package/dist/mcp/local-state.js

@@ -1,12 +1,16 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { randomBytes } from "crypto";
 import { homedir } from "os";
 import { dirname, join } from "path";
 const DEFAULT_STATE_PATH = join(homedir(), ".letagents", "mcp-state.json");
+const STATE_LOCK_WAIT_MS = 25;
+const STATE_LOCK_TIMEOUT_MS = 2_000;
+const STATE_LOCK_STALE_MS = 10_000;
+const STATE_LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 export function getLocalStatePath() {
     return process.env.LETAGENTS_STATE_PATH || DEFAULT_STATE_PATH;
 }
-export function readLocalState() {
-    const statePath = getLocalStatePath();
+function readLocalStateFromPath(statePath) {
     if (!existsSync(statePath)) {
         return {};
     }
@@ -19,18 +23,76 @@ export function readLocalState() {
         return {};
     }
 }
-export function writeLocalState(state) {
+export function readLocalState() {
+    const statePath = getLocalStatePath();
+    return readLocalStateFromPath(statePath);
+}
+function sleepSync(ms) {
+    if (ms > 0) {
+        Atomics.wait(STATE_LOCK_SLEEP_BUFFER, 0, 0, ms);
+    }
+}
+function writeLocalStateUnlocked(statePath, state) {
+    const tempPath = `${statePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+        renameSync(tempPath, statePath);
+    }
+    finally {
+        rmSync(tempPath, { force: true });
+    }
+}
+function withStateLock(callback) {
     const statePath = getLocalStatePath();
     mkdirSync(dirname(statePath), { recursive: true });
-    const tempPath = `${statePath}.tmp`;
-    writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-    renameSync(tempPath, statePath);
+    const lockPath = `${statePath}.lock`;
+    const startedAt = Date.now();
+    while (true) {
+        let lockFd = null;
+        try {
+            lockFd = openSync(lockPath, "wx");
+            return callback(statePath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST") {
+                throw error;
+            }
+            try {
+                const stats = statSync(lockPath);
+                if (Date.now() - stats.mtimeMs > STATE_LOCK_STALE_MS) {
+                    rmSync(lockPath, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - startedAt >= STATE_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out acquiring local state lock at ${lockPath}`);
+            }
+            sleepSync(STATE_LOCK_WAIT_MS);
+        }
+        finally {
+            if (lockFd !== null) {
+                closeSync(lockFd);
+                rmSync(lockPath, { force: true });
+            }
+        }
+    }
+}
+export function writeLocalState(state) {
+    withStateLock((statePath) => {
+        writeLocalStateUnlocked(statePath, state);
+    });
 }
 export function updateLocalState(updater) {
-    const current = readLocalState();
-    const updated = updater(current) ?? current;
-    writeLocalState(updated);
-    return updated;
+    return withStateLock((statePath) => {
+        const current = readLocalStateFromPath(statePath);
+        const updated = updater(current) ?? current;
+        writeLocalStateUnlocked(statePath, updated);
+        return updated;
+    });
 }
 function isExpired(expiresAt) {
     if (!expiresAt) {

package/dist/mcp/room-id.js

@@ -4,6 +4,9 @@ export function encodeRoomIdPath(roomId) {
         .map((segment) => encodeURIComponent(segment))
         .join("/");
 }
+export function getCanonicalRoomWebPath(roomId) {
+    return `/in/${encodeRoomIdPath(roomId)}`;
+}
 export function looksLikeInviteCode(value) {
     return /^[A-Z0-9]{4}(?:-[A-Z0-9]{4})+$/.test(value.trim().toUpperCase());
 }

package/dist/mcp/server.js

@@ -2,7 +2,7 @@
 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 { createHash, randomUUID } from "crypto";
 import { writeFileSync, existsSync } from "fs";
 import { userInfo } from "os";
 import { join, dirname } from "path";
@@ -10,12 +10,13 @@ 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, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setStoredAgentIdentity, setPendingDeviceAuth, setStoredAuth, touchRoomSession, } from "./local-state.js";
-import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
+import { AGENT_CODENAME_SPACE, normalizeSlugSegment, normalizeAgentBaseName, pickLocalCodename, } from "./codenames.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";
-const CURRENT_AGENT_IDENTITY_KEY = getAgentIdentityStorageKey();
 let currentRoom = null;
-let currentAgentIdentity = getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY);
+let currentAgentIdentityKey = "";
+let currentAgentIdentity = null;
 let currentAuthenticatedAccount = undefined;
 let currentAuthenticatedAccountSource = null;
 let currentAuthenticatedEnvToken = null;
@@ -27,6 +28,11 @@ const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME || process.env.AGENT_NAME |
 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();
+const AGENT_INSTANCE_UUID = randomUUID();
+currentAgentIdentityKey =
+    EXPLICIT_AGENT_IDENTITY_KEY ?? `instance:${AGENT_INSTANCE_UUID}`;
+currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -43,130 +49,17 @@ function readCommandOutput(command, cwd = process.cwd()) {
         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";
-}
+// normalizeSlugSegment, normalizeAgentBaseName, AGENT_CODENAMES,
+// AGENT_CODENAME_SPACE, hashStringToIndex, codenameFromIndex,
+// pickLocalCodename — all imported from ./codenames.js
 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",
-];
-function getAgentIdentityStorageKey() {
+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}`,
@@ -177,11 +70,10 @@ function getAgentIdentityStorageKey() {
     if (runtimeSignals.length) {
         return runtimeSignals[0];
     }
-    return `cwd:${process.cwd()}`;
+    return null;
 }
-function hashStringToIndex(value, modulo) {
-    const digest = createHash("sha256").update(value).digest();
-    return digest.readUInt16BE(0) % modulo;
+function getFallbackAgentIdentityNamespaceKey(ideLabel) {
+    return `cwd:${process.cwd()}:ide:${normalizeAgentBaseName(ideLabel)}`;
 }
 function detectAgentIdeLabel() {
     if (AGENT_IDE_LABEL) {
@@ -194,6 +86,125 @@ function detectAgentIdeLabel() {
     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;
+    }
+    // v1: Use per-instance UUID for guaranteed distinct identity.
+    // Each MCP process gets a unique UUID — no slot/PID coordination needed.
+    // Trade-off: process restart = new identity (accepted for v1).
+    const uuidKey = `instance:${AGENT_INSTANCE_UUID}`;
+    currentAgentIdentityKey = uuidKey;
+    currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
+    return currentAgentIdentityKey;
+}
 async function getAuthenticatedAgentDirectory() {
     try {
         const result = await apiCall("/agents/me");
@@ -213,9 +224,9 @@ async function getAuthenticatedAgentDirectory() {
         return null;
     }
 }
-function shouldReuseStoredIdentity(identity) {
+function shouldReuseStoredIdentity(identity, identityKey) {
     return Boolean(identity &&
-        identity.runtime_key === CURRENT_AGENT_IDENTITY_KEY &&
+        identity.runtime_key === identityKey &&
         identity.display_name?.trim() &&
         identity.ide_label?.trim() &&
         identity.owner_attribution?.trim());
@@ -236,43 +247,36 @@ function resolveExplicitAgentIdentity() {
     }
     return null;
 }
-function pickLocalCodename(runtimeKey, offset = 0) {
-    const index = (hashStringToIndex(runtimeKey, AGENT_CODENAMES.length) + offset) % AGENT_CODENAMES.length;
-    const word = AGENT_CODENAMES[index];
-    return {
-        name: normalizeAgentBaseName(word),
-        display_name: toTitleCaseCodename(word),
-    };
-}
-async function resolveAgentName(authAvailable) {
+// pickLocalCodename — imported from ./codenames.js
+async function resolveAgentName(authAvailable, identityKey) {
     const explicit = resolveExplicitAgentIdentity();
     if (explicit) {
         return explicit;
     }
-    if (shouldReuseStoredIdentity(currentAgentIdentity)) {
+    if (shouldReuseStoredIdentity(currentAgentIdentity, identityKey)) {
         return {
             name: currentAgentIdentity.name,
             display_name: currentAgentIdentity.display_name,
         };
     }
     if (!authAvailable) {
-        return pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+        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_CODENAMES.length; offset += 1) {
-        const candidate = pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY, offset);
+    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(CURRENT_AGENT_IDENTITY_KEY)
+        .update(identityKey)
         .digest("hex")
         .slice(0, 4);
-    const fallback = pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+    const fallback = pickLocalCodename(identityKey);
     return {
         name: `${fallback.name}-${fallbackHash}`,
         display_name: `${fallback.display_name} ${fallbackHash.toUpperCase()}`,
@@ -377,6 +381,7 @@ function toPublicAgentIdentity(identity) {
         actor_label: identity.actor_label,
         canonical_key: identity.canonical_key ?? null,
         runtime_key: identity.runtime_key ?? null,
+        agent_instance_id: AGENT_INSTANCE_UUID,
         source: identity.source,
     };
 }
@@ -384,8 +389,9 @@ 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);
+    const { name, display_name: displayName } = await resolveAgentName(authAvailable, identityKey);
     const actorLabel = buildAgentActorLabel({
         display_name: displayName,
         owner_label: owner.label,
@@ -399,7 +405,7 @@ async function ensureAgentIdentity() {
         ide_label: ideLabel,
         actor_label: actorLabel,
         canonical_key: owner.login ? `${owner.login}/${name}` : null,
-        runtime_key: CURRENT_AGENT_IDENTITY_KEY,
+        runtime_key: identityKey,
         source: "local",
         resolved_at: new Date().toISOString(),
     };
@@ -452,7 +458,7 @@ async function ensureAgentIdentity() {
         currentAgentIdentity = setStoredAgentIdentity({
             ...resolved,
             resolved_at: new Date().toISOString(),
-        }, CURRENT_AGENT_IDENTITY_KEY);
+        }, identityKey);
     }
     return currentAgentIdentity ?? resolved;
 }
@@ -628,22 +634,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,
@@ -651,12 +667,12 @@ 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,
     };
 }
@@ -868,18 +884,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),
             },
         ],
     };
@@ -972,7 +1005,7 @@ server.tool("get_current_room", "Get information about the currently joined room
                     ? {
                         connected: true,
                         ...toPublicRoomState(currentRoom),
-                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY)),
+                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                         auth: getStoredAuth()
                             ? {
                                 source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
@@ -1163,15 +1196,31 @@ 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' " +
@@ -1497,17 +1546,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),
             },
         ],
     };
@@ -1535,21 +1608,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),
             },
         ],
     };
@@ -1592,7 +1693,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(CURRENT_AGENT_IDENTITY_KEY)),
+                    agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                     current_room: toPublicRoomState(currentRoom),
                     saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
                     detected_room_from_context: detectedRoom,
@@ -1763,7 +1864,11 @@ 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,
+                    ...(joinedRoom?.room_id
+                        ? withCanonicalRoomLink(joinedRoom.room_id, {})
+                        : {}),
                     agent_identity: toPublicAgentIdentity(agentIdentity),
+                    hint: "You can change your agent's display name anytime using the set_agent_name tool.",
                 }, null, 2),
             },
         ],
@@ -1787,6 +1892,95 @@ server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token an
         ],
     };
 });
+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
+        .string()
+        .min(2)
+        .max(64)
+        .describe("The desired display name for this agent (2-64 characters)."),
+}, async ({ name: desiredName }) => {
+    const trimmedName = desiredName.trim();
+    if (trimmedName.length < 2 || trimmedName.length > 64) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "Name must be between 2 and 64 characters." }, null, 2),
+                },
+            ],
+        };
+    }
+    const authAvailable = Boolean(getLetagentsToken());
+    if (!authAvailable) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "Authentication required. Run start_device_auth first." }, null, 2),
+                },
+            ],
+        };
+    }
+    const slugName = normalizeAgentBaseName(trimmedName);
+    try {
+        const owner = await resolveOwnerContext();
+        const registered = await apiCall("/agents", {
+            method: "POST",
+            body: JSON.stringify({
+                name: slugName,
+                display_name: trimmedName,
+                owner_label: owner.label,
+            }),
+        });
+        const ideLabel = detectAgentIdeLabel();
+        const ownerAttribution = formatOwnerAttribution(owner.label);
+        const actorLabel = buildAgentActorLabel({
+            display_name: trimmedName,
+            owner_label: owner.label,
+            ide_label: ideLabel,
+        });
+        const updatedIdentity = {
+            name: slugName,
+            display_name: trimmedName,
+            owner_label: owner.label,
+            owner_attribution: ownerAttribution,
+            ide_label: ideLabel,
+            actor_label: actorLabel,
+            canonical_key: typeof registered.canonical_key === "string"
+                ? registered.canonical_key
+                : owner.login ? `${owner.login}/${slugName}` : null,
+            runtime_key: currentAgentIdentityKey,
+            source: "api",
+            resolved_at: new Date().toISOString(),
+        };
+        currentAgentIdentity = setStoredAgentIdentity(updatedIdentity, currentAgentIdentityKey);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: `Agent name changed to "${trimmedName}".`,
+                        agent_identity: toPublicAgentIdentity(currentAgentIdentity),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: `Failed to set name: ${error instanceof Error ? error.message : String(error)}`,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+});
 server.tool("resume_room_session", "Rejoin the last locally saved room context, or a specific saved room, after a restart. This recreates participation in the room; it does not preserve a prior server-side session ID.", {
     room_id: z
         .string()
@@ -1817,7 +2011,7 @@ 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),
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",