lody 0.52.0 → 0.52.2

package/dist/index.js

@@ -36822,7 +36822,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     return client;
   }
   const name = "lody";
-  const version$4 = "0.52.0";
+  const version$4 = "0.52.2";
   const description$1 = "Lody Agent CLI tool for managing remote command execution";
   const type$2 = "module";
   const main$3 = "dist/index.js";
@@ -36865,7 +36865,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     "node": ">=18.0.0"
   };
   const optionalDependencies = {
-    "acp-extension-claude": "0.34.1",
+    "acp-extension-claude": "0.34.3",
     "acp-extension-codex": "0.14.3"
   };
   const devDependencies = {
@@ -85476,13 +85476,14 @@ ${tailedOutput}` : null;
   };
   function withSlowOperationWarning(promise, logger2, operationName, sessionId, intervalMs = 1e4) {
     let completed = false;
-    let elapsedMs = 0;
+    const startMs = Date.now();
     const interval2 = setInterval(() => {
-      elapsedMs += intervalMs;
       if (!completed) {
+        const elapsedMs = Date.now() - startMs;
         logger2.debug(`[${sessionId}] Operation "${operationName}" is still pending after ${Math.round(elapsedMs / 1e3)}s - possible hang`);
       }
     }, intervalMs);
+    interval2.unref?.();
     return promise.finally(() => {
       completed = true;
       clearInterval(interval2);
@@ -98397,11 +98398,13 @@ stream:${scope2.streamId}`;
     machineId = null;
     machineKey = null;
     sessionKeys = /* @__PURE__ */ new Map();
+    machineHeartbeatSeq = 0;
     started = false;
     stopped = false;
     start() {
       if (this.started || this.stopped) return;
       this.started = true;
+      this.options.logger.debug(`[${this.options.workspaceId}] Joining Loro presence room`);
       void this.transport.join({
         onStatusChange: (status) => {
           this.options.logger.debug(`[${this.options.workspaceId}] Loro presence room status: ${status}`);
@@ -98413,6 +98416,7 @@ stream:${scope2.streamId}`;
         }
         if (result.ok) {
           this.subscription = result.value;
+          this.options.logger.debug(`[${this.options.workspaceId}] Loro presence subscription established`);
           return;
         }
         this.options.logger.debug(`[${this.options.workspaceId}] Failed to join Loro presence room: ${formatErrorMessage(result.error)}`);
@@ -98442,6 +98446,7 @@ stream:${scope2.streamId}`;
     }
     writeMachineHeartbeat() {
       if (this.stopped || !this.machineId || !this.machineKey) return;
+      const seq2 = ++this.machineHeartbeatSeq;
       const state2 = {
         kind: "machine",
         machineId: this.machineId,
@@ -98449,6 +98454,7 @@ stream:${scope2.streamId}`;
         updatedAt: getServerNow()
       };
       this.store.set(this.machineKey, state2);
+      this.options.logger.debug(`[${this.options.workspaceId}] Loro presence machine heartbeat written (seq=${seq2} updatedAt=${state2.updatedAt})`);
     }
     setSessionPresence(args2) {
       if (this.stopped) return;
@@ -116856,6 +116862,18 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       let metaSub = null;
       const initialMetaSync = createDeferred();
       let initialMetaSyncCompleted = false;
+      let persistFlushSeq = 0;
+      const flushRepoForPersist = async (reason) => {
+        const currentRepo = repo;
+        if (!currentRepo) {
+          return;
+        }
+        const seq2 = ++persistFlushSeq;
+        const startedAt = Date.now();
+        logger2.debug(`[${workspaceId}] Loro repo flush started (reason=${reason} seq=${seq2})`);
+        await withSlowOperationWarning(currentRepo.flush(), logger2, `loro-repo.flush(${reason}, seq=${seq2})`, workspaceId);
+        logger2.debug(`[${workspaceId}] Loro repo flush completed (reason=${reason} seq=${seq2} duration=${Date.now() - startedAt}ms)`);
+      };
       const transportAdapter = new StreamsTransportAdapter({
         bucketId: LORO_STREAMS_BUCKET_ID,
         metaStreamId: getLoroMetaStreamId(workspaceId),
@@ -116869,10 +116887,10 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
           debounceMs: 5e3
         },
         onPersistDoc: async () => {
-          await repo?.flush();
+          await flushRepoForPersist("doc");
         },
         onPersistMeta: async () => {
-          await repo?.flush();
+          await flushRepoForPersist("meta");
         }
       });
       let manager = null;
@@ -117166,8 +117184,11 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       if (!this.machine) {
         return;
       }
-      await this.machine.sendHeartbeat();
+      const startedAt = Date.now();
+      this.logger.debug(`[${this.workspaceId}] Machine heartbeat writing presence and meta`);
       this.presenceRuntime?.writeMachineHeartbeat();
+      await withSlowOperationWarning(this.machine.sendHeartbeat(), this.logger, "machine.sendHeartbeat repo.upsertDocMeta(lastSeen)", this.workspaceId);
+      this.logger.debug(`[${this.workspaceId}] Machine heartbeat meta write completed (duration=${Date.now() - startedAt}ms)`);
     }
     async restoreMachineDocument(machineId) {
       const machineRoomId = getMachineRoomId(machineId);
@@ -122002,11 +122023,19 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       return {};
     }
     async extMethod(method, params) {
-      this.handleExtensionMessage(method, params);
+      try {
+        this.handleExtensionMessage(method, params);
+      } catch (error2) {
+        this.logger.warn(`Error handling extension method ${method}: ${error2}`);
+      }
       return {};
     }
     async extNotification(method, params) {
-      this.handleExtensionMessage(method, params);
+      try {
+        this.handleExtensionMessage(method, params);
+      } catch (error2) {
+        this.logger.warn(`Error handling extension notification ${method}: ${error2}`);
+      }
     }
     handleExtensionMessage(method, params) {
       const resolvedMethod = method.startsWith("_") ? method.slice(1) : method;
@@ -122106,7 +122135,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       this.supportsClose = !!closeCapability;
       const hasCloseMethod = typeof connection.closeSession === "function";
       this.logger.debug(`[${this.options.sessionId}] ACP capabilities (loadSession=${this.supportsLoadSession ? "yes" : "no"} loadSessionMethod=${hasLoadSessionMethod ? "yes" : "no"} resume=${this.supportsResume ? "yes" : "no"} resumeMethod=${hasResumeMethod ? "yes" : "no"} close=${this.supportsClose ? "yes" : "no"} closeMethod=${hasCloseMethod ? "yes" : "no"})`);
-      this.logger.debug(`[${this.options.sessionId}] About to start new ACP session`);
+      this.logger.debug(`[${this.options.sessionId}] About to establish ACP session`);
       const newSessionStart = performance$1.now();
       this.options.onStartupStage?.({
         type: "new_session_start"
@@ -122133,11 +122162,12 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         const loadStart = performance$1.now();
         try {
           this.logger.debug(`[${this.options.sessionId}] Attempting ACP loadSession (acpSessionId=${resumeSessionId})`);
-          const loadResponse = await withAbort(connection.loadSession({
+          const ACP_LOAD_SESSION_TIMEOUT_MS = Math.max(0, timeoutOptions.loadSessionTimeoutMs ?? timeoutOptions.newSessionTimeoutMs ?? 12e4);
+          const loadResponse = await withTimeout$2(withAbort(connection.loadSession({
             sessionId: resumeSessionId,
             cwd: workdir,
             mcpServers
-          }), startupAbort);
+          }), startupAbort), this.logger, "connection.loadSession", this.options.sessionId, ACP_LOAD_SESSION_TIMEOUT_MS);
           const loadDurationMs = performance$1.now() - loadStart;
           sessionResponse = {
             sessionId: resumeSessionId,
@@ -122158,11 +122188,12 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         const resumeStart = performance$1.now();
         try {
           this.logger.debug(`[${this.options.sessionId}] Attempting ACP resume (acpSessionId=${resumeSessionId})`);
-          const resumeResponse = await withAbort(connection.resumeSession({
+          const ACP_RESUME_SESSION_TIMEOUT_MS = Math.max(0, timeoutOptions.resumeSessionTimeoutMs ?? timeoutOptions.newSessionTimeoutMs ?? 12e4);
+          const resumeResponse = await withTimeout$2(withAbort(connection.resumeSession({
             sessionId: resumeSessionId,
             cwd: workdir,
             mcpServers
-          }), startupAbort);
+          }), startupAbort), this.logger, "connection.resumeSession", this.options.sessionId, ACP_RESUME_SESSION_TIMEOUT_MS);
           const resumeDurationMs = performance$1.now() - resumeStart;
           sessionResponse = {
             sessionId: resumeSessionId,
@@ -122218,21 +122249,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         this.logger.error(`[${this.options.sessionId}] connection.prompt returned undefined - connection may be closed`);
         return void 0;
       }
-      const PROMPT_WARN_AFTER_MS = 6e5;
-      const PROMPT_NO_UPDATES_MS = 12e4;
-      const PROMPT_WARN_INTERVAL_MS = 3e5;
-      const startMs = Date.now();
-      let completed = false;
       let abortListener;
-      const warningInterval = setInterval(() => {
-        if (completed) return;
-        const nowMs = Date.now();
-        const elapsedMs = nowMs - startMs;
-        if (elapsedMs < PROMPT_WARN_AFTER_MS) return;
-        const noUpdatesMs = nowMs - this.lastSessionUpdateAtMs;
-        if (noUpdatesMs < PROMPT_NO_UPDATES_MS) return;
-        this.logger.debug(`[${this.options.sessionId}] Operation "connection.prompt" is still pending after ${Math.round(elapsedMs / 1e3)}s (no session updates for ${Math.round(noUpdatesMs / 1e3)}s)`);
-      }, PROMPT_WARN_INTERVAL_MS);
       try {
         const abortPromise = abortSignal ? new Promise((_2, reject) => {
           abortListener = () => {
@@ -122253,11 +122270,9 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         this.logger.debug(`[${this.options.sessionId}] connection.prompt returned`);
         return result;
       } finally {
-        completed = true;
         if (abortSignal && abortListener) {
           abortSignal.removeEventListener("abort", abortListener);
         }
-        clearInterval(warningInterval);
       }
     }
     async cancel(sessionId) {
@@ -122428,7 +122443,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
   const BuiltinACPSetting = {
     claude: {
       packageName: "acp-extension-claude",
-      version: "0.34.1",
+      version: "0.34.3",
       binName: "acp-extension-claude"
     },
     codex: {
@@ -122919,6 +122934,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       args: args2,
       spawnImpl: options.spawnImpl
     });
+    options.logger.debug(`[acp-startup] spawned ACP process (cliType=${options.cliType} agentType=${options.agentType} workdir=${options.workdir})`);
     const stderrStream = agentProcess.stderr;
     let stderrTail = "";
     if (stderrStream) {
@@ -122980,6 +122996,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     const input2 = createStdinWritableStream(agentProcess.stdin);
     const stream2 = ndJsonStream(input2, output);
     try {
+      options.logger.debug("[acp-startup] creating ACP client");
       const started = await createAcpClient({
         stream: stream2,
         workdir: options.workdir,
@@ -122994,6 +123011,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         onRequestPermission: options.onRequestPermission,
         startupAbort: startupMonitor.abortPromise
       });
+      options.logger.debug(`[acp-startup] ACP client ready (acpSessionId=${started.acpSessionId})`);
       return {
         agentProcess,
         client: started.client,
@@ -123137,6 +123155,8 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     const sleep2 = (ms2) => new Promise((resolve2) => setTimeout(resolve2, ms2));
     const tryGenerateWithArgs = async (extraArgs) => {
       let collectedText = "";
+      const startupStartedAt = Date.now();
+      options.logger.debug(`[title-generator] Starting isolated title ACP agent (cliType=${options.cliType} agentType=${options.agentType})`);
       const { agentProcess, client, acpSessionId } = await startLocalAcpAgent({
         cliType: options.cliType,
         agentType: options.agentType,
@@ -123162,6 +123182,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         }),
         extraArgs
       });
+      options.logger.debug(`[title-generator] Isolated title ACP agent ready (acpSessionId=${acpSessionId} startupDuration=${Date.now() - startupStartedAt}ms)`);
       try {
         const prompt2 = buildTitlePrompt(options.taskPrompt);
         const configOptionValues = options.titleConfig?.configOptionValues;
@@ -123170,7 +123191,9 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
             await client?.setSessionConfigOption(acpSessionId, key2, value);
           }
         }
+        options.logger.debug(`[title-generator] Sending title prompt (acpSessionId=${acpSessionId})`);
         const response = await client?.prompt(acpSessionId, prompt2);
+        options.logger.debug(`[title-generator] Title prompt returned (acpSessionId=${acpSessionId})`);
         const deadline = Date.now() + 1e4;
         while (Date.now() < deadline && collectedText.trim() === "") {
           await sleep2(100);
@@ -127168,6 +127191,7 @@ $mem | ConvertTo-Json -Compress
         const resumeSource = requestedResumeSessionId ? "request" : storedResumeSessionId ? "meta" : "none";
         self2.deps.logger.debug(`[${sessionId}] Session not found in memory; restoring (project=${project?.kind === "github" ? project.repoFullName : project?.kind === "local" ? `local:${project.localProjectId}` : "none"} resume=${resumeSessionId ? "yes" : "no"} resumeSource=${resumeSource} resumeSessionId=${resumeSessionId ?? "none"})`);
         yield* self2.tryPromise(() => sessionDoc.setStatus(SessionStatusFactory.initializing("resuming")));
+        self2.deps.logger.debug(`[${sessionId}] Resuming status published; preparing session restore (resumeSource=${resumeSource} resumeSessionId=${resumeSessionId ?? "none"})`);
         const restoreConfig = {
           sessionId,
           workspaceId: message.workspaceId,
@@ -127191,11 +127215,13 @@ $mem | ConvertTo-Json -Compress
           if (resumeSessionId) {
             yield* acpReplaySuppression.acquire;
           }
+          self2.deps.logger.debug(`[${sessionId}] Session restore createSession started (resumeSessionId=${resumeSessionId ?? "none"})`);
           const restoredSession = yield* ctx.trackPendingSession(() => self2.deps.sessionManager.createSession(restoreConfig, {
             resumeSessionId
           }), {
             terminateOnCancel: true
           });
+          self2.deps.logger.debug(`[${sessionId}] Session restore createSession returned (acpSessionId=${restoredSession.acpSessionId ?? "null"})`);
           ctx.bindSession(restoredSession);
           yield* ctx.abortIfCancelled({
             terminateSession: true
@@ -127221,9 +127247,11 @@ $mem | ConvertTo-Json -Compress
               ...restoreConfig
             };
             const fallbackAttempt = gen(function* () {
+              self2.deps.logger.debug(`[${sessionId}] Fallback restore createSession started`);
               const fallbackSession = yield* ctx.trackPendingSession(() => self2.deps.sessionManager.createSession(fallbackConfig), {
                 terminateOnCancel: true
               });
+              self2.deps.logger.debug(`[${sessionId}] Fallback restore createSession returned (acpSessionId=${fallbackSession.acpSessionId ?? "null"})`);
               ctx.bindSession(fallbackSession);
               yield* ctx.abortIfCancelled({
                 terminateSession: true
@@ -128343,6 +128371,7 @@ $mem | ConvertTo-Json -Compress
     static REALTIME_WAIT_TIMEOUT_MS = 3e4;
     static REMOTE_SYNC_TIMEOUT_MS = 15e3;
     static HISTORY_SYNC_WAIT_TIMEOUT_MS = 5 * 6e4;
+    static HISTORY_SYNC_PROGRESS_LOG_MS = 3e4;
     static HISTORY_RECONNECT_JITTER_MIN_MS = 500;
     static HISTORY_RECONNECT_JITTER_MAX_MS = 1500;
     static setUnrefTimeout(callback, delayMs) {
@@ -128415,12 +128444,17 @@ $mem | ConvertTo-Json -Compress
         let reconnectAttempted = false;
         let unsubscribeMirror;
         let unsubscribeStatus;
+        let progressTimer = null;
+        const waitStartedAt = Date.now();
         const cleanup = () => {
           if (settled) {
             return;
           }
           settled = true;
           clearTimeout(timer2);
+          if (progressTimer) {
+            clearInterval(progressTimer);
+          }
           unsubscribeMirror?.();
           unsubscribeStatus?.();
         };
@@ -128475,6 +128509,13 @@ $mem | ConvertTo-Json -Compress
           this.deps.logger.warn(`[${sessionId}] User turn did not arrive in history after ${SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS / 1e3}s; entering dispatch recovery`);
           resolve2(null);
         }, SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS);
+        progressTimer = setInterval(() => {
+          if (settled) {
+            return;
+          }
+          this.deps.logger.warn(`[${sessionId}] Still waiting for pending user turn history sync (elapsed=${Date.now() - waitStartedAt}ms docRoom=${sessionDoc.getDocRoomStatus() ?? "unknown"})`);
+        }, SessionDispatchWatcher.HISTORY_SYNC_PROGRESS_LOG_MS);
+        progressTimer.unref?.();
         unsubscribeMirror = sessionDoc.mirror?.subscribe(checkForTurn);
         if (!unsubscribeMirror) {
           this.deps.logger.debug(`[${sessionId}] Session mirror is unavailable during history sync wait`);
@@ -132059,6 +132100,8 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     static CONTEXT_WINDOW_USAGE_THROTTLE_MS = 400;
     permissionRequestStartTimes = /* @__PURE__ */ new Map();
     machineHeartbeatTimer = null;
+    machineHeartbeatInFlightStartedAt = null;
+    machineHeartbeatSeq = 0;
     static MACHINE_HEARTBEAT_INTERVAL_MS = 2e4;
     evictForMemoryPressureFn = async () => ({
       availableMemoryBytes: 0,
@@ -132089,24 +132132,35 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     startMachineHeartbeat() {
       this.stopMachineHeartbeat();
       this.logger.debug(`Machine heartbeat started (${Math.round(MessageHandler.MACHINE_HEARTBEAT_INTERVAL_MS / 1e3)}s interval)`);
-      void this.workspaceDocument.sendMachineHeartbeat().then(() => {
-        this.logger.debug("Machine heartbeat sent (initial)");
-      }).catch((error2) => {
-        this.logger.debug(`Initial machine heartbeat failed: ${formatErrorMessage(error2)}`);
-      });
+      this.sendMachineHeartbeatWithDiagnostics("initial");
       this.machineHeartbeatTimer = setInterval(() => {
-        void this.workspaceDocument.sendMachineHeartbeat().then(() => {
-          this.logger.debug("Machine heartbeat sent");
-        }).catch((error2) => {
-          this.logger.debug(`Machine heartbeat failed: ${formatErrorMessage(error2)}`);
-        });
+        this.sendMachineHeartbeatWithDiagnostics("periodic");
       }, MessageHandler.MACHINE_HEARTBEAT_INTERVAL_MS);
+      this.machineHeartbeatTimer.unref?.();
+    }
+    sendMachineHeartbeatWithDiagnostics(reason) {
+      const now2 = Date.now();
+      if (this.machineHeartbeatInFlightStartedAt !== null) {
+        this.logger.warn(`Machine heartbeat skipped (reason=${reason}); previous heartbeat still pending for ${now2 - this.machineHeartbeatInFlightStartedAt}ms`);
+        return;
+      }
+      const seq2 = ++this.machineHeartbeatSeq;
+      this.machineHeartbeatInFlightStartedAt = now2;
+      this.logger.debug(`Machine heartbeat tick started (reason=${reason} seq=${seq2})`);
+      void withSlowOperationWarning(this.workspaceDocument.sendMachineHeartbeat(), this.logger, `workspaceDocument.sendMachineHeartbeat(reason=${reason}, seq=${seq2})`, this.machineId).then(() => {
+        this.logger.debug(`Machine heartbeat sent (reason=${reason} seq=${seq2} duration=${Date.now() - now2}ms)`);
+      }).catch((error2) => {
+        this.logger.debug(`Machine heartbeat failed (reason=${reason} seq=${seq2} duration=${Date.now() - now2}ms): ${formatErrorMessage(error2)}`);
+      }).finally(() => {
+        this.machineHeartbeatInFlightStartedAt = null;
+      });
     }
     stopMachineHeartbeat() {
       if (this.machineHeartbeatTimer) {
         clearInterval(this.machineHeartbeatTimer);
         this.machineHeartbeatTimer = null;
       }
+      this.machineHeartbeatInFlightStartedAt = null;
     }
     preferredBaseBranch = (process.env.LODY_BASE_BRANCH || "main").trim() || "main";
     resolveGitHubProjectBranch(meta, preferredBranch) {
@@ -134850,6 +134904,8 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     }
     queue;
     isStopped = false;
+    static QUEUE_WAIT_WARNING_MS = 1e4;
+    static PROCESSING_WARNING_MS = 3e4;
     enqueue(message, handler) {
       if (this.isStopped) {
         this.logger.debug("MessageProcessor is stopped, ignoring new message");
@@ -134857,11 +134913,30 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
       }
       const sessionId = this.extractSessionId(message);
       const queueKey = this.extractQueueKey(message);
-      this.logger.debug(`Enqueued message type=${message.type} sessionId=${sessionId || "N/A"}`);
+      const queuedAt = Date.now();
+      let started = false;
+      const waitWarning = setInterval(() => {
+        if (started) {
+          return;
+        }
+        this.logger.warn(`Message still waiting in queue type=${message.type} sessionId=${sessionId || "N/A"} queuedFor=${Date.now() - queuedAt}ms active=${this.queue.active} waiting=${this.queue.waiting}`);
+      }, MessageProcessor.QUEUE_WAIT_WARNING_MS);
+      waitWarning.unref?.();
+      this.logger.debug(`Enqueued message type=${message.type} sessionId=${sessionId || "N/A"} active=${this.queue.active} waiting=${this.queue.waiting}`);
       void this.queue.enqueue(queueKey, async () => {
         const startTime = Date.now();
+        started = true;
+        clearInterval(waitWarning);
+        let processingCompleted = false;
+        const processingWarning = setInterval(() => {
+          if (processingCompleted) {
+            return;
+          }
+          this.logger.warn(`Message still processing type=${message.type} sessionId=${sessionId || "N/A"} runningFor=${Date.now() - startTime}ms active=${this.queue.active} waiting=${this.queue.waiting}`);
+        }, MessageProcessor.PROCESSING_WARNING_MS);
+        processingWarning.unref?.();
         try {
-          this.logger.debug(`Processing message type=${message.type} sessionId=${sessionId || "N/A"}`);
+          this.logger.debug(`Processing message type=${message.type} sessionId=${sessionId || "N/A"} queueWait=${startTime - queuedAt}ms active=${this.queue.active} waiting=${this.queue.waiting}`);
           await handler(message);
           const duration2 = Date.now() - startTime;
           this.logger.debug(`Processed message type=${message.type} sessionId=${sessionId || "N/A"} duration=${duration2}ms`);
@@ -134871,6 +134946,9 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
           const err2 = error2 instanceof Error ? error2 : new Error(String(error2));
           this.logger.error(`Failed to process message type=${message.type} sessionId=${sessionId || "N/A"} duration=${duration2}ms: ${err2.message}`);
           this.emit("message:error", err2, message);
+        } finally {
+          processingCompleted = true;
+          clearInterval(processingWarning);
         }
       });
     }
@@ -135235,6 +135313,8 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     }
     async dispatchLocalMessageForResponse(message) {
       const handler = this.requireHandler();
+      const dispatchStartedAt = Date.now();
+      this.options.logger.debug(`Local control dispatch started type=${message.type} sessionId=${"sessionId" in message ? message.sessionId : "N/A"} active=${this.messageProcessor.getActiveSessions()} waiting=${this.messageProcessor.getQueueSize()}`);
       return await new Promise((resolve2, reject) => {
         this.messageProcessor.enqueue(message, async (nextMessage) => {
           const responses = [];
@@ -135244,6 +135324,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
               return;
             }
             settled = true;
+            this.options.logger.debug(`Local control dispatch resolved type=${message.type} sessionId=${"sessionId" in message ? message.sessionId : "N/A"} duration=${Date.now() - dispatchStartedAt}ms responses=${responses.length} active=${this.messageProcessor.getActiveSessions()} waiting=${this.messageProcessor.getQueueSize()}`);
             resolve2([
               ...responses
             ]);
@@ -135253,6 +135334,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
               return;
             }
             settled = true;
+            this.options.logger.debug(`Local control dispatch rejected type=${message.type} sessionId=${"sessionId" in message ? message.sessionId : "N/A"} duration=${Date.now() - dispatchStartedAt}ms: ${error2 instanceof Error ? error2.message : String(error2)}`);
             reject(error2);
           };
           const context2 = {
@@ -142420,7 +142502,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
       await this.workspaceDocument.getOrCreateSessionDoc(config2.sessionId);
       this.logger.debug(`[${config2.sessionId}] Session will enter create inner`);
       const createInnerStart = performance$1.now();
-      const session = await this.createSessionInner(config2);
+      const session = await withSlowOperationWarning(this.createSessionInner(config2), this.logger, "session.createSessionInner", config2.sessionId);
       session.ghTokenInjected = ghTokenInjected;
       const createInnerDurationMs = performance$1.now() - createInnerStart;
       this.logger.debug(`[${config2.sessionId}] Session create inner finished in ${Math.round(createInnerDurationMs)}ms`);
@@ -142441,7 +142523,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
       this.logger.debug(`[${sessionId}] About to call session.createAgent`);
       try {
         const createAgentStart = performance$1.now();
-        acpSessionId = await session.createAgent({
+        acpSessionId = await withSlowOperationWarning(session.createAgent({
           cliType: config2.agentCliType,
           agentType: config2.agentType,
           command: setting.exec.command,
@@ -142501,7 +142583,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
           onCodexImageGenerationEnd: (event) => {
             this.emit("onCodexImageGenerationEnd", sessionId, event);
           }
-        });
+        }), this.logger, `session.createAgent(resume=${requestedResumeSessionId ? "yes" : "no"})`, sessionId);
         const createAgentDurationMs = performance$1.now() - createAgentStart;
         this.logger.debug(`[${sessionId}] Session createAgent finished in ${Math.round(createAgentDurationMs)}ms (acpSessionId=${acpSessionId})`);
         this.logger.debug(`[${sessionId}] createAgent returned successfully`);
@@ -145144,6 +145226,23 @@ Received ${signal}, shutting down gracefully...` : "\nShutting down gracefully..
       shutdown: shutdown2
     };
   }
+  function startEventLoopLagMonitor(logger2, options) {
+    const intervalMs = Math.max(100, options.intervalMs ?? 1e3);
+    const warnThresholdMs = Math.max(intervalMs, options.warnThresholdMs ?? 5e3);
+    let expectedAt = Date.now() + intervalMs;
+    const timer2 = setInterval(() => {
+      const now2 = Date.now();
+      const lagMs = now2 - expectedAt;
+      expectedAt = now2 + intervalMs;
+      if (lagMs >= warnThresholdMs) {
+        logger2.warn(`[event-loop] ${options.label} timer lag detected: fired ${Math.round(lagMs)}ms late (threshold=${warnThresholdMs}ms interval=${intervalMs}ms)`);
+      }
+    }, intervalMs);
+    timer2.unref?.();
+    return {
+      stop: () => clearInterval(timer2)
+    };
+  }
   const ELECTRON_BOOTSTRAP_ENV = "LODY_ELECTRON_BOOTSTRAP";
   const ELECTRON_SESSION_TOKEN_ENV = "LODY_ELECTRON_SESSION_TOKEN";
   const ELECTRON_SESSION_USER_ID_ENV = "LODY_ELECTRON_SESSION_USER_ID";
@@ -145371,7 +145470,13 @@ Received ${signal}, shutting down gracefully...` : "\nShutting down gracefully..
       runtimeStateReporter,
       onFatalAuthFailure: (error2) => triggerFatalAuthShutdown?.(error2)
     });
-    registerProcessCleanup(() => fleet.shutdown());
+    const eventLoopLagMonitor = startEventLoopLagMonitor(logger2, {
+      label: "lody start"
+    });
+    registerProcessCleanup(async () => {
+      eventLoopLagMonitor.stop();
+      await fleet.shutdown();
+    });
     const shutdownSignals = process.platform === "win32" ? [
       "SIGINT",
       "SIGTERM",
@@ -145387,6 +145492,7 @@ Received ${signal}, shutting down gracefully...` : "\nShutting down gracefully..
       logger: logger2,
       shutdown: async () => {
         unregisterProcessCleanup();
+        eventLoopLagMonitor.stop();
         await fleet.shutdown();
       },
       flushTelemetry: () => shutdownPostHog(),
@@ -145425,6 +145531,7 @@ Received ${signal}, shutting down gracefully...` : "\nShutting down gracefully..
       });
       shutdownController.unregister();
       unregisterProcessCleanup();
+      eventLoopLagMonitor.stop();
       await fleet.shutdown().catch((err2) => {
         logger2.error(`Cleanup failed: ${err2 instanceof Error ? err2.message : "Unknown error"}`);
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.52.0",
+  "version": "0.52.2",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
     "node": ">=18.0.0"
   },
   "optionalDependencies": {
-    "acp-extension-claude": "0.34.1",
+    "acp-extension-claude": "0.34.3",
     "acp-extension-codex": "0.14.3"
   },
   "devDependencies": {
@@ -74,10 +74,10 @@
     "ws": "^8.18.3",
     "zod": "^4.1.5",
     "@lody/cli-supervisor": "0.0.1",
-    "@lody/convex": "0.0.1",
     "@lody/loro-streams-rpc": "0.0.1",
+    "@lody/shared": "0.0.1",
     "loro-code": "0.0.1",
-    "@lody/shared": "0.0.1"
+    "@lody/convex": "0.0.1"
   },
   "files": [
     "dist",