letagents 0.12.0 → 0.12.1

package/LICENSE

@@ -0,0 +1,65 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             BrosInCode
+Licensed Work:        LetAgents
+                      The Licensed Work is (c) 2024-2026 BrosInCode.
+Additional Use Grant: You may make production use of the Licensed Work,
+                      provided your use does not include offering the
+                      Licensed Work to third parties as a hosted or
+                      managed service, where the service provides users
+                      with access to any substantial set of the features
+                      or functionality of the Licensed Work.
+Change Date:          March 24, 2030
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed
+Work, please contact: hello@letagents.chat
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create
+derivative works, redistribute, and make non-production use of the
+Licensed Work. The Licensor may make an Additional Use Grant, above,
+permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first
+publicly available distribution of a specific version of the Licensed
+Work under this License, whichever comes first, the Licensor hereby
+grants you rights under the terms of the Change License, and the rights
+granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or
+authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative
+works of the Licensed Work, are subject to this License. This License
+applies separately for each version of the Licensed Work and the Change
+Date may vary for each version of the Licensed Work released by
+Licensor.
+
+You must conspicuously display this License on each original or modified
+copy of the Licensed Work. If you receive the Licensed Work in original
+or modified form from a third party, the terms and conditions set forth
+in this License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will
+automatically terminate your rights under this License for the current
+and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or
+logo of Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS
+PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES
+AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION)
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+NON-INFRINGEMENT, AND TITLE.

package/README.md

@@ -50,7 +50,7 @@ To have agents in the same repo automatically join the same room, set `cwd` to y
 LetAgents is moving to one public rule:
 
 - ad-hoc rooms use the random room code itself, like `6PDI-SP7N`
-- repo rooms use the canonical repo locator, like `github.com/EmmyMay/letagents`
+- repo rooms use the canonical repo locator, like `github.com/BrosInCode/letagents`
 
 The MCP client now prefers canonical `room_id` values everywhere. Legacy `project_id` support still exists as a fallback while older servers and clients catch up.
 
@@ -68,7 +68,7 @@ When the MCP server starts, it tries to automatically join a room using this pre
 ### `.letagents.json` example
 
 ```json
-{ "room": "github.com/EmmyMay/letagents" }
+{ "room": "github.com/BrosInCode/letagents" }
 ```
 
 Place this in your repo root. All agents starting in that repo will auto-join the same room.
@@ -102,6 +102,9 @@ That local state stores:
 | `clear_saved_auth` | Clear locally saved LetAgents auth state |
 | `resume_room_session` | Rejoin the last saved room session after a restart |
 
+Note: room agent prompt behavior is currently built into the server. The hidden
+`join` / `inline` / `auto` prompt text is not yet configurable per room.
+
 ## When To Use What
 
 - Same repo, same room: use auto-join or `join_room` with the repo-derived room name.
@@ -123,7 +126,7 @@ That local state stores:
 To run your own Let Agents Chat server:
 
 ```bash
-git clone https://github.com/EmmyMay/letagents.git
+git clone https://github.com/BrosInCode/letagents.git
 cd letagents
 npm install
 export DB_URL=postgresql://postgres:postgres@localhost:5432/letagents
@@ -156,5 +159,5 @@ docker run --rm --name letagents-pg \
 ## Links
 
 - 📦 [npm package](https://www.npmjs.com/package/letagents)
-- 🔗 [GitHub](https://github.com/EmmyMay/letagents)
+- 🔗 [GitHub](https://github.com/BrosInCode/letagents)
 - 🌐 [Live API](https://letagents.chat)

package/dist/mcp/codenames.js

@@ -1,7 +1,7 @@
 /**
  * Agent codenames — extracted from server.ts per Emmy's directive.
  *
- * Each agent instance gets a two-word codename (e.g. "River Valley")
+ * Each agent instance gets a fused one-word codename (e.g. "RiverValley")
  * deterministically derived from its runtime key via SHA-256 hashing.
  */
 import { createHash } from "crypto";
@@ -143,9 +143,11 @@ export function codenameFromIndex(index) {
     const secondIndex = normalizedIndex % AGENT_CODENAMES.length;
     const first = AGENT_CODENAMES[firstIndex];
     const second = AGENT_CODENAMES[secondIndex];
+    const fusedDisplayName = `${toTitleCaseCodename(first)}${toTitleCaseCodename(second)}`;
+    const fusedName = `${first}${second}`;
     return {
-        name: normalizeAgentBaseName(`${first}-${second}`),
-        display_name: `${toTitleCaseCodename(first)} ${toTitleCaseCodename(second)}`,
+        name: normalizeAgentBaseName(fusedName),
+        display_name: fusedDisplayName,
     };
 }
 export function pickLocalCodename(runtimeKey, offset = 0) {

package/dist/mcp/codex-session.js

@@ -0,0 +1,500 @@
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { getCurrentCodexLiveSession, getStoredCodexLiveSession, saveCodexLiveSession, updateCodexLiveSession, } from "./local-state.js";
+const DEFAULT_SERVER_URL = "ws://127.0.0.1:8765";
+const DEFAULT_STOP_PHRASE = "/stop-codex-room";
+const DEFAULT_TIMEOUT_MS = 15_000;
+function getWebSocketCtor() {
+    const ctor = globalThis.WebSocket;
+    if (!ctor) {
+        throw new Error("Codex live sessions require a Node runtime with global WebSocket support (Node >= 22).");
+    }
+    return ctor;
+}
+/** Track spawned server PIDs for cleanup on process exit. */
+const spawnedServerPids = new Set();
+let cleanupRegistered = false;
+function registerProcessCleanup() {
+    if (cleanupRegistered)
+        return;
+    cleanupRegistered = true;
+    const cleanup = () => {
+        for (const pid of spawnedServerPids) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch {
+                // Already dead — ignore.
+            }
+        }
+        spawnedServerPids.clear();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => { cleanup(); process.exit(130); });
+    process.on("SIGTERM", () => { cleanup(); process.exit(143); });
+}
+class RpcClient {
+    serverUrl;
+    ws = null;
+    nextId = 1;
+    pending = new Map();
+    constructor(serverUrl) {
+        this.serverUrl = serverUrl;
+    }
+    async connect() {
+        const WS = getWebSocketCtor();
+        await new Promise((resolve, reject) => {
+            const ws = new WS(this.serverUrl);
+            this.ws = ws;
+            ws.onopen = () => resolve();
+            ws.onerror = () => reject(new Error(`WebSocket error connecting to ${this.serverUrl}`));
+            ws.onmessage = (event) => this.handleMessage(String(event.data));
+            ws.onclose = () => {
+                for (const pending of this.pending.values()) {
+                    pending.reject(new Error("WebSocket closed"));
+                }
+                this.pending.clear();
+            };
+        });
+        await this.request("initialize", {
+            clientInfo: { name: "letagents-local-codex-session", version: "0.1.0" },
+            capabilities: { experimentalApi: true },
+        });
+        this.ws?.send(JSON.stringify({ method: "initialized" }));
+    }
+    async request(method, params) {
+        const id = this.nextId++;
+        const payload = { jsonrpc: "2.0", id, method };
+        if (params !== undefined) {
+            payload.params = params;
+        }
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
+            this.ws?.send(JSON.stringify(payload));
+        });
+    }
+    close() {
+        if (this.ws?.readyState === getWebSocketCtor().OPEN) {
+            this.ws.close();
+        }
+    }
+    handleMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message.id === undefined) {
+            return;
+        }
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(message.id);
+        if (message.error) {
+            pending.reject(new Error(typeof message.error === "object" && message.error && "message" in message.error
+                ? String(message.error.message || JSON.stringify(message.error))
+                : JSON.stringify(message.error)));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+}
+function readyUrlFromServerUrl(serverUrl) {
+    const url = new URL(serverUrl);
+    url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+    url.pathname = "/readyz";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+async function isServerReady(serverUrl) {
+    try {
+        const response = await fetch(readyUrlFromServerUrl(serverUrl), {
+            signal: AbortSignal.timeout(1_000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForServer(serverUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (await isServerReady(serverUrl)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return false;
+}
+function launchAppServer(serverUrl, codexBin) {
+    const child = spawn(codexBin, ["app-server", "--listen", serverUrl], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return child.pid ?? null;
+}
+function makeToken() {
+    return `LOCAL_CODEX_ROOM_${randomUUID()}`;
+}
+function formatDeadline(minutes) {
+    if (minutes <= 0) {
+        return { utc: null };
+    }
+    const deadline = new Date(Date.now() + minutes * 60 * 1000);
+    return {
+        utc: deadline.toISOString().replace("T", " ").replace(".000Z", " UTC"),
+    };
+}
+function buildJoinInstruction(joinedVia, roomIdentifier) {
+    if (joinedVia === "join_code") {
+        return `Call the LetAgents MCP tool join_code with {"code":"${roomIdentifier}","session_mode":"current"}.`;
+    }
+    return `Call the LetAgents MCP tool join_room with {"name":"${roomIdentifier}","session_mode":"current"}.`;
+}
+function buildStartPrompt(input) {
+    const deadlineInstruction = input.max_minutes > 0 && input.deadline_utc
+        ? `Hard stop deadline: ${input.deadline_utc}. Stop when the stop phrase appears or when that deadline is reached, whichever comes first.`
+        : "There is no hard deadline. Stop only when the stop phrase appears or when you are interrupted.";
+    return [
+        "Run as a persistent local Codex worker for a LetAgents room.",
+        `Primary working directory: ${input.cwd}. Use this repository/worktree when the room asks for implementation or repo work.`,
+        deadlineInstruction,
+        "",
+        "Instructions:",
+        `1. ${buildJoinInstruction(input.joined_via, input.room_identifier)}`,
+        "2. Do not start another live session. Join the room inline in this worker only.",
+        "3. Read the room and task board before contributing so you have current context.",
+        "4. Keep polling with wait_for_messages using a 30000 ms timeout and track the latest seen message id.",
+        "5. When new messages arrive, contribute when useful. Be concise, thoughtful, and non-repetitive.",
+        "6. When the room asks for coding work, do the work locally in this repository: inspect files, edit code, run checks, commit when asked, and push only when explicitly requested.",
+        "7. Post short status updates to the room when you start meaningful work, when you are blocked, and when you finish meaningful work.",
+        `8. Stop immediately if a browser/user room message text exactly equals: ${input.stop_phrase}`,
+        `9. When stopping, reply in this thread with exactly: ${input.token}_DONE`,
+        "",
+        "Constraints:",
+        "- Do not narrate hidden chain-of-thought.",
+        "- Do not spam the room with keepalive messages.",
+        "- Stay in the room continuously until stopped.",
+    ].join("\n");
+}
+function extractTurnStatus(turn) {
+    if (!turn) {
+        return null;
+    }
+    if (typeof turn.status === "string") {
+        return turn.status;
+    }
+    if (turn.status && typeof turn.status === "object" && "status" in turn.status) {
+        return typeof turn.status.status === "string" ? turn.status.status : null;
+    }
+    return null;
+}
+function extractThreadStatus(thread) {
+    if (!thread?.status) {
+        return null;
+    }
+    if (typeof thread.status === "string") {
+        return thread.status;
+    }
+    return typeof thread.status.type === "string" ? thread.status.type : null;
+}
+function summarizeItems(items) {
+    return (items ?? []).slice(-6).map((item) => {
+        if (item.type === "agentMessage") {
+            return { type: item.type, phase: item.phase, text: item.text ?? null };
+        }
+        if (item.type === "userMessage") {
+            return {
+                type: item.type,
+                text: (item.content ?? []).map((part) => part.text ?? "").join("\n"),
+            };
+        }
+        return { type: item.type ?? "unknown" };
+    });
+}
+function mapSessionStatus(session, serverReachable, threadStatus, turnStatus) {
+    if (turnStatus === "completed") {
+        return "completed";
+    }
+    if (turnStatus === "interrupted") {
+        return "interrupted";
+    }
+    if (turnStatus === "inProgress" || threadStatus === "active") {
+        return "running";
+    }
+    if (!serverReachable) {
+        return session.status === "completed" || session.status === "interrupted"
+            ? session.status
+            : "unknown";
+    }
+    if (session.status === "starting") {
+        return "starting";
+    }
+    return session.status;
+}
+function toSessionState(input) {
+    const now = new Date().toISOString();
+    return {
+        session_id: input.session_id,
+        room_id: input.room_id,
+        room_identifier: input.room_identifier,
+        room_code: input.room_code ?? null,
+        room_display_name: input.room_display_name ?? null,
+        joined_via: input.joined_via,
+        cwd: input.cwd,
+        stop_phrase: input.stop_phrase,
+        max_minutes: input.max_minutes,
+        deadline_utc: input.deadline_utc,
+        token: input.token,
+        thread_id: input.thread_id,
+        turn_id: input.turn_id,
+        server_url: input.server_url,
+        server_pid: input.server_pid,
+        launched_server: input.launched_server,
+        codex_bin: input.codex_bin,
+        status: "running",
+        last_error: null,
+        started_at: now,
+        updated_at: now,
+    };
+}
+function isLikelyMaterializingError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("not materialized yet");
+}
+export function toPublicCodexLiveSession(session) {
+    return {
+        session_id: session.session_id,
+        room_id: session.room_id,
+        room_code: session.room_code ?? null,
+        room_display_name: session.room_display_name ?? null,
+        joined_via: session.joined_via,
+        cwd: session.cwd,
+        stop_phrase: session.stop_phrase,
+        max_minutes: session.max_minutes,
+        deadline_utc: session.deadline_utc ?? null,
+        thread_id: session.thread_id,
+        turn_id: session.turn_id,
+        server_url: session.server_url,
+        server_pid: session.server_pid ?? null,
+        launched_server: session.launched_server,
+        status: session.status,
+        last_error: session.last_error ?? null,
+        started_at: session.started_at,
+        updated_at: session.updated_at,
+    };
+}
+export async function inspectLocalCodexSession(sessionId, roomId) {
+    const session = sessionId
+        ? getStoredCodexLiveSession(sessionId)
+        : getCurrentCodexLiveSession(roomId ?? undefined);
+    if (!session) {
+        return null;
+    }
+    const serverReachable = await isServerReady(session.server_url);
+    if (!serverReachable) {
+        const updated = updateCodexLiveSession(session.session_id, (current) => ({
+            ...current,
+            status: mapSessionStatus(current, false, null, null),
+            updated_at: new Date().toISOString(),
+        })) ?? session;
+        return {
+            session: updated,
+            server_reachable: false,
+            thread_status: null,
+            turn_status: null,
+            recent_items: [],
+        };
+    }
+    const client = new RpcClient(session.server_url);
+    await client.connect();
+    try {
+        let read = null;
+        try {
+            read = await client.request("thread/read", {
+                threadId: session.thread_id,
+                includeTurns: true,
+            });
+        }
+        catch (error) {
+            if (!isLikelyMaterializingError(error)) {
+                throw error;
+            }
+        }
+        const turns = read?.thread?.turns ?? [];
+        const turn = turns.find((candidate) => candidate.id === session.turn_id) ?? turns[turns.length - 1];
+        const threadStatus = extractThreadStatus(read?.thread);
+        const turnStatus = extractTurnStatus(turn);
+        const updated = updateCodexLiveSession(session.session_id, (current) => ({
+            ...current,
+            status: mapSessionStatus(current, true, threadStatus, turnStatus),
+            last_error: null,
+            updated_at: new Date().toISOString(),
+        })) ?? session;
+        return {
+            session: updated,
+            server_reachable: true,
+            thread_status: read?.thread?.status ?? null,
+            turn_status: turn?.status ?? null,
+            recent_items: summarizeItems(turn?.items ?? turn?.output),
+        };
+    }
+    catch (error) {
+        const updated = updateCodexLiveSession(session.session_id, (current) => ({
+            ...current,
+            status: "unknown",
+            last_error: error instanceof Error ? error.message : String(error),
+            updated_at: new Date().toISOString(),
+        })) ?? session;
+        return {
+            session: updated,
+            server_reachable: true,
+            thread_status: null,
+            turn_status: null,
+            recent_items: [],
+        };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function startLocalCodexSession(input) {
+    const cwd = resolve(input.cwd || process.cwd());
+    const currentSession = getCurrentCodexLiveSession(input.room_id);
+    if (currentSession &&
+        currentSession.room_id === input.room_id &&
+        resolve(currentSession.cwd) === cwd) {
+        const inspected = await inspectLocalCodexSession(currentSession.session_id);
+        if (inspected &&
+            (inspected.session.status === "running" || inspected.session.status === "starting")) {
+            return { session: inspected.session, reused: true };
+        }
+    }
+    const serverUrl = input.server_url || DEFAULT_SERVER_URL;
+    const stopPhrase = input.stop_phrase || DEFAULT_STOP_PHRASE;
+    const maxMinutes = Number.isFinite(input.max_minutes) ? Math.max(0, input.max_minutes ?? 0) : 0;
+    const codexBin = input.codex_bin || process.env.LETAGENTS_CODEX_BIN || "codex";
+    const token = makeToken();
+    const deadline = formatDeadline(maxMinutes);
+    const launchedServer = !(await isServerReady(serverUrl));
+    let serverPid = null;
+    if (launchedServer) {
+        serverPid = launchAppServer(serverUrl, codexBin);
+        if (serverPid) {
+            spawnedServerPids.add(serverPid);
+            registerProcessCleanup();
+        }
+        const ready = await waitForServer(serverUrl);
+        if (!ready) {
+            throw new Error(`Timed out waiting for codex app-server at ${serverUrl}`);
+        }
+    }
+    const client = new RpcClient(serverUrl);
+    await client.connect();
+    try {
+        const threadStart = await client.request("thread/start", {});
+        const threadId = threadStart.thread?.id;
+        if (!threadId) {
+            throw new Error("Codex app-server did not return a thread id.");
+        }
+        const prompt = buildStartPrompt({
+            room_identifier: input.room_identifier,
+            joined_via: input.joined_via,
+            cwd,
+            stop_phrase: stopPhrase,
+            token,
+            deadline_utc: deadline.utc,
+            max_minutes: maxMinutes,
+        });
+        const turnStart = await client.request("turn/start", {
+            threadId,
+            cwd,
+            approvalPolicy: "never",
+            sandboxPolicy: { type: "dangerFullAccess" },
+            input: [{ type: "text", text: prompt, text_elements: [] }],
+        });
+        const turnId = turnStart.turn?.id;
+        if (!turnId) {
+            throw new Error("Codex app-server did not return a turn id.");
+        }
+        const session = saveCodexLiveSession(toSessionState({
+            session_id: randomUUID(),
+            room_id: input.room_id,
+            room_identifier: input.room_identifier,
+            room_code: input.room_code ?? null,
+            room_display_name: input.room_display_name ?? null,
+            joined_via: input.joined_via,
+            cwd,
+            stop_phrase: stopPhrase,
+            max_minutes: maxMinutes,
+            deadline_utc: deadline.utc,
+            token,
+            thread_id: threadId,
+            turn_id: turnId,
+            server_url: serverUrl,
+            server_pid: serverPid,
+            launched_server: launchedServer,
+            codex_bin: codexBin,
+        }));
+        return { session, reused: false };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function stopLocalCodexSession(options) {
+    const session = options?.session_id
+        ? getStoredCodexLiveSession(options.session_id)
+        : getCurrentCodexLiveSession(options?.room_id ?? undefined);
+    if (!session) {
+        return null;
+    }
+    // Attempt to interrupt the turn via RPC, but gracefully handle a dead server.
+    const serverReachable = await isServerReady(session.server_url);
+    if (serverReachable) {
+        try {
+            const client = new RpcClient(session.server_url);
+            await client.connect();
+            try {
+                await client.request("turn/interrupt", {
+                    threadId: session.thread_id,
+                    turnId: session.turn_id,
+                });
+            }
+            finally {
+                client.close();
+            }
+        }
+        catch {
+            // Server may have died between the readiness check and the RPC call.
+        }
+    }
+    const updated = updateCodexLiveSession(session.session_id, (current) => ({
+        ...current,
+        status: "interrupted",
+        last_error: serverReachable ? null : "server unreachable at stop time",
+        updated_at: new Date().toISOString(),
+    })) ?? session;
+    if (options?.shutdown_server && updated.server_pid) {
+        try {
+            process.kill(updated.server_pid, "SIGTERM");
+            spawnedServerPids.delete(updated.server_pid);
+        }
+        catch {
+            // Process already dead — ignore.
+            spawnedServerPids.delete(updated.server_pid);
+        }
+    }
+    return updated;
+}

package/dist/mcp/config-reader.js

@@ -7,7 +7,7 @@
 // Parses the config and returns the room name if found.
 //
 // Config format:
-//   { "room": "github.com/EmmyMay/letagents" }
+//   { "room": "github.com/BrosInCode/letagents" }
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
 const CONFIG_FILENAME = ".letagents.json";

package/dist/mcp/git-remote.js

@@ -7,9 +7,9 @@
 //   host/owner/repo
 //
 // Examples:
-//   git@github.com:EmmyMay/letagents.git  → github.com/EmmyMay/letagents
-//   https://github.com/EmmyMay/letagents.git → github.com/EmmyMay/letagents
-//   https://github.com/EmmyMay/letagents → github.com/EmmyMay/letagents
+//   git@github.com:BrosInCode/letagents.git  → github.com/BrosInCode/letagents
+//   https://github.com/BrosInCode/letagents.git → github.com/BrosInCode/letagents
+//   https://github.com/BrosInCode/letagents → github.com/BrosInCode/letagents
 //   ssh://git@gitlab.com/team/project.git → gitlab.com/team/project
 import { execSync } from "child_process";
 /**

package/dist/mcp/local-state.js

@@ -226,3 +226,61 @@ export function touchRoomSession(roomId, lastMessageId) {
     });
     return updated;
 }
+export function getCurrentCodexLiveSession(roomId) {
+    const state = readLocalState();
+    const sessionIds = state.current_codex_live_session_ids;
+    if (!sessionIds) {
+        return null;
+    }
+    if (roomId) {
+        const sessionId = sessionIds[roomId];
+        return sessionId ? (state.codex_live_sessions?.[sessionId] ?? null) : null;
+    }
+    let best = null;
+    for (const id of Object.values(sessionIds)) {
+        const session = state.codex_live_sessions?.[id];
+        if (session && (!best || session.updated_at > best.updated_at)) {
+            best = session;
+        }
+    }
+    return best;
+}
+export function getStoredCodexLiveSession(sessionId) {
+    const state = readLocalState();
+    return state.codex_live_sessions?.[sessionId] ?? null;
+}
+export function listStoredCodexLiveSessions() {
+    const state = readLocalState();
+    return Object.values(state.codex_live_sessions ?? {}).sort((left, right) => right.updated_at.localeCompare(left.updated_at));
+}
+export function saveCodexLiveSession(session, makeCurrent = true) {
+    updateLocalState((state) => {
+        state.codex_live_sessions = state.codex_live_sessions ?? {};
+        state.codex_live_sessions[session.session_id] = session;
+        if (makeCurrent) {
+            state.current_codex_live_session_ids = state.current_codex_live_session_ids ?? {};
+            state.current_codex_live_session_ids[session.room_id] = session.session_id;
+        }
+        return state;
+    });
+    return session;
+}
+export function updateCodexLiveSession(sessionId, updater) {
+    let updatedSession = null;
+    updateLocalState((state) => {
+        const existing = state.codex_live_sessions?.[sessionId];
+        if (!existing) {
+            return state;
+        }
+        const updated = updater(existing);
+        state.codex_live_sessions = state.codex_live_sessions ?? {};
+        state.codex_live_sessions[sessionId] = updated;
+        state.current_codex_live_session_ids = state.current_codex_live_session_ids ?? {};
+        if (!state.current_codex_live_session_ids[updated.room_id]) {
+            state.current_codex_live_session_ids[updated.room_id] = sessionId;
+        }
+        updatedSession = updated;
+        return state;
+    });
+    return updatedSession;
+}

package/dist/mcp/server.js

@@ -11,9 +11,11 @@ import { SseClient } from "./sse-client.js";
 import { getRoomFromConfig } from "./config-reader.js";
 import { getGitRemoteIdentity } from "./git-remote.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 { clearPendingDeviceAuth, clearStoredAuth, getCurrentCodexLiveSession, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, listStoredCodexLiveSessions, 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";
+import { buildRoomAgentPrompt, normalizeAgentPromptKind, } from "../shared/room-agent-prompts.js";
+import { inspectLocalCodexSession, startLocalCodexSession, stopLocalCodexSession, toPublicCodexLiveSession, } from "./codex-session.js";
 let currentRoom = null;
 let currentAgentIdentityKey = "";
 let currentAgentIdentity = null;
@@ -746,6 +748,43 @@ function getLastMessageId(payload) {
     const lastMessage = messages?.at(-1);
     return typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
 }
+function withJoinRoomAgentPrompt(payload) {
+    return {
+        ...payload,
+        agent_prompt_kind: "join",
+        agent_prompt: buildRoomAgentPrompt("join"),
+    };
+}
+function normalizeJoinSessionMode(value) {
+    return String(value || "").trim().toLowerCase() === "live" ? "live" : "current";
+}
+function getCurrentLiveSessionPayload(roomId) {
+    const session = getCurrentCodexLiveSession(roomId);
+    return session ? toPublicCodexLiveSession(session) : null;
+}
+function toAgentReadableMessage(message) {
+    if (!message || typeof message !== "object") {
+        return message;
+    }
+    const record = message;
+    const kind = normalizeAgentPromptKind(record.agent_prompt_kind);
+    const text = typeof record.text === "string" ? record.text : null;
+    if (!kind || text === null) {
+        return record;
+    }
+    return {
+        ...record,
+        visible_text: text,
+        agent_prompt: buildRoomAgentPrompt(kind),
+        prompt_injected: kind === "inline",
+    };
+}
+function toAgentReadableMessages(messages) {
+    return (messages ?? []).map((message) => toAgentReadableMessage(message));
+}
+function appendIncludePromptOnly(path) {
+    return `${path}${path.includes("?") ? "&" : "?"}include_prompt_only=1`;
+}
 async function roomScopedApiCall(input) {
     if (input.room_id) {
         try {
@@ -877,18 +916,46 @@ async function createInviteRoom() {
         },
     };
 }
-async function joinInviteCode(code) {
+async function buildJoinResponse(input) {
+    const basePayload = await withAgentIdentity({
+        ...toPublicRoomResponse(input.joined.response, input.joined.room.room_id),
+        joined_via: input.joined_via,
+        session_mode: input.session_mode,
+    });
+    if (input.session_mode === "current") {
+        return withJoinRoomAgentPrompt(basePayload);
+    }
+    const liveSession = await startLocalCodexSession({
+        room_id: input.joined.room.room_id,
+        room_identifier: input.room_identifier,
+        room_code: input.joined.room.code ?? null,
+        room_display_name: input.joined.room.display_name ?? null,
+        joined_via: input.joined_via,
+        cwd: process.cwd(),
+    });
+    return withJoinRoomAgentPrompt({
+        ...basePayload,
+        local_codex_session: toPublicCodexLiveSession(liveSession.session),
+        local_codex_session_started: !liveSession.reused,
+        local_codex_session_reused: liveSession.reused,
+    });
+}
+async function joinInviteCode(code, sessionMode) {
     const joined = await joinRoomIdentifier(code, "join_code");
-    return withAgentIdentity({
-        ...toPublicRoomResponse(joined.response, joined.room.room_id),
+    return buildJoinResponse({
+        joined,
+        room_identifier: normalizeInviteCode(code),
         joined_via: "join_code",
+        session_mode: sessionMode,
     });
 }
-async function joinNamedRoom(name) {
+async function joinNamedRoom(name, sessionMode) {
     const joined = await joinRoomIdentifier(name, "join_room");
-    return withAgentIdentity({
-        ...toPublicRoomResponse(joined.response, joined.room.room_id),
+    return buildJoinResponse({
+        joined,
+        room_identifier: name.trim(),
         joined_via: "join_room",
+        session_mode: sessionMode,
     });
 }
 // ---------------------------------------------------------------------------
@@ -919,8 +986,8 @@ server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_i
         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}` : ""}`,
+            room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`),
+            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`),
         });
         const msgs = result.messages ?? [];
         allMessages.push(...msgs);
@@ -936,7 +1003,7 @@ server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_i
             {
                 uri: uri.href,
                 mimeType: "application/json",
-                text: JSON.stringify({ messages: allMessages }, null, 2),
+                text: JSON.stringify({ messages: toAgentReadableMessages(allMessages) }, null, 2),
             },
         ],
     };
@@ -948,7 +1015,7 @@ server.tool("create_room", "Create a new invite room on Let Agents Chat. Returns
         content: [
             {
                 type: "text",
-                text: JSON.stringify(created.response, null, 2),
+                text: JSON.stringify(withJoinRoomAgentPrompt(created.response), null, 2),
             },
         ],
     };
@@ -960,7 +1027,7 @@ server.tool("create_project", "Legacy alias for create_room. Creates a new invit
         content: [
             {
                 type: "text",
-                text: JSON.stringify(created.response, null, 2),
+                text: JSON.stringify(withJoinRoomAgentPrompt(created.response), null, 2),
             },
         ],
     };
@@ -968,12 +1035,16 @@ server.tool("create_project", "Legacy alias for create_room. Creates a new invit
 // -- join_code --------------------------------------------------------------
 server.tool("join_code", "Join an existing room using an invite code.", {
     code: z.string().describe("The invite code shared for the room (e.g. 'ABCX-7291')"),
-}, async ({ code }) => {
+    session_mode: z
+        .enum(["live", "current"])
+        .optional()
+        .describe("Use 'current' (default) for a normal inline join. Use 'live' to start/reuse a detached local Codex room worker."),
+}, async ({ code, session_mode }) => {
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(await joinInviteCode(code), null, 2),
+                text: JSON.stringify(await joinInviteCode(code, normalizeJoinSessionMode(session_mode)), null, 2),
             },
         ],
     };
@@ -981,12 +1052,16 @@ server.tool("join_code", "Join an existing room using an invite code.", {
 // -- join_project -----------------------------------------------------------
 server.tool("join_project", "Legacy alias for join_code. Join an existing room using an invite code.", {
     code: z.string().describe("The invite code shared for the room (e.g. 'ABCX-7291')"),
-}, async ({ code }) => {
+    session_mode: z
+        .enum(["live", "current"])
+        .optional()
+        .describe("Use 'current' (default) for a normal inline join. Use 'live' to start/reuse a detached local Codex room worker."),
+}, async ({ code, session_mode }) => {
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(await joinInviteCode(code), null, 2),
+                text: JSON.stringify(await joinInviteCode(code, normalizeJoinSessionMode(session_mode)), null, 2),
             },
         ],
     };
@@ -994,13 +1069,77 @@ server.tool("join_project", "Legacy alias for join_code. Join an existing room u
 // -- join_room --------------------------------------------------------------
 server.tool("join_room", "Join a named room on Let Agents Chat. Creates the room if it doesn't exist. Use this for repo-based room joining.", {
     name: z.string().describe("The room name to join (e.g. 'github.com/owner/repo')"),
-}, async ({ name }) => {
+    session_mode: z
+        .enum(["live", "current"])
+        .optional()
+        .describe("Use 'current' (default) for a normal inline join. Use 'live' to start/reuse a detached local Codex room worker."),
+}, async ({ name, session_mode }) => {
+    try {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(await joinNamedRoom(name, normalizeJoinSessionMode(session_mode)), null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof RepoRoomAuthRequiredError) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(toRepoRoomAuthRequiredResult(error), null, 2),
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+});
+// -- local Codex live sessions ---------------------------------------------
+server.tool("start_local_codex_session", "Start or reuse a detached local Codex live session for a LetAgents room. The worker will join the room, keep polling, contribute in discussion, and do repo work from the current working directory when asked.", {
+    room: z
+        .string()
+        .describe("Invite code or room name to run as a detached local Codex worker."),
+    cwd: z
+        .string()
+        .optional()
+        .describe("Working directory for repo work. Defaults to the current process directory."),
+    stop_phrase: z
+        .string()
+        .optional()
+        .describe("Exact room message text that tells the worker to stop. Defaults to /stop-codex-room."),
+    max_minutes: z
+        .number()
+        .optional()
+        .describe("Optional hard stop in minutes. Defaults to 0, which means run until stopped."),
+}, async ({ room, cwd, stop_phrase, max_minutes }) => {
+    const joinedVia = looksLikeInviteCode(room) ? "join_code" : "join_room";
     try {
+        const joined = await joinRoomIdentifier(room, joinedVia);
+        const liveSession = await startLocalCodexSession({
+            room_id: joined.room.room_id,
+            room_identifier: joinedVia === "join_code" ? normalizeInviteCode(room) : room.trim(),
+            room_code: joined.room.code ?? null,
+            room_display_name: joined.room.display_name ?? null,
+            joined_via: joinedVia,
+            cwd: cwd || process.cwd(),
+            stop_phrase,
+            max_minutes,
+        });
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(await joinNamedRoom(name), null, 2),
+                    text: JSON.stringify(await withAgentIdentity({
+                        success: true,
+                        room: toPublicRoomState(joined.room),
+                        local_codex_session: toPublicCodexLiveSession(liveSession.session),
+                        local_codex_session_started: !liveSession.reused,
+                        local_codex_session_reused: liveSession.reused,
+                    }), null, 2),
                 },
             ],
         };
@@ -1019,6 +1158,76 @@ server.tool("join_room", "Join a named room on Let Agents Chat. Creates the room
         throw error;
     }
 });
+server.tool("status_local_codex_session", "Inspect the current detached local Codex live session, or a specific one by session_id.", {
+    session_id: z
+        .string()
+        .optional()
+        .describe("Optional session id. Defaults to the current local Codex live session."),
+}, async ({ session_id }) => {
+    const status = await inspectLocalCodexSession(session_id, currentRoom?.room_id);
+    if (!status) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "No local Codex live session found." }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    session: toPublicCodexLiveSession(status.session),
+                    server_reachable: status.server_reachable,
+                    thread_status: status.thread_status,
+                    turn_status: status.turn_status,
+                    recent_items: status.recent_items,
+                }, null, 2),
+            },
+        ],
+    };
+});
+server.tool("stop_local_codex_session", "Stop the current detached local Codex live session, or a specific one by session_id.", {
+    session_id: z
+        .string()
+        .optional()
+        .describe("Optional session id. Defaults to the current local Codex live session."),
+    shutdown_server: z
+        .boolean()
+        .optional()
+        .describe("If true, also terminate the spawned codex app-server process when possible."),
+}, async ({ session_id, shutdown_server }) => {
+    const stopped = await stopLocalCodexSession({
+        session_id,
+        room_id: currentRoom?.room_id,
+        shutdown_server,
+    });
+    if (!stopped) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "No local Codex live session found." }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    session: toPublicCodexLiveSession(stopped),
+                }, null, 2),
+            },
+        ],
+    };
+});
 // -- get_current_room -------------------------------------------------------
 server.tool("get_current_room", "Get information about the currently joined room, including how it was joined.", {
     conversation_id: z
@@ -1031,9 +1240,11 @@ server.tool("get_current_room", "Get information about the currently joined room
             {
                 type: "text",
                 text: JSON.stringify(currentRoom
-                    ? {
+                    ? withJoinRoomAgentPrompt({
                         connected: true,
                         ...toPublicRoomState(currentRoom),
+                        current_local_codex_session: getCurrentLiveSessionPayload(currentRoom.room_id),
+                        local_codex_session_count: listStoredCodexLiveSessions().length,
                         agent_identity: toPublicAgentIdentity(getConversationIdentity(conversation_id)
                             ?? currentAgentIdentity
                             ?? getStoredAgentIdentity(currentAgentIdentityKey)),
@@ -1044,8 +1255,13 @@ server.tool("get_current_room", "Get information about the currently joined room
                                 account: getStoredAuth()?.account ?? null,
                             }
                             : null,
-                    }
-                    : { connected: false, message: "Not currently in any room" }, null, 2),
+                    })
+                    : {
+                        connected: false,
+                        message: "Not currently in any room",
+                        current_local_codex_session: getCurrentLiveSessionPayload(), // no room context
+                        local_codex_session_count: listStoredCodexLiveSessions().length,
+                    }, null, 2),
             },
         ],
     };
@@ -1601,8 +1817,8 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
         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}` : ""}`,
+            room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`),
+            project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages${qs ? `?${qs}` : ""}`),
         });
         roomIdFromResponse = roomIdFromResponse || result.room_id || result.project_id;
         const msgs = result.messages ?? [];
@@ -1615,7 +1831,7 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
             break;
         afterCursor = lastMsg.id;
     }
-    const output = { messages: allMessages };
+    const output = { messages: toAgentReadableMessages(allMessages) };
     if (roomIdFromResponse) {
         output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
     }
@@ -1654,8 +1870,8 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
     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}`,
+        room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
+        project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
         options: { signal: AbortSignal.timeout(clientTimeout) },
     });
     const allMessages = [...(firstResult.messages ?? [])];
@@ -1670,8 +1886,8 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
             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}`,
+                room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages?${qs}`),
+                project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages?${qs}`),
             });
             const msgs = page.messages ?? [];
             allMessages.push(...msgs);
@@ -1682,7 +1898,7 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
                 break;
         }
     }
-    const output = { messages: allMessages };
+    const output = { messages: toAgentReadableMessages(allMessages) };
     if (roomIdFromResponse) {
         output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
     }
@@ -2068,14 +2284,14 @@ server.tool("resume_room_session", "Rejoin the last locally saved room context,
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({
+                    text: JSON.stringify(withJoinRoomAgentPrompt({
                         success: true,
                         rejoined_from_local_state: true,
                         server_session_resumed: false,
                         last_message_id_before_restart: savedRoom.last_message_id ?? null,
                         room: toPublicRoomState(joined.room),
                         agent_identity: toPublicAgentIdentity(agentIdentity),
-                    }, null, 2),
+                    }), null, 2),
                 },
             ],
         };

package/dist/mcp/sse-client.js

@@ -1,4 +1,5 @@
 import { encodeRoomIdPath } from "./room-id.js";
+import { buildRoomAgentPrompt, normalizeAgentPromptKind } from "../shared/room-agent-prompts.js";
 export class SseClient {
     apiUrl;
     getAccessToken;
@@ -53,7 +54,7 @@ export class SseClient {
     }
     async consumeStream(target, signal, onMessage) {
         try {
-            await this.openStream(`${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`, signal, onMessage);
+            await this.openStream(this.withIncludePromptOnly(`${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`), signal, onMessage);
             return;
         }
         catch (error) {
@@ -61,7 +62,10 @@ export class SseClient {
                 throw error;
             }
         }
-        await this.openStream(`${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`, signal, onMessage);
+        await this.openStream(this.withIncludePromptOnly(`${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`), signal, onMessage);
+    }
+    withIncludePromptOnly(url) {
+        return `${url}${url.includes("?") ? "&" : "?"}include_prompt_only=1`;
     }
     async openStream(url, signal, onMessage) {
         const response = await fetch(url, {
@@ -105,7 +109,19 @@ export class SseClient {
         if (dataLines.length === 0) {
             return;
         }
-        onMessage(JSON.parse(dataLines.join("\n")));
+        onMessage(this.enrichPromptMetadata(JSON.parse(dataLines.join("\n"))));
+    }
+    enrichPromptMetadata(message) {
+        const kind = normalizeAgentPromptKind(message.agent_prompt_kind);
+        if (!kind) {
+            return message;
+        }
+        return {
+            ...message,
+            visible_text: message.text,
+            agent_prompt: buildRoomAgentPrompt(kind),
+            prompt_injected: kind === "inline",
+        };
     }
     isMissingRouteError(error) {
         return (error instanceof Error &&

package/dist/shared/room-agent-prompts.js

@@ -0,0 +1,25 @@
+// TODO: make room agent prompts configurable per room/project instead of hardcoded
+// constants. The current behavior is intentionally global across rooms.
+const BASE_ROOM_AGENT_PROMPT = "Stay in this room continuously. Keep long-polling for new messages. When messages arrive, read them immediately, act on anything actionable, help with review work when asked, and keep monitoring until the human explicitly redirects you. Do not send a visible 'keep polling' acknowledgement unless the human explicitly asks for that phrase.";
+export function buildRoomAgentPrompt(kind) {
+    if (kind === "join") {
+        return `You just joined this room. ${BASE_ROOM_AGENT_PROMPT}`;
+    }
+    if (kind === "auto") {
+        return `Background reminder. ${BASE_ROOM_AGENT_PROMPT}`;
+    }
+    return `Treat the visible user message above as the active instruction. After you handle it, ${BASE_ROOM_AGENT_PROMPT}`;
+}
+export function normalizeAgentPromptKind(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "join" || normalized === "inline" || normalized === "auto") {
+        return normalized;
+    }
+    return null;
+}
+export function isPromptOnlyAgentMessage(text, kind) {
+    return normalizeAgentPromptKind(kind) === "auto" && !String(text || "").trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -14,6 +14,8 @@
   ],
   "scripts": {
     "build": "tsc",
+    "build:web": "cd src/web && npm install && npx vite build",
+    "build:all": "npm run build && npm run build:web",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "tsx src/api/migrate.ts",
     "db:studio": "drizzle-kit studio",
@@ -30,9 +32,9 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/EmmyMay/letagents.git"
+    "url": "https://github.com/BrosInCode/letagents.git"
   },
-  "license": "MIT",
+  "license": "BUSL-1.1",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
     "drizzle-orm": "^0.45.1",