@bojackduy/opencode-loopd 1.13.1 → 1.13.2

package/CHANGELOG.md

@@ -17,6 +17,26 @@
 
 - Scratch harness (real host + real service): timeout→`terminated/timeout`+notify; until→`terminated/until` with 1 notify and `until-matched` state; pattern read returns ANSI-original lines case-insensitively, rejects `(a+)+`; env value reaches process while state keeps only the name; terminate+remove in one call. 555 tests pass.
 
+## 1.13.2 (2026-10-12) — Diagnostic Isolation and Lock Recovery
+
+### Fixed
+
+- Read/exempt tools no longer wait on workspace bookkeeping in either hook or worker tracking. After-hooks without an execution reservation avoid unnecessary state mutations; write and scope guards remain enforced.
+- State and inbox locks retain their acquisition descriptor for cleanup under file-table exhaustion, validate token and inode ownership, and remove incomplete acquisition metadata on failure. Lock errors identify loopd and the last observed owner PID and operation.
+- State read errors fail closed instead of allowing a mutation to overwrite saved goals with an empty store.
+- Dashboard control timeouts bound request submission, response reads, and timeout diagnostics. A timeout reports uncertain/late delivery rather than implying cancellation.
+- v2 CodeMode orchestration no longer blocks itself on the outer execute reservation. Nested executors retain independent guards and reservations even when the host reuses a call ID.
+- Automatic terminal-tool cleanup handles missing part identity only with matching message-envelope identity, and retained idle runtime IDs only with exact terminal evidence.
+- Idle continuation distinguishes completed tool-call steps from finished turns, and newer unfinished assistant steps invalidate older completion anchors.
+- Repeated block acknowledgements preserve the original blocker and do not duplicate accounting, events, or parent notifications.
+
+### Verification
+
+- 794 tests pass across 70 files; the ten control-I/O and diagnostic-isolation regressions also pass ten repetitions.
+- Typecheck, server/TUI builds, and whitespace checks pass.
+
+Fully stop the old OpenCode instance before restarting to load the updated plugins. This release does not steal or delete locks held by a live process.
+
 ## 1.13.1 (2026-10-11) — Truthful Goal Delivery and Safe Recovery
 
 ### Fixed

package/dist/server.js

@@ -215,25 +215,32 @@ async function acquireLock(directory, key, operation) {
   const dir = lockDir(directory);
   await fs2.mkdir(dir, { recursive: true });
   const lockPath = lockFile(directory, key);
+  let lastOwner;
   const deadline = performance.now() + LOCK_TIMEOUT_MS;
   for (let attempt = 0;performance.now() < deadline; attempt++) {
     try {
       try {
         const raw = await fs2.readFile(lockPath, "utf8");
         const meta = JSON.parse(raw);
+        lastOwner = meta;
         const age = Date.now() - Date.parse(meta.acquiredAt);
         if (age > LOCK_STALE_MS && !processIsAlive(meta.pid)) {
           await fs2.rm(lockPath, { force: true });
         }
       } catch {}
-      const meta = { pid: process.pid, operation, acquiredAt: new Date().toISOString() };
-      const fd = await fs2.open(lockPath, "wx");
+      const meta = { pid: process.pid, operation, acquiredAt: new Date().toISOString(), token: randomUUID() };
+      const fd = await fs2.open(lockPath, "wx+");
       try {
         await fd.writeFile(JSON.stringify(meta), "utf8");
-      } finally {
-        await fd.close();
+        return { path: lockPath, handle: fd, token: meta.token };
+      } catch (error) {
+        try {
+          await fs2.rm(lockPath, { force: true });
+        } finally {
+          await fd.close();
+        }
+        throw error;
       }
-      return;
     } catch (error) {
       if (error?.code === "EEXIST") {} else if (error?.code === "ENOENT") {
         await fs2.mkdir(dir, { recursive: true });
@@ -244,26 +251,28 @@ async function acquireLock(directory, key, operation) {
     }
     await delay(Math.min(25 * (attempt + 1), 250, Math.max(0, deadline - performance.now())));
   }
-  throw new Error(`failed to acquire lock "${key}" for "${operation}" after ${LOCK_TIMEOUT_MS}ms`);
+  const owner = lastOwner ? ` Last observed owner: PID ${lastOwner.pid}, operation "${lastOwner.operation}", acquired ${lastOwner.acquiredAt}.` : " Owner metadata unavailable.";
+  throw new Error(`failed to acquire lock "${key}" for "${operation}" after ${LOCK_TIMEOUT_MS}ms. This is the loopd plugin's lock, not OpenCode core.${owner}`);
 }
-async function releaseLock(directory, key) {
-  const lockPath = lockFile(directory, key);
+async function releaseLock(lease) {
   try {
-    const raw = await fs2.readFile(lockPath, "utf8");
-    const meta = JSON.parse(raw);
-    const shouldRelease = meta.pid === process.pid;
-    if (!shouldRelease)
+    const held = await lease.handle.stat();
+    const buffer = Buffer.alloc(held.size);
+    const { bytesRead } = await lease.handle.read(buffer, 0, buffer.length, 0);
+    const meta = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+    if (meta.pid !== process.pid || meta.token !== lease.token)
       return;
-    try {
-      const raw2 = await fs2.readFile(lockPath, "utf8");
-      const meta2 = JSON.parse(raw2);
-      if (meta2.acquiredAt !== meta.acquiredAt || meta2.pid !== meta.pid)
+    const current = await fs2.stat(lease.path).catch((error) => {
+      if (error?.code === "ENOENT")
         return;
-    } catch {
+      throw error;
+    });
+    if (!current || current.dev !== held.dev || current.ino !== held.ino)
       return;
-    }
-    await fs2.rm(lockPath, { force: true });
-  } catch {}
+    await fs2.rm(lease.path, { force: true });
+  } finally {
+    await lease.handle.close();
+  }
 }
 async function readState(directory) {
   const target = stateFile(directory);
@@ -281,11 +290,11 @@ async function readState(directory) {
         return emptyState();
       const transient = error instanceof SyntaxError || error?.code === "EPERM" || error?.code === "EACCES" || error?.code === "EBUSY";
       if (!transient || attempt === attempts - 1)
-        break;
+        throw error;
       await delay(25 * (attempt + 1));
     }
   }
-  return emptyState();
+  throw new Error("State could not be read.");
 }
 function migrate(state) {
   if (state.version === CURRENT_VERSION)
@@ -431,14 +440,14 @@ async function writeState(directory, state) {
   await writeAtomic(stateFile(directory), payload);
 }
 async function mutateState(directory, description, fn) {
-  await acquireLock(directory, "state", description);
+  const lease = await acquireLock(directory, "state", description);
   try {
     const state = await readState(directory);
     const next = await fn(state);
     await writeState(directory, next);
     return next;
   } finally {
-    await releaseLock(directory, "state");
+    await releaseLock(lease);
   }
 }
 async function appendEvent(directory, event) {
@@ -523,7 +532,7 @@ async function appendGoalInbox(directory, goalID, from, text) {
   await mutateState(directory, `inbox.enqueue:${goalID}`, async (state) => {
     if (!state.goals.some((goal) => goal.id === goalID))
       return state;
-    await acquireLock(directory, `inbox-${goalID}`, "inbox.append");
+    const lease = await acquireLock(directory, `inbox-${goalID}`, "inbox.append");
     try {
       const dir = path.join(loopDir(directory), "inboxes");
       await fs2.mkdir(dir, { recursive: true });
@@ -532,24 +541,24 @@ async function appendGoalInbox(directory, goalID, from, text) {
 `, "utf8");
       accepted = true;
     } finally {
-      await releaseLock(directory, `inbox-${goalID}`);
+      await releaseLock(lease);
     }
     return state;
   });
   return accepted;
 }
 async function deleteGoalInbox(directory, goalID) {
-  await acquireLock(directory, `inbox-${goalID}`, "inbox.delete");
+  const lease = await acquireLock(directory, `inbox-${goalID}`, "inbox.delete");
   try {
     await fs2.rm(inboxFile(directory, goalID), { force: true });
   } finally {
-    await releaseLock(directory, `inbox-${goalID}`);
+    await releaseLock(lease);
   }
 }
 async function acknowledgeGoalInbox(directory, goalID, delivered) {
   if (!delivered.length)
     return;
-  await acquireLock(directory, `inbox-${goalID}`, "inbox.acknowledge");
+  const lease = await acquireLock(directory, `inbox-${goalID}`, "inbox.acknowledge");
   try {
     let raw;
     try {
@@ -571,11 +580,11 @@ async function acknowledgeGoalInbox(directory, goalID, delivered) {
     else
       await fs2.rm(inboxFile(directory, goalID), { force: true });
   } finally {
-    await releaseLock(directory, `inbox-${goalID}`);
+    await releaseLock(lease);
   }
 }
 async function snapshotGoalInbox(directory, goalID) {
-  await acquireLock(directory, `inbox-${goalID}`, "inbox.snapshot");
+  const lease = await acquireLock(directory, `inbox-${goalID}`, "inbox.snapshot");
   try {
     const raw = await fs2.readFile(inboxFile(directory, goalID), "utf8");
     const lines = raw.trim().split(`
@@ -587,7 +596,7 @@ async function snapshotGoalInbox(directory, goalID) {
       return { lines: [], messages: [] };
     throw error;
   } finally {
-    await releaseLock(directory, `inbox-${goalID}`);
+    await releaseLock(lease);
   }
 }
 async function peekGoalInbox(directory, goalID) {
@@ -1423,6 +1432,9 @@ var init_workspace_scope = () => {};
 // src/application/workspace-execution.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import path3 from "path";
+function isWorkspaceToolExempt(tool) {
+  return readTools.has(tool);
+}
 function structuredWritePaths(tool, args) {
   if (tool === "write" || tool === "edit") {
     if (typeof args.filePath !== "string")
@@ -1607,7 +1619,12 @@ async function beforeWorkspaceTool(directory, input, args) {
     return state;
   });
 }
-async function afterWorkspaceTool(directory, sessionID, callID) {
+async function afterWorkspaceTool(directory, sessionID, callID, tool) {
+  if (tool && isWorkspaceToolExempt(tool))
+    return;
+  const snapshot = await readState(directory);
+  if (!snapshot.workspaceCalls?.some((call) => call.sessionID === sessionID && call.callID === callID))
+    return;
   await mutateState(directory, `workspace.after:${callID}`, async (state) => {
     state.workspaceCalls = state.workspaceCalls?.filter((call) => call.sessionID !== sessionID || call.callID !== callID);
     const now = Date.now();
@@ -1646,7 +1663,7 @@ async function releaseTerminalWorkspaceCalls(directory, evidence) {
     });
     for (const goal of state.goals) {
       const rt = state.runtimes.find((item) => item.goalID === goal.id);
-      const started = rt?.turnStartedAt ? Date.parse(rt.turnStartedAt) : NaN;
+      const started = rt?.turnStartedAt || rt?.lastRunAt ? Date.parse(rt.turnStartedAt ?? rt.lastRunAt) : NaN;
       if (!rt?.activeToolCallIDs?.length || !Number.isFinite(started))
         continue;
       rt.activeToolCallIDs = rt.activeToolCallIDs.filter((callID) => {
@@ -1680,22 +1697,35 @@ async function reconcileTerminalWorkspaceCalls(directory, host) {
   }));
   await releaseTerminalWorkspaceCalls(directory, proof.flat());
 }
-function guardV2ToolEditor(directory, editor) {
+function guardV2ToolEditor(directory, editor, lifecycle) {
   if (typeof editor.list !== "function" || typeof editor.update !== "function")
     throw new Error("Scoped execution requires the v2 tool editor list/update execution surface.");
+  const guarded = new Set;
   for (const entry of editor.list()) {
+    guarded.add(entry.id);
     editor.update(entry.id, (definition) => {
       const execute = definition.execute;
       definition.execute = async (args, context) => {
-        await beforeWorkspaceTool(directory, { tool: entry.name, sessionID: context.sessionID, callID: context.id }, args);
+        const input = { tool: entry.id, sessionID: context.sessionID, callID: `${context.id}:${randomUUID4()}` };
+        const values = args;
+        if (lifecycle)
+          await lifecycle.before(input, values);
+        else
+          await beforeWorkspaceTool(directory, input, values);
+        let result;
         try {
-          return await execute(args, context);
+          result = await execute(args, context);
+          return result;
         } finally {
-          await afterWorkspaceTool(directory, context.sessionID, context.id);
+          if (lifecycle)
+            await lifecycle.after(input, values, result);
+          else
+            await afterWorkspaceTool(directory, input.sessionID, input.callID, input.tool);
         }
       };
     });
   }
+  return guarded;
 }
 async function withWorkspaceOperation(directory, goalID, sessionID, run) {
   const id = randomUUID4();
@@ -2602,9 +2632,7 @@ function createLoopEngine(options) {
           Object.assign(rt, recordActivity(rt));
           rt.activePromptObservedAt ??= new Date().toISOString();
           rt.activeAssistantMessageID = info.id;
-          if (info.time?.completed) {
-            rt.activeAssistantCompletedAt = new Date(info.time.completed).toISOString();
-          }
+          rt.activeAssistantCompletedAt = info.time?.completed && info.finish !== "tool-calls" ? new Date(info.time.completed).toISOString() : undefined;
           matched = true;
         }
       } else {
@@ -2692,7 +2720,7 @@ function createLoopEngine(options) {
       const stagedRt = afterIdle.runtimes.find((r) => r.goalID === goalID);
       const eventAnchored = stagedRt?.runGeneration === candidate.generation && Boolean(stagedRt?.activeAssistantCompletedAt);
       const transcript = await inspectPromptTurn(goal.workerSessionID, candidate.promptMessageID);
-      const failureReason = !transcript.latestUserPrompt && !eventAnchored ? "prompt-outside-window" : !eventAnchored && !candidate.assistantCompleted && !transcript.assistantCompleted ? "assistant-incomplete" : undefined;
+      const failureReason = transcript.assistantInProgress ? "assistant-incomplete" : !transcript.latestUserPrompt && !eventAnchored ? "prompt-outside-window" : !eventAnchored && !candidate.assistantCompleted && !transcript.assistantCompleted ? "assistant-incomplete" : undefined;
       if (failureReason) {
         let newlyStamped = false;
         await mutateState(directory, `idle.confirm-stamp:${goalID}`, async (s) => {
@@ -2855,7 +2883,7 @@ function createLoopEngine(options) {
     return true;
   }
   async function inspectPromptTurn(workerSessionID, promptMessageID) {
-    const noMatch = { latestUserPrompt: false, assistantCompleted: false };
+    const noMatch = { latestUserPrompt: false, assistantCompleted: false, assistantInProgress: false };
     if (!workerSessionID)
       return noMatch;
     let messages;
@@ -2869,9 +2897,14 @@ function createLoopEngine(options) {
       return noMatch;
     const allTimestamped = users.every((message) => message.timestamp && Number.isFinite(Date.parse(message.timestamp)));
     const ordered = allTimestamped ? [...users].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)) : users;
+    const assistants = messages.filter((message) => message.role === "assistant" && message.parentMessageID === promptMessageID);
+    const orderedAssistants = assistants.every((message) => Number.isFinite(Date.parse(message.createdAt ?? message.timestamp ?? ""))) ? [...assistants].sort((a, b) => Date.parse(a.createdAt ?? a.timestamp) - Date.parse(b.createdAt ?? b.timestamp)) : assistants;
+    const latestAssistant = orderedAssistants.at(-1);
+    const assistantCompleted = Boolean(latestAssistant?.completedAt) && latestAssistant?.finish !== "tool-calls";
     return {
       latestUserPrompt: ordered.at(-1)?.messageID === promptMessageID,
-      assistantCompleted: messages.some((message) => message.role === "assistant" && message.parentMessageID === promptMessageID && Boolean(message.completedAt))
+      assistantCompleted,
+      assistantInProgress: Boolean(latestAssistant) && !assistantCompleted
     };
   }
   async function handleSessionStatus(state, goal, event) {
@@ -3852,6 +3885,8 @@ function createRealHost(client, directory) {
             messageID: m.info?.id || m.id,
             parentMessageID: m.info?.parentID,
             completedAt: completedMs ? new Date(completedMs).toISOString() : undefined,
+            finish: typeof m.info?.finish === "string" ? m.info.finish : undefined,
+            createdAt: typeof createdMs === "number" ? new Date(createdMs).toISOString() : undefined,
             tokens: tokens && typeof tokens.input === "number" ? {
               input: tokens.input || 0,
               output: tokens.output || 0,
@@ -3872,10 +3907,14 @@ function createRealHost(client, directory) {
         const result = await withTimeout(client.session.messages({ path: { id: sessionID } }), 1e4, "OpenCode session.messages (tool terminal evidence)");
         if (!Array.isArray(result?.data))
           return [];
-        return result.data.flatMap((message) => (message.parts ?? []).flatMap((part) => {
-          const evidence = terminalToolExecution(part);
-          return evidence?.sessionID === sessionID ? [evidence] : [];
-        }));
+        return result.data.flatMap((message) => {
+          if (message.info?.sessionID !== undefined && message.info.sessionID !== sessionID)
+            return [];
+          return (message.parts ?? []).flatMap((part) => {
+            const evidence = terminalToolExecution(part?.sessionID === undefined && message.info?.sessionID === sessionID ? { ...part, sessionID } : part);
+            return evidence?.sessionID === sessionID ? [evidence] : [];
+          });
+        });
       } catch {
         return [];
       }
@@ -4111,6 +4150,7 @@ function createV2Host(context, statuses, options = {}) {
             messageID: message.id,
             parentMessageID,
             completedAt: completed ? new Date(completed).toISOString() : undefined,
+            createdAt: new Date(created).toISOString(),
             tokens: message.tokens ? {
               input: message.tokens.input,
               output: message.tokens.output,
@@ -9184,6 +9224,16 @@ ${failureDetails.slice(0, 500)}`,
         if (!goal) {
           return { title: "No goal", output: "No active goal to block." };
         }
+        if (goal.status === "blocked") {
+          return { title: "Goal already blocked", output: JSON.stringify({
+            goalID: goal.id,
+            goalName: goal.name,
+            status: "blocked",
+            alreadyBlocked: true,
+            reason: goal.blocker?.reason,
+            needed: goal.blocker?.needed
+          }) };
+        }
         if (!canTransition(goal.status, "blocked", "model")) {
           return { title: "Invalid transition", output: `Cannot block goal in ${goal.status} state.` };
         }
@@ -10411,7 +10461,7 @@ function commandTools(options) {
 init_server_log();
 init_state_repository();
 // package.json
-var version = "1.13.1";
+var version = "1.13.2";
 
 // src/server/plugin.ts
 init_workspace_execution();
@@ -10520,6 +10570,8 @@ function createServerHooks(directory, host, defaults) {
     tool: { ...goalTools(directory, goalService, undefined, defaults, host), ...ownerTools2({ directory, host, goalService }), ...commandTools({ directory, commandService, capabilities: commandHost.capabilities, goalService }) },
     "tool.execute.before": async (input, _output) => {
       await beforeWorkspaceTool(directory, input, _output.args);
+      if (isWorkspaceToolExempt(input.tool))
+        return;
       const activeWorkers = goalService.getActiveWorkers();
       let matchedGoalID;
       for (const [goalID, worker] of activeWorkers) {
@@ -10540,7 +10592,7 @@ function createServerHooks(directory, host, defaults) {
       } catch {}
     },
     "tool.execute.after": async (input, output) => {
-      await afterWorkspaceTool(directory, input.sessionID, input.callID);
+      await afterWorkspaceTool(directory, input.sessionID, input.callID, input.tool);
       if (input.tool === "loopd_create_goal" || input.tool === "get_goal" || input.tool === "report_goal_progress") {
         ensureStarted();
         reconcileInBackground();
@@ -10548,7 +10600,7 @@ function createServerHooks(directory, host, defaults) {
       const activeWorkers = goalService.getActiveWorkers();
       let matchedGoalID;
       for (const [goalID, worker] of activeWorkers) {
-        if (worker.workerSessionID === input.sessionID) {
+        if (!isWorkspaceToolExempt(input.tool) && worker.workerSessionID === input.sessionID) {
           matchedGoalID = goalID;
           break;
         }
@@ -10569,6 +10621,8 @@ function createServerHooks(directory, host, defaults) {
           if (!raw)
             return;
           const parsed = JSON.parse(raw);
+          if (parsed.alreadyBlocked === true)
+            return;
           if (parsed.status !== "complete" && parsed.status !== "blocked")
             return;
           const goalID = parsed.goalID;
@@ -10635,6 +10689,7 @@ var v2 = {
     const eventController = new AbortController;
     let eventTask = Promise.resolve();
     let disposed = false;
+    let guardedToolIDs = new Set;
     const cleanup = async () => {
       if (disposed)
         return;
@@ -10652,9 +10707,23 @@ var v2 = {
         for (const [id, definition] of Object.entries(hooks.tool ?? {})) {
           editor.add(toV2Tool(id, definition, directory));
         }
-        guardV2ToolEditor(directory, editor);
+        guardedToolIDs = guardV2ToolEditor(directory, editor, {
+          before: async (input, args) => {
+            await hooks["tool.execute.before"]?.(input, { args });
+          },
+          after: async (input, args, result) => {
+            const output = result;
+            await hooks["tool.execute.after"]?.({ ...input, args }, {
+              title: "",
+              output: typeof output?.content === "string" ? output.content : JSON.stringify(output?.content ?? ""),
+              metadata: output?.metadata ?? {}
+            });
+          }
+        });
       }));
       registrations.push(await context.tool.hook("execute.before", async (input) => {
+        if (input.tool === "execute" || guardedToolIDs.has(input.tool))
+          return;
         await hooks["tool.execute.before"]?.({
           tool: input.tool,
           sessionID: input.sessionID,
@@ -10662,6 +10731,8 @@ var v2 = {
         }, { args: input.input });
       }));
       registrations.push(await context.tool.hook("execute.after", async (input) => {
+        if (input.tool === "execute" || guardedToolIDs.has(input.tool))
+          return;
         const output = input.status === "completed" ? input.result : { content: JSON.stringify(input.error) };
         await hooks["tool.execute.after"]?.({
           tool: input.tool,

package/dist/tui.js

@@ -106,11 +106,11 @@ async function readState(directory) {
         return emptyState();
       const transient = error instanceof SyntaxError || error?.code === "EPERM" || error?.code === "EACCES" || error?.code === "EBUSY";
       if (!transient || attempt === attempts - 1)
-        break;
+        throw error;
       await delay(25 * (attempt + 1));
     }
   }
-  return emptyState();
+  throw new Error("State could not be read.");
 }
 function migrate(state) {
   if (state.version === CURRENT_VERSION)
@@ -359,33 +359,66 @@ function createControlClient(directory) {
       args: command.args,
       requestedAt: new Date().toISOString()
     };
-    await writeControlRequest(directory, request);
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const response = await readControlResponse(directory, request.requestID);
-      if (response)
-        return response;
-      await delay2(100);
-    }
-    const late = await readControlResponse(directory, request.requestID).catch(() => {
-      return;
+    let submitted = false;
+    let expired = false;
+    let timeoutReply;
+    const deadline = performance.now() + timeoutMs;
+    function timedOut() {
+      return timeoutReply ??= (async () => {
+        let probeTimer;
+        let claimed;
+        try {
+          claimed = await Promise.race([
+            statProcessingRequest(directory, request.requestID),
+            new Promise((resolve) => {
+              probeTimer = setTimeout(() => resolve(undefined), 100);
+            })
+          ]);
+        } catch {} finally {
+          if (probeTimer)
+            clearTimeout(probeTimer);
+        }
+        const stage = claimed ? `accepted by the server ${(claimed.requestAgeMs / 1000).toFixed(1)}s ago, still processing` : submitted ? "request submitted; server acceptance or response could not be confirmed" : "request submission is still pending";
+        return {
+          requestID: request.requestID,
+          ok: false,
+          errorCode: "timeout",
+          message: `timeout waiting for response (${stage}; the operation may complete later under this requestID \u2014 check the server log before retrying)`,
+          completedAt: new Date().toISOString()
+        };
+      })();
+    }
+    async function exchange() {
+      await writeControlRequest(directory, request);
+      submitted = true;
+      while (!expired && performance.now() < deadline) {
+        const response = await readControlResponse(directory, request.requestID);
+        if (response)
+          return response;
+        if (!expired)
+          await delay2(Math.min(100, Math.max(0, deadline - performance.now())));
+      }
+      if (!expired) {
+        const late = await readControlResponse(directory, request.requestID);
+        if (late)
+          return late;
+      }
+      return timedOut();
+    }
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        expired = true;
+        timedOut().then(resolve);
+      }, timeoutMs);
     });
-    if (late)
-      return late;
-    let stage = "not yet accepted by the server";
     try {
-      const claimed = await statProcessingRequest(directory, request.requestID);
-      if (claimed) {
-        stage = `accepted by the server ${(claimed.requestAgeMs / 1000).toFixed(1)}s ago, still processing \u2014 ` + `the operation may complete later (late reply under this requestID); ` + `check the server log before retrying`;
-      }
-    } catch {}
-    return {
-      requestID: request.requestID,
-      ok: false,
-      message: `timeout waiting for response (${stage})`,
-      errorCode: "timeout",
-      completedAt: new Date().toISOString()
-    };
+      return await Promise.race([exchange(), timeout]);
+    } finally {
+      expired = true;
+      if (timer)
+        clearTimeout(timer);
+    }
   }
   async function getState() {
     return readState(directory);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.13.1",
+  "version": "1.13.2",
   "description": "Codex-inspired background goal engine for OpenCode — autonomous subagents, engine-driven loop, child worker sessions and modal TUI dashboard. Like Claude Code loop for OpenCode.",
   "type": "module",
   "license": "AGPL-3.0-or-later",