letagents 0.12.26 → 0.12.28

package/dist/mcp/codex-session/session-start.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import { resolve } from "path";
+import { CODEX_THREAD_HISTORY_MODE } from "../../../shared/codex-thread-history.mjs";
 import { getCurrentCodexLiveSession, getStoredCodexLiveSession, saveCodexLiveSession, updateCodexLiveSession, } from "../local-state.js";
 import { getGitCurrentBranch } from "../git-remote.js";
 import { isServerReady, launchAppServer, resolveCodexServerUrl, terminateSpawnedProcess, waitForServer, } from "./app-server.js";
@@ -109,7 +110,7 @@ export async function startLocalCodexSession(input) {
             });
         });
         await client.connect();
-        const threadStart = await client.request("thread/start", {});
+        const threadStart = await client.request("thread/start", { historyMode: CODEX_THREAD_HISTORY_MODE });
         const threadId = threadStart.thread?.id;
         if (!threadId) {
             throw new Error("Codex app-server did not return a thread id.");

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

@@ -7,7 +7,7 @@ import { registerOnboardingTools } from "./tools/onboarding.js";
 import { registerRentalTools } from "./tools/rental.js";
 import { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./tools/rooms.js";
 import { registerTaskTools } from "./tools/tasks.js";
-import { registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
+import { registerReplyThreadTool, registerSupervisedRoomTurnTools } from "./tools/supervised-room-turn.js";
 import { toolSurfaceForExecutionProfile } from "./runtime/tool-surface-policy.js";
 import { profileAwareToolServer } from "./supervised-tool-facade.js";
 import { workerAwareToolServer } from "./worker-tool-facade.js";
@@ -46,6 +46,8 @@ export function registerTools(server, profile = "autonomous_mcp_worker", supervi
     registerTaskTools(tools);
     registerRepoInitializationTool(tools);
     registerMessageTools(tools, { includeDeliveryLoop: surface.deliveryLoop });
+    if (profile === "supervised_room_turn")
+        registerReplyThreadTool(tools);
     if (profile === "supervised_room_turn" && supervisedProvider === "cursor")
         registerSupervisedRoomTurnTools(tools);
     if (surface.onboarding)

package/dist/mcp/server/runtime/supervisor-bridge.js

@@ -9,6 +9,9 @@ import { getCurrentSupervisedRoomAuthority } from "./supervised-room-authority.j
 const NEGOTIATION_PROTOCOL_VERSION = 1;
 const SUPPORTED_SUPERVISOR_PROTOCOL_VERSIONS = new Set([1, 2, 3]);
 const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+// A signed desktop update can leave the socket absent for roughly 20 seconds.
+// Only unsent operations receive this startup grace; it never permits replay.
+const SUPERVISED_STARTUP_TIMEOUT_MS = 30_000;
 const CONFIRMED_BINDING_VERIFY_TIMEOUT_MS = 250;
 const SUPERVISOR_CONTEXT_FILE = ".letagents-supervisor-context.json";
 const WORK_ATTEMPT_MARKER_FILE = ".letagents-work-attempt.json";
@@ -95,26 +98,9 @@ const activeCursorCheckpointDrains = new Set();
 const cursorCheckpointRetryTimers = new Map();
 const CURSOR_CHECKPOINT_RETRY_DELAYS_MS = [250, 1_000, 3_000];
 export async function executeCurrentSupervisedTool(input, env = process.env, options = {}) {
-    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
-    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    const negotiated = await negotiateSupervisor(coordinates.socketPath, timeoutMs);
-    if (negotiated.generation === null)
-        throw new Error("The supervised daemon generation is unavailable.");
-    const response = await supervisorRequest(coordinates.socketPath, {
-        version: negotiated.protocolVersion,
-        id: randomUUID(),
-        method: "supervisor.execute_bounded_tool",
-        params: {
-            entry_id: coordinates.entryId,
-            work_attempt_id: coordinates.workAttemptId,
-            execution_generation_id: coordinates.executionGenerationId,
-            ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
-            daemon_generation: negotiated.generation,
-            mcp_request_id: input.mcpRequestId,
-            tool_name: input.toolName,
-            input: input.input,
-        },
-    }, null);
+    const response = await requestCurrentSupervisedOperation("supervisor.execute_bounded_tool", {
+        mcp_request_id: input.mcpRequestId, tool_name: input.toolName, input: input.input,
+    }, env, options);
     if (!response.ok) {
         if (/Unsupported daemon method:\s*supervisor\.execute_bounded_tool/i.test(response.error ?? "")) {
             return { state: "unsupported" };
@@ -131,27 +117,9 @@ export async function executeCurrentSupervisedTool(input, env = process.env, opt
     return { state: "completed", roomId, result: result.result };
 }
 export async function prepareCurrentSupervisedEffect(input, env = process.env, options = {}) {
-    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
-    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    const negotiated = await negotiateSupervisor(coordinates.socketPath, timeoutMs);
-    if (negotiated.generation === null)
-        throw new Error("The supervised daemon generation is unavailable.");
-    const response = await supervisorRequest(coordinates.socketPath, {
-        version: negotiated.protocolVersion,
-        id: randomUUID(),
-        method: "supervisor.prepare_bounded_effect",
-        params: {
-            entry_id: coordinates.entryId,
-            work_attempt_id: coordinates.workAttemptId,
-            execution_generation_id: coordinates.executionGenerationId,
-            ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
-            daemon_generation: negotiated.generation,
-            mcp_request_id: input.mcpRequestId,
-            tool_name: input.toolName,
-            input: input.input,
-            mutation: input.mutation,
-        },
-    }, timeoutMs);
+    const response = await requestCurrentSupervisedOperation("supervisor.prepare_bounded_effect", {
+        mcp_request_id: input.mcpRequestId, tool_name: input.toolName, input: input.input, mutation: input.mutation,
+    }, env, options);
     if (!response.ok)
         throw new Error(response.error || "The supervised effect was rejected.");
     const result = response.result && typeof response.result === "object" ? response.result : {};
@@ -184,6 +152,50 @@ export async function prepareCurrentSupervisedEffect(input, env = process.env, o
     }
     throw new Error("The supervised effect journal returned an unsupported action.");
 }
+async function requestCurrentSupervisedOperation(method, params, env, options) {
+    // Keep the original invocation and authority across an unlink-to-listen gap.
+    const invocation = JSON.parse(JSON.stringify(params));
+    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
+    const requestId = randomUUID();
+    const deadline = Date.now() + (options.requestTimeoutMs ?? SUPERVISED_STARTUP_TIMEOUT_MS);
+    let retryAttempt = 0;
+    while (true) {
+        let negotiated;
+        try {
+            negotiated = await negotiateSupervisor(coordinates.socketPath, remainingRequestTimeout(deadline));
+        }
+        catch (error) {
+            // Negotiation is read-only; no operation has been sent at this point.
+            if (!(error instanceof SupervisorTransportError) || !isRetryableSupervisorBridgeError(error)
+                || !await waitForCompletionHandoffRetry(deadline, retryAttempt++))
+                throw error;
+            continue;
+        }
+        if (negotiated.generation === null)
+            throw new Error("The supervised daemon generation is unavailable.");
+        try {
+            return await supervisorRequest(coordinates.socketPath, {
+                version: negotiated.protocolVersion, id: requestId, method,
+                params: {
+                    ...invocation,
+                    entry_id: coordinates.entryId,
+                    work_attempt_id: coordinates.workAttemptId,
+                    execution_generation_id: coordinates.executionGenerationId,
+                    ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
+                    daemon_generation: negotiated.generation,
+                },
+            }, method === "supervisor.execute_bounded_tool" ? null : remainingRequestTimeout(deadline), remainingRequestTimeout(deadline));
+        }
+        catch (error) {
+            // Once a write begins, failure is ambiguous. Never replay an operation,
+            // even when its error looks like a transient daemon restart.
+            if (!(error instanceof SupervisorTransportError) || error.writeAttempted
+                || !isRetryableSupervisorBridgeError(error)
+                || !await waitForCompletionHandoffRetry(deadline, retryAttempt++))
+                throw error;
+        }
+    }
+}
 export async function completeCurrentSupervisedEffect(input, env = process.env, options = {}) {
     const coordinates = await requireCurrentSupervisedCoordinates(env, options);
     const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
@@ -811,27 +823,44 @@ async function negotiateSupervisor(socketPath, timeoutMs) {
         custodialPollingV1: result.capabilities?.custodialPollingV1 === true,
         custodialPollingOffersV1: result.capabilities?.custodialPollingOffersV1 === true };
 }
-function supervisorRequest(socketPath, request, timeoutMs) {
+class SupervisorTransportError extends Error {
+    writeAttempted;
+    code;
+    constructor(error, writeAttempted) {
+        super(error.message, { cause: error });
+        this.writeAttempted = writeAttempted;
+        this.code = error.code;
+    }
+}
+function supervisorRequest(socketPath, request, timeoutMs, connectTimeoutMs = null) {
     return new Promise((resolve, reject) => {
+        const encoded = `${JSON.stringify(request)}\n`;
         const socket = createConnection(socketPath);
         let buffer = "";
         let finished = false;
-        const timer = timeoutMs === null ? null : setTimeout(() => {
-            socket.destroy();
-            finish(() => reject(new Error("Timed out communicating with the supervisor daemon.")));
-        }, timeoutMs);
-        timer?.unref();
+        let writeAttempted = false;
         const finish = (operation) => {
             if (finished)
                 return;
             finished = true;
             if (timer)
                 clearTimeout(timer);
+            if (connectTimer)
+                clearTimeout(connectTimer);
             operation();
         };
+        const failTransport = (error) => finish(() => reject(new SupervisorTransportError(error, writeAttempted)));
+        const timeout = () => {
+            failTransport(new Error("Timed out communicating with the supervisor daemon."));
+            socket.destroy();
+        };
+        const timer = timeoutMs === null ? null : setTimeout(timeout, timeoutMs);
+        const connectTimer = connectTimeoutMs === null ? null : setTimeout(timeout, connectTimeoutMs);
+        timer?.unref();
+        connectTimer?.unref();
         socket.setEncoding("utf8");
-        socket.once("error", (error) => finish(() => reject(error)));
-        socket.once("close", () => finish(() => reject(new Error("Supervisor connection closed before a response."))));
+        socket.once("error", failTransport);
+        socket.once("close", () => failTransport(new Error("Supervisor connection closed before a response.")));
         socket.on("data", (chunk) => {
             buffer += chunk;
             const newline = buffer.indexOf("\n");
@@ -848,6 +877,19 @@ function supervisorRequest(socketPath, request, timeoutMs) {
                 finish(() => reject(error));
             }
         });
-        socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+        socket.once("connect", () => {
+            if (finished)
+                return;
+            if (connectTimer)
+                clearTimeout(connectTimer);
+            writeAttempted = true;
+            try {
+                socket.write(encoded);
+            }
+            catch (error) {
+                failTransport(error instanceof Error ? error : new Error(String(error)));
+                socket.destroy();
+            }
+        });
     });
 }

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

@@ -1,5 +1,12 @@
 import { z } from "zod";
 const MAX_ROOM_REPLY_BYTES = 32 * 1024;
+/** Select routing only; the daemon remains the sole final-answer publisher. */
+export function registerReplyThreadTool(server) {
+    const tool = server.tool("set_reply_thread", "Place your final answer in the activating room message's thread. Takes no arguments, sends no message, and does not finish the turn. Continue working and use your normal final completion when ready. Unavailable for synthetic task continuations or corrections.", {}, async () => { throw new Error("set_reply_thread requires the active daemon-owned room turn."); });
+    // The legacy raw-shape overload strips unknown keys. Preserve a strict schema
+    // so a caller cannot mistake ignored room/recipient/text arguments for authority.
+    tool.inputSchema = z.object({}).strict();
+}
 function completionResponse(outcome) {
     const payload = {
         accepted: true,

package/package.json

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

package/shared/codex-thread-history.d.mts

@@ -0,0 +1 @@
+export const CODEX_THREAD_HISTORY_MODE: "legacy";

package/shared/codex-thread-history.mjs

@@ -0,0 +1,4 @@
+// Attachment and recovery require readable native turn history. Codex 0.153.4
+// can default to paginated threads whose history API is unavailable. Select
+// the verified contract only for creation; never reinterpret an existing thread.
+export const CODEX_THREAD_HISTORY_MODE = "legacy";

package/shared/local-supervised-tools.mjs

@@ -16,8 +16,8 @@ export function localSupervisedRoomToolOperation(name) {
 }
 
 export function localSupervisedRoomToolAvailable(name) {
-  // Cursor completion is handled by the daemon. Local room moves are unsupported.
-  return name === "complete_room_turn" || localSupervisedRoomToolOperation(name) !== null;
+  // Turn controls are handled by the daemon. Local room moves are unsupported.
+  return name === "complete_room_turn" || name === "set_reply_thread" || localSupervisedRoomToolOperation(name) !== null;
 }
 
 export function defineLocalSupervisedToolHandlers(handlers) {