letagents 0.12.27 → 0.12.29

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/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/tasks/board-intent-tools.js

@@ -170,7 +170,7 @@ export function registerBoardIntentTools(server) {
             return taskToolError(String(error));
         }
     });
-    server.tool("register_task_claim_intent", "Register intent to claim an accepted task as the current worker. Use the returned approval with claim_task.", {
+    server.tool("register_task_claim_intent", "Register intent to claim an accepted task as the current worker. Manager approval assigns the task and work lease immediately for authenticated workers; no second claim_task call is needed. Follow requires_follow_up only for legacy approvals.", {
         task_id: z.string().describe("Task id to claim, e.g. task_12."),
         ...workerTaskIdentitySchema,
     }, async ({ task_id, room_id, conversation_id: _conversation_id, agent_session_id }) => {
@@ -277,7 +277,7 @@ export function registerBoardIntentTools(server) {
             return taskToolError(String(error));
         }
     });
-    server.tool("approve_board_intent", "Approve a pending board intent. For task_create intents this creates the task immediately and returns result.kind=\"task_created\"; do not call add_task afterward. Other intent types notify the proposer to perform the exact follow-up with board_intent_id and their own worker session. The scoped approval token remains available for legacy callers; do not post it in room messages.", {
+    server.tool("approve_board_intent", "Approve a pending board intent. For task_create intents this creates the task immediately and returns result.kind=\"task_created\"; do not call add_task afterward. Authenticated-worker task_claim intents assign the task and work lease immediately with result.kind=\"task_claimed\" and requires_follow_up=false; do not call claim_task afterward. Other intents and legacy unverified claims require the exact follow-up with board_intent_id and the proposer's own worker session. The scoped approval token remains available for legacy callers; do not post it in room messages.", {
         intent_id: z.string().describe("Board intent id to approve."),
         reason: z.string().optional().describe("Short approval reason."),
         ...workerTaskIdentitySchema,

package/dist/mcp/server/tools/tasks/verdict-tools.js

@@ -5,7 +5,7 @@ import { resolveCanonicalRoomId, resolveCanonicalTaskToolIdentity, taskActorPayl
 import { jsonToolResponse, taskToolError } from "./response.js";
 import { taskReviewIdentitySchema } from "./schemas.js";
 export function registerTaskVerdictTools(server) {
-    server.tool("submit_review_verdict", "Submit a GitHub review verdict through the durable effect journal. Requires this exact worker session to hold an active review lease. Ambiguous provider outcomes are reconciled by correlation lookup and are never blindly retried.", {
+    server.tool("submit_review_verdict", "Submit a GitHub review verdict through the durable effect journal. Requires this exact worker session to hold an active review lease. Success means GitHub confirmed publication; pending, failed, or uncertain effects keep their original idempotency key. Ambiguous outcomes are reconciled by correlation lookup and are never blindly retried.", {
         task_id: z.string().describe("Task in review, e.g. 'task_1'."),
         verdict: z.enum(["approve", "request_changes", "comment"]).describe("GitHub review verdict."),
         body: z.string().max(65_536).optional().describe("Review explanation. Empty or junk blocking verdicts are quarantined."),
@@ -34,13 +34,26 @@ export function registerTaskVerdictTools(server) {
                     }),
                 },
             });
-            await syncRoomPresence(targetRoomId, identity, {
-                status: "reviewing",
-                status_text: `submitted ${verdict} verdict for ${task_id}`,
-            }, agentSession);
+            const published = result.effect.state === "succeeded";
+            const publicationStatus = published ? `published ${verdict} verdict for ${task_id}`
+                : result.effect.quarantined_at ? `review publication blocked for ${task_id}`
+                    : result.effect.state === "failed" ? `review publication failed for ${task_id}`
+                        : result.effect.state === "pending" ? `review publication pending for ${task_id}`
+                            : `review publication outcome unknown for ${task_id}`;
+            // Presence is a secondary notification. Its failure cannot erase an
+            // exact journal receipt or turn a known publication into a new retry.
+            try {
+                await syncRoomPresence(targetRoomId, identity, {
+                    status: "reviewing",
+                    status_text: publicationStatus,
+                }, agentSession);
+            }
+            catch { /* Return the durable effect even when presence is unavailable. */ }
             return jsonToolResponse({
-                success: true,
                 ...result,
+                success: published,
+                message: published ? "The review was published on GitHub."
+                    : `${publicationStatus}. The returned effect is the publication record; do not submit a new idempotency key to retry it.`,
                 agent_identity: toPublicAgentIdentity(identity),
             }, 2);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.27",
+  "version": "0.12.29",
   "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";