letagents 0.12.11 → 0.12.12

package/dist/mcp/server/tools/rooms/inspection-tools.js

@@ -3,7 +3,7 @@ import { join } from "path";
 import { z } from "zod";
 import { getRoomFromConfig } from "../../../config-reader.js";
 import { buildActiveGitRoomContext, getGitCurrentBranch, getGitDefaultBranch, getGitRoomContext, } from "../../../git-remote.js";
-import { currentAgentIdentity, currentAgentIdentityKey, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
+import { currentAgentIdentity, currentAgentIdentityKey, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicCurrentRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
 import { requireValidWorkerBearerRuntime } from "../../runtime/worker-bearer.js";
 import { findExistingConfig, resolveGitRoot, } from "../../repo-context.js";
 import { jsonToolResponse } from "./response.js";
@@ -29,16 +29,17 @@ export function registerRoomInspectionTools(server) {
 }
 export async function getCurrentRoomPayload(conversationId) {
     const runtime = requireValidWorkerBearerRuntime();
-    const workerAuth = runtime.mode === "worker"
-        ? { source: "worker_bearer", expires_at: null, account: null }
+    const publicCurrentRoom = toPublicCurrentRoomState();
+    const workerAuth = runtime.mode !== "owner"
+        ? { source: runtime.mode === "worker" ? "worker_bearer" : "daemon_supervised", expires_at: null, account: null }
         : null;
-    const localCodexDetails = runtime.mode === "worker"
+    const localCodexDetails = runtime.mode !== "owner"
         ? { current_local_codex_session: null, local_codex_session_count: 0 }
         : {
             current_local_codex_session: getCurrentLiveSessionPayload(currentRoom?.room_id),
             local_codex_session_count: listStoredCodexLiveSessions().length,
         };
-    if (!currentRoom) {
+    if (!publicCurrentRoom) {
         return {
             connected: false,
             message: "Not currently in any room",
@@ -46,12 +47,13 @@ export async function getCurrentRoomPayload(conversationId) {
             ...(workerAuth ? { auth: workerAuth } : {}),
         };
     }
-    const auth = runtime.mode === "worker"
+    const auth = runtime.mode !== "owner"
         ? null
         : (await ownerAuthStoreLoader()).getStoredAuth();
-    return withJoinRoomAgentPrompt({
+    const payload = {
         connected: true,
-        ...toPublicRoomState(currentRoom),
+        ...publicCurrentRoom,
+        ...(runtime.mode === "supervised" ? { room_binding: "daemon_supervised" } : {}),
         ...localCodexDetails,
         agent_identity: toPublicAgentIdentity(getConversationIdentity(conversationId)
             ?? currentAgentIdentity
@@ -63,9 +65,14 @@ export async function getCurrentRoomPayload(conversationId) {
                 account: auth.account ?? null,
             }
             : null),
-    });
+    };
+    // A daemon-supervised worker is already bound to its exact authorized room.
+    // A normal join prompt is both false and dangerous here because it can lead
+    // the provider to request an unrelated room move.
+    return runtime.mode === "supervised" ? payload : withJoinRoomAgentPrompt(payload);
 }
 function getRepoInspectionPayload(targetDir) {
+    const runtime = requireValidWorkerBearerRuntime();
     const startDir = targetDir || process.cwd();
     const repoRoot = resolveGitRoot(startDir);
     const configDir = repoRoot ? findExistingConfig(startDir) : null;
@@ -95,10 +102,16 @@ function getRepoInspectionPayload(targetDir) {
         git_current_branch: gitContext?.currentBranch ?? configGitContext?.currentBranch ?? null,
         git_default_branch: gitContext?.defaultBranch ?? configGitContext?.defaultBranch ?? null,
         detected_room_from_context: detectedRoom ?? null,
-        current_room: toPublicRoomState(currentRoom),
-        current_room_scope: currentRoomScope(currentRoomMatchesContext, detectedRoom),
-        warning: repoWarning({ repoRoot, detectedRoom, currentRoomMatchesContext }),
-        join_hint: joinHint({ repoRoot, detectedRoom, currentRoomMatchesContext }),
+        current_room: toPublicCurrentRoomState(),
+        current_room_scope: runtime.mode === "supervised"
+            ? "daemon_supervised_exact_room"
+            : currentRoomScope(currentRoomMatchesContext, detectedRoom),
+        warning: runtime.mode === "supervised"
+            ? null
+            : repoWarning({ repoRoot, detectedRoom, currentRoomMatchesContext }),
+        join_hint: runtime.mode === "supervised"
+            ? null
+            : joinHint({ repoRoot, detectedRoom, currentRoomMatchesContext }),
     };
 }
 function readConfigContents(configPath) {

package/dist/mcp/server/tools/supervised-room-turn.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+const MAX_ROOM_REPLY_BYTES = 32 * 1024;
+function completionResponse(outcome) {
+    const payload = {
+        accepted: true,
+        outcome,
+        instruction: "The daemon recorded this exact turn completion. End the provider turn without sending the activating reply through another tool.",
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+/**
+ * Cursor's documented terminal `result` is the concatenation of every
+ * assistant delta, including progress narration. A supervised provider must
+ * therefore propose its public reply over a distinct, turn-scoped channel.
+ *
+ * This tool is registered only for `supervised_room_turn`. The normal
+ * supervised tool facade binds it to the exact provider turn and commits its
+ * request/result through the durable bounded-effect journal before the daemon
+ * will consider it publishable.
+ */
+export function registerSupervisedRoomTurnTools(server) {
+    server.tool("complete_room_turn", "Record the single public completion for this supervised room turn. Call exactly once after all work is finished. Progress text outside this tool is live activity only and is never published as the room reply.", {
+        outcome: z.enum(["reply", "no_reply"]).describe("Use reply to publish one answer, or no_reply when the activating message needs no response."),
+        text: z.string().optional().describe("The concise public room reply. Required only when outcome is reply."),
+    }, async ({ outcome, text }) => {
+        const normalized = text?.trim() ?? "";
+        if (outcome === "reply") {
+            if (!normalized)
+                throw new Error("complete_room_turn requires non-empty text when outcome is reply.");
+            if (Buffer.byteLength(normalized, "utf8") > MAX_ROOM_REPLY_BYTES) {
+                throw new Error("complete_room_turn reply exceeds the 32 KiB public-message limit.");
+            }
+        }
+        else if (normalized) {
+            throw new Error("complete_room_turn must omit text when outcome is no_reply.");
+        }
+        return completionResponse(outcome);
+    });
+}

package/dist/mcp/server.js

@@ -5,14 +5,21 @@ import { registerRoomResources } from "./server/resources.js";
 import { registerTools } from "./server/register-tools.js";
 import { attachMcpServer, autoJoinFromContext, shutdownRuntime } from "./server/runtime.js";
 import { requireValidWorkerBearerRuntime } from "./server/runtime/worker-bearer.js";
-const server = new McpServer({
-    name: "letagents",
-    version: "0.2.0",
-});
-attachMcpServer(server);
-registerRoomResources(server);
-registerTools(server);
+import { executionProfile } from "./server/runtime/execution-profile.js";
+import { LETAGENTS_RUNTIME_CONTRACT_ARG, letAgentsRuntimeContract, } from "./server/runtime-contract.js";
 async function main() {
+    if (process.argv.slice(2).includes(LETAGENTS_RUNTIME_CONTRACT_ARG)) {
+        process.stdout.write(`${JSON.stringify(letAgentsRuntimeContract())}\n`);
+        return;
+    }
+    const server = new McpServer({
+        name: "letagents",
+        version: "0.2.0",
+    });
+    attachMcpServer(server);
+    registerRoomResources(server);
+    const profile = executionProfile();
+    registerTools(server, profile);
     requireValidWorkerBearerRuntime();
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/shared/activation-routing.js

@@ -33,6 +33,50 @@ export function attachAgentMessageActivation(message, identity, context = {}) {
         },
     };
 }
+/**
+ * Send-time receipts are the activation authority. For a snapshot-bearing
+ * message, a receipt activates and the absence of one is the durable
+ * send-time "silent" — never re-promoted by re-running the router against
+ * later task/thread/session state, which would create a second authority.
+ * Only messages that predate routing snapshots keep the lazy per-reader
+ * decision, so legacy backlog mentions still activate rotated sessions.
+ */
+export function attachAgentMessageActivationsFromReceipts(messages, identity, receiptsMap, snapshotNumbers, context = {}) {
+    if (!identity || identity.session_kind !== "worker") {
+        return [...messages];
+    }
+    return messages.map((message) => {
+        const msgIdStr = String(message.id ?? "");
+        const msgNum = parseInt(msgIdStr.replace(/^msg_/, ""), 10);
+        const receipt = !isNaN(msgNum) ? receiptsMap.get(msgNum) || receiptsMap.get(msgIdStr) : null;
+        if (receipt) {
+            const reason = receipt.activation_reason;
+            return {
+                ...message,
+                activation: {
+                    for_current_agent: {
+                        decision: "activate",
+                        reason: reason || "explicit_mention",
+                        addressed: true,
+                    },
+                },
+            };
+        }
+        if (!isNaN(msgNum) && snapshotNumbers.has(msgNum)) {
+            return {
+                ...message,
+                activation: {
+                    for_current_agent: {
+                        decision: "silent",
+                        reason: "unaddressed",
+                        addressed: false,
+                    },
+                },
+            };
+        }
+        return attachAgentMessageActivation(message, identity, context);
+    });
+}
 export function attachAgentMessageActivations(messages, identity, context = {}) {
     if (!identity || identity.session_kind !== "worker") {
         return [...messages];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.11",
+  "version": "0.12.12",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -62,8 +62,12 @@
     "ws": "8.21.0"
   },
   "overrides": {
+    "@hono/node-server": "2.0.10",
     "@esbuild-kit/core-utils": {
       "esbuild": "^0.25.12"
-    }
+    },
+    "fast-uri": "3.1.5",
+    "hono": "4.12.34",
+    "ip-address": "10.3.1"
   }
 }