chatroom-cli 1.103.0 → 1.103.2

package/dist/index.js

@@ -30445,8 +30445,8 @@ var init_claude_sdk_agent_service = __esm(() => {
                 maxTurns: DEFAULT_MAX_TURNS2,
                 pathToClaudeCodeExecutable: executablePath,
                 includePartialMessages: true,
-                systemPrompt: isFirstQuery && !sdkSession.resumeOnFirstQuery ? sdkSession.storedSystemPrompt : undefined,
-                resume: useResume ? sdkSession.sessionId : undefined,
+                ...isFirstQuery && !sdkSession.resumeOnFirstQuery && sdkSession.storedSystemPrompt !== undefined ? { systemPrompt: sdkSession.storedSystemPrompt } : {},
+                ...useResume && sdkSession.sessionId !== undefined ? { resume: sdkSession.sessionId } : {},
                 settingSources: [],
                 permissionMode: "bypassPermissions",
                 allowDangerouslySkipPermissions: true,
@@ -79539,7 +79539,7 @@ To reconnect, run:`);
         chatroomId: this.chatroomId,
         role: this.role,
         taskId: task._id,
-        messageId: message?._id,
+        ...message?._id !== undefined ? { messageId: message._id } : {},
         convexUrl: getConvexUrl()
       });
       const taskReceivedTime = new Date().toISOString().replace("T", " ").substring(0, 19);
@@ -81229,6 +81229,14 @@ var init_cursor_sdk_config = __esm(() => {
       outputActivity: true,
       processExited: true
     },
+    crashRecovery: {
+      onSessionFailure: {
+        maxAttempts: 6,
+        intervalMs: 1e4,
+        resumeFirstAttempts: 3,
+        recoveryReason: "platform.cursor_sdk_session_reopen"
+      }
+    },
     wireEvents: ["sdk.cursor.message", "sdk.cursor.run.completed", "wire.log.agent_end"]
   };
 });
@@ -103006,6 +103014,25 @@ function resolveResumableHarnessSessionId(snapshot) {
   return snapshot.resumableHarnessSessionId ?? snapshot.harnessSessionId;
 }
 
+// src/daemon/domain/entities/session-recovery-policy.ts
+function resolveSessionRecoveryPolicy(harness, classification2) {
+  const caps = getHarnessCapabilities(harness);
+  if (classification2.hadSessionFailure && caps.crashRecovery?.onSessionFailure) {
+    return caps.crashRecovery.onSessionFailure;
+  }
+  return DEFAULT_CRASH_RECOVERY_POLICY;
+}
+var DEFAULT_CRASH_RECOVERY_POLICY;
+var init_session_recovery_policy = __esm(() => {
+  init_types();
+  DEFAULT_CRASH_RECOVERY_POLICY = {
+    maxAttempts: 1,
+    intervalMs: 0,
+    resumeFirstAttempts: 0,
+    recoveryReason: "platform.crash_recovery"
+  };
+});
+
 // src/daemon/domain/usecase/classify-resume-storm-reason.ts
 function classifyResumeStormReason(logLines) {
   const blob = logLines.join(`
@@ -103114,18 +103141,6 @@ function appendRecentLogLine(slot, line) {
 }
 var RECENT_LOG_LINE_CAP2 = 100;
 
-// src/daemon/domain/usecase/cursor-sdk-session-reopen-retry.ts
-var CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS = 20, CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS = 5000, CURSOR_SDK_SESSION_REOPEN_REASON = "platform.cursor_sdk_session_reopen", CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS = 3;
-
-// src/daemon/domain/usecase/detect-cursor-sdk-run-error.ts
-function isCursorSdkRunErrorInLogs(logLines) {
-  return logLines.some((line) => line.includes(" run-error]"));
-}
-function formatCursorSdkRunErrorMessage(logLines) {
-  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
-  return line?.trim() ?? "Cursor SDK run failed";
-}
-
 // src/daemon/domain/usecase/handle-turn-completed.ts
 async function handleTurnCompleted(deps, input, slot) {
   if (await tryAbortResumeStorm(deps, input, slot)) {
@@ -103262,6 +103277,19 @@ var init_native_spawn_presence = __esm(() => {
   init_execution_kind();
 });
 
+// src/daemon/infrastructure/local/harness/session-monitors/no-op-session-monitor.ts
+var NO_FAILURE, noOpSessionMonitor;
+var init_no_op_session_monitor = __esm(() => {
+  NO_FAILURE = {
+    hadSessionFailure: false,
+    failureKind: "none",
+    recoverable: true
+  };
+  noOpSessionMonitor = {
+    classifyExitFailure: () => NO_FAILURE
+  };
+});
+
 // src/daemon/infrastructure/agent-process-manager/agent-process-manager.ts
 function agentKey3(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
@@ -103271,7 +103299,7 @@ class AgentProcessManager {
   deps;
   slots = new Map;
   lastHarnessSessions = new Map;
-  sessionReopenRetryInFlight = new Set;
+  sessionRecoveryRetryInFlight = new Set;
   exitRetryQueue = [];
   exitRetryTimer = null;
   turnEndQueue = new TurnEndQueue;
@@ -103689,12 +103717,12 @@ class AgentProcessManager {
       });
     }));
     this.resetSlotAfterExit(slot);
-    await this.emitExitEvent(slot, opts, ctx);
+    const exitLifecyclePromise = this.emitExitEvent(slot, opts, ctx);
     try {
       await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
     } catch {}
     this.untrackAllServices(opts.pid);
-    lifecyclePromise.then(() => this.dispatchRestartAfterExit(opts, ctx, key)).catch(() => {});
+    lifecyclePromise.then(() => this.dispatchRestartAfterExit(opts, ctx, key, exitLifecyclePromise)).catch(() => {});
   }
   captureExitContext(slot, opts, stopReason) {
     return {
@@ -103742,7 +103770,7 @@ class AgentProcessManager {
     slot.pendingOperation = undefined;
     slot.nativeTurnPhase = undefined;
   }
-  async emitExitEvent(slot, opts, ctx) {
+  emitExitEvent(slot, opts, ctx) {
     const stopReason = ctx.stopReason;
     const exitArgs = {
       sessionId: this.deps.sessionId,
@@ -103756,14 +103784,14 @@ class AgentProcessManager {
       signal: opts.signal ?? undefined,
       agentHarness: ctx.harness
     };
-    this.recordAgentExit(opts.role, exitArgs, "Failed to record agent exit event");
+    return this.recordAgentExit(opts.role, exitArgs, "Failed to record agent exit event");
   }
   untrackAllServices(pid) {
     for (const service3 of this.deps.agentServices.values()) {
       service3.untrack(pid);
     }
   }
-  dispatchRestartAfterExit(opts, ctx, _key) {
+  dispatchRestartAfterExit(opts, ctx, _key, exitLifecyclePromise) {
     if (this.isStopRequested(opts.chatroomId, opts.role)) {
       return;
     }
@@ -103774,14 +103802,123 @@ class AgentProcessManager {
       }
       return;
     }
-    this.maybeRestartAgent(opts, ctx);
+    this.maybeRestartAgent(opts, ctx, exitLifecyclePromise);
   }
-  hasCursorSdkRunErrorInContext(recentLogLines) {
-    if (!isCursorSdkRunErrorInLogs(recentLogLines)) {
-      return false;
+  maybeRestartAgent(opts, ctx, exitLifecyclePromise) {
+    const { harness, recentLogLines } = ctx;
+    const logs = recentLogLines ?? [];
+    if (!harness || !ctx.workingDir) {
+      console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${ctx.workingDir ?? "none"})`);
+      return;
     }
-    console.log(`[AgentProcessManager] cursor-sdk run-error detected: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
-    return true;
+    const monitor = this.deps.sessionMonitors.get(harness) ?? noOpSessionMonitor;
+    const monitorCtx = {
+      recentLogLines: logs,
+      harness,
+      wantResume: ctx.wantResume
+    };
+    const classification2 = monitor.classifyExitFailure(monitorCtx);
+    this.retrySessionRecovery(opts, ctx, classification2, monitor, monitorCtx, exitLifecyclePromise);
+  }
+  async retrySessionRecovery(opts, ctx, classification2, monitor, monitorCtx, exitLifecyclePromise) {
+    const harness = ctx.harness;
+    const policy = resolveSessionRecoveryPolicy(harness, classification2);
+    const key = agentKey3(opts.chatroomId, opts.role);
+    const multiAttempt = policy.maxAttempts > 1;
+    if (multiAttempt && this.sessionRecoveryRetryInFlight.has(key)) {
+      return;
+    }
+    if (multiAttempt) {
+      this.sessionRecoveryRetryInFlight.add(key);
+    }
+    try {
+      await this.prepareSessionRecoveryBeforeRetry(opts, classification2, exitLifecyclePromise);
+      const lastError = await this.runSessionRecoveryAttempts(opts, ctx, classification2, monitor, monitorCtx, policy, key, multiAttempt);
+      if (lastError === null)
+        return;
+      if (multiAttempt) {
+        const failureMessage = `${harness} session recovery failed after ${policy.maxAttempts} attempts: ${lastError}`;
+        console.log(`[AgentProcessManager] ⛔ ${failureMessage}`);
+        this.emitStartFailedEvent(opts.role, opts.chatroomId, failureMessage);
+      } else {
+        console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${opts.role}: ${lastError}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`   ⚠️  Session recovery retry loop failed: ${message}`);
+      this.emitStartFailedEvent(opts.role, opts.chatroomId, message);
+    } finally {
+      if (multiAttempt) {
+        this.sessionRecoveryRetryInFlight.delete(key);
+      }
+    }
+  }
+  async prepareSessionRecoveryBeforeRetry(opts, classification2, exitLifecyclePromise) {
+    if (!classification2.requiresTaskReleaseBeforeRecovery)
+      return;
+    this.clearLastInFlightTask(opts.chatroomId, opts.role);
+    if (exitLifecyclePromise) {
+      await exitLifecyclePromise;
+    }
+  }
+  async runSessionRecoveryAttempts(opts, ctx, classification2, monitor, monitorCtx, policy, key, multiAttempt) {
+    const generation = this.slots.get(key)?.stopGeneration;
+    let lastError = "unknown";
+    for (let attempt = 1;attempt <= policy.maxAttempts; attempt++) {
+      if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+        return null;
+      if (classification2.hadSessionFailure && policy.resumeFirstAttempts > 0 && attempt === policy.resumeFirstAttempts + 1) {
+        this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
+      }
+      const wantResume = monitor.resolveWantResume?.(attempt, classification2, monitorCtx) ?? (classification2.hadSessionFailure ? false : ctx.wantResume ?? true);
+      if (multiAttempt) {
+        const stored = this.lastHarnessSessions.get(key);
+        const storedSessionId = stored ? resolveResumableHarnessSessionId(stored) : undefined;
+        await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, policy.maxAttempts, attempt > 1 ? lastError : undefined, storedSessionId);
+        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+          return null;
+      }
+      const attemptResult = await this.executeSessionRecoveryAttempt(opts, ctx, policy, wantResume, multiAttempt, generation);
+      if (attemptResult.kind === "success" || attemptResult.kind === "stopped")
+        return null;
+      if (attemptResult.kind === "crash_loop")
+        return null;
+      lastError = attemptResult.lastError;
+      if (attempt < policy.maxAttempts && policy.intervalMs > 0) {
+        await this.deps.clock.delay(policy.intervalMs);
+        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+          return null;
+      }
+    }
+    return lastError;
+  }
+  async executeSessionRecoveryAttempt(opts, ctx, policy, wantResume, multiAttempt, generation) {
+    const harness = ctx.harness;
+    const ensureOpts = {
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      agentHarness: harness,
+      model: ctx.model,
+      workingDir: ctx.workingDir,
+      reason: policy.recoveryReason,
+      wantResume
+    };
+    const result = await this.ensureRunning(ensureOpts);
+    if (result.success)
+      return { kind: "success" };
+    if (this.isStopRequested(opts.chatroomId, opts.role, generation)) {
+      return { kind: "stopped" };
+    }
+    const error51 = result.error ?? "unknown";
+    if (!multiAttempt && result.error === "backoff") {
+      await this.retryCrashRecoveryAfterBackoff(opts, ctx, ensureOpts, result.retryAfterMs);
+      return { kind: "success" };
+    }
+    if (result.error === "crash_loop") {
+      this.handleCrashLoopLimitReached(opts, ctx.recentLogLines);
+      return { kind: "crash_loop" };
+    }
+    return { kind: "failed", lastError: error51 };
   }
   maybeEmitProviderUnavailable(chatroomId, role, slot) {
     if (!slot || slot.harness !== "codex-sdk" || slot.providerUnavailableEmitted)
@@ -103813,48 +103950,6 @@ class AgentProcessManager {
       recoverable: providerUnavailableRecoverable(classification2.reason)
     }).catch(() => {});
   }
-  maybeRestartAgent(opts, ctx) {
-    const { harness, model, workingDir, recentLogLines } = ctx;
-    const logs = recentLogLines ?? [];
-    if (!harness || !workingDir) {
-      console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
-      return;
-    }
-    const hadRunError = this.hasCursorSdkRunErrorInContext(logs);
-    if (harness === "cursor-sdk") {
-      this.retryCursorSdkSessionReopen(opts, ctx, hadRunError);
-      return;
-    }
-    this.attemptCrashRecoveryRestart(opts, ctx, {
-      chatroomId: opts.chatroomId,
-      role: opts.role,
-      agentHarness: harness,
-      model,
-      workingDir,
-      reason: "platform.crash_recovery",
-      wantResume: hadRunError ? false : ctx.wantResume ?? true
-    });
-  }
-  async attemptCrashRecoveryRestart(exitOpts, ctx, ensureOpts) {
-    try {
-      const result = await this.ensureRunning(ensureOpts);
-      if (result.success)
-        return;
-      if (result.error === "backoff") {
-        await this.retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, result.retryAfterMs);
-        return;
-      }
-      if (result.error === "crash_loop") {
-        this.handleCrashLoopLimitReached(exitOpts, ctx.recentLogLines);
-        return;
-      }
-      console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${exitOpts.role}: ${result.error ?? "unknown"}`);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.log(`   ⚠️  Failed to restart agent: ${message}`);
-      this.emitStartFailedEvent(exitOpts.role, exitOpts.chatroomId, message);
-    }
-  }
   async retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, retryAfterMs) {
     if (retryAfterMs === undefined || retryAfterMs <= 0) {
       return;
@@ -103892,71 +103987,6 @@ class AgentProcessManager {
       });
     }
   }
-  resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx) {
-    if (hadRunError && attempt <= CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS) {
-      return true;
-    }
-    if (hadRunError) {
-      return false;
-    }
-    return ctx.wantResume ?? true;
-  }
-  async retryCursorSdkSessionReopen(opts, ctx, hadRunError) {
-    const key = agentKey3(opts.chatroomId, opts.role);
-    if (this.sessionReopenRetryInFlight.has(key)) {
-      return;
-    }
-    this.sessionReopenRetryInFlight.add(key);
-    const generation = this.slots.get(key)?.stopGeneration;
-    const harness = ctx.harness;
-    const model = ctx.model;
-    const workingDir = ctx.workingDir;
-    let lastError = "unknown";
-    try {
-      for (let attempt = 1;attempt <= CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS; attempt++) {
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        if (hadRunError && attempt === CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS + 1) {
-          this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
-        }
-        const wantResume = this.resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx);
-        const stored = this.lastHarnessSessions.get(key);
-        const storedSessionId = stored ? resolveResumableHarnessSessionId(stored) : undefined;
-        await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, attempt > 1 ? lastError : undefined, storedSessionId);
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        const result = await this.ensureRunning({
-          chatroomId: opts.chatroomId,
-          role: opts.role,
-          agentHarness: harness,
-          model,
-          workingDir,
-          reason: CURSOR_SDK_SESSION_REOPEN_REASON,
-          wantResume
-        });
-        if (result.success) {
-          return;
-        }
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        lastError = result.error ?? "unknown";
-        if (attempt < CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS) {
-          await this.deps.clock.delay(CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS);
-          if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-            return;
-        }
-      }
-      const failureMessage = `cursor-sdk session reopen failed after ${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS} attempts: ${lastError}`;
-      console.log(`[AgentProcessManager] ⛔ ${failureMessage}`);
-      this.emitStartFailedEvent(opts.role, opts.chatroomId, failureMessage);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.log(`   ⚠️  cursor-sdk session reopen retry loop failed: ${message}`);
-      this.emitStartFailedEvent(opts.role, opts.chatroomId, message);
-    } finally {
-      this.sessionReopenRetryInFlight.delete(key);
-    }
-  }
   emitStartFailedEvent(role, chatroomId, error51) {
     logDaemonAuditEvent(this.deps.logEvent, {
       type: "agent.startFailed",
@@ -104166,7 +104196,11 @@ class AgentProcessManager {
       this.queueExitRetry({ role, args: exitArgs });
     });
     const emittedAt = this.deps.clock.now();
-    this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).catch((err) => console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`));
+    return this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).then(() => {
+      return;
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`);
+    });
   }
   async clearAgentPidQuietly(chatroomId, role) {
     try {
@@ -104344,7 +104378,7 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${err.message}`);
     }
   }
-  async emitSessionReopenRetry(chatroomId, role, attempt, error51, harnessSessionId) {
+  async emitSessionReopenRetry(chatroomId, role, attempt, maxAttempts, error51, harnessSessionId) {
     try {
       await logDaemonAuditEvent(this.deps.logEvent, {
         type: "agent.sessionReopenRetry",
@@ -104352,7 +104386,7 @@ class AgentProcessManager {
         role,
         machineId: this.deps.machineId,
         attempt,
-        maxAttempts: CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS,
+        maxAttempts,
         ...error51 ? { error: error51 } : {},
         ...harnessSessionId ? { harnessSessionId } : {}
       });
@@ -104362,11 +104396,11 @@ class AgentProcessManager {
         chatroomId,
         role,
         attempt,
-        maxAttempts: CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS,
+        maxAttempts,
         ...error51 ? { error: error51 } : {},
         ...harnessSessionId ? { harnessSessionId } : {}
       });
-      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionReopenRetry for ${role} (attempt ${attempt}/${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS})`);
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionReopenRetry for ${role} (attempt ${attempt}/${maxAttempts})`);
     } catch (err) {
       console.log(`   ⚠️  Failed to emit sessionReopenRetry event: ${err.message}`);
     }
@@ -104945,6 +104979,7 @@ var init_agent_process_manager = __esm(() => {
   init_agent_lifecycle_runtime();
   init_agent_lifecycle_types();
   init_agent_stop();
+  init_session_recovery_policy();
   init_spawn_policy();
   init_abort_resume_storm();
   init_classify_provider_error();
@@ -104956,6 +104991,99 @@ var init_agent_process_manager = __esm(() => {
   init_native_task_delivery_coordinator();
   init_native_turn_phase2();
   init_native_spawn_presence();
+  init_no_op_session_monitor();
+});
+
+// src/daemon/domain/usecase/cursor-sdk-session-reopen-retry.ts
+var CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS = 3;
+
+// src/daemon/domain/usecase/detect-cursor-sdk-run-error.ts
+function isCursorSdkRunErrorInLogs(logLines) {
+  return logLines.some((line) => line.includes(" run-error]"));
+}
+function formatCursorSdkRunErrorMessage(logLines) {
+  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
+  return line?.trim() ?? "Cursor SDK run failed";
+}
+function isCursorSdkAuthErrorInLogs(logLines) {
+  if (classifyResumeStormReason(logLines) !== "auth_error")
+    return false;
+  return logLines.some((line) => line.includes("[cursor-sdk:"));
+}
+function hasCursorSdkSessionReopenTrigger(logLines) {
+  return isCursorSdkRunErrorInLogs(logLines) || isCursorSdkAuthErrorInLogs(logLines);
+}
+var init_detect_cursor_sdk_run_error = __esm(() => {
+  init_classify_resume_storm_reason();
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/cursor-sdk-session-monitor.ts
+var cursorSdkSessionMonitor;
+var init_cursor_sdk_session_monitor = __esm(() => {
+  init_detect_cursor_sdk_run_error();
+  cursorSdkSessionMonitor = {
+    classifyExitFailure(ctx) {
+      const logs = ctx.recentLogLines;
+      if (!hasCursorSdkSessionReopenTrigger(logs)) {
+        return { hadSessionFailure: false, failureKind: "none", recoverable: true };
+      }
+      const auth = isCursorSdkAuthErrorInLogs(logs);
+      console.log(`[CursorSdkSessionMonitor] session failure detected: ${formatCursorSdkRunErrorMessage(logs)}`);
+      return {
+        hadSessionFailure: true,
+        failureKind: auth ? "auth_error" : "run_error",
+        recoverable: true,
+        requiresTaskReleaseBeforeRecovery: auth
+      };
+    },
+    resolveWantResume(attempt, classification2, ctx) {
+      if (classification2.hadSessionFailure && attempt <= CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS) {
+        return true;
+      }
+      if (classification2.hadSessionFailure) {
+        return false;
+      }
+      return ctx.wantResume ?? true;
+    }
+  };
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/session-monitor-registry.ts
+function registerSessionMonitor(harnessId, monitor) {
+  registry3.set(harnessId, monitor);
+}
+function getSessionMonitor(harnessId) {
+  return registry3.get(harnessId);
+}
+function getAllSessionMonitors() {
+  return new Map(registry3);
+}
+var registry3;
+var init_session_monitor_registry = __esm(() => {
+  registry3 = new Map;
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/init-session-monitors.ts
+function initSessionMonitorRegistry() {
+  if (initialized2)
+    return;
+  for (const harness of AGENT_HARNESSES) {
+    registerSessionMonitor(harness, harness === "cursor-sdk" ? cursorSdkSessionMonitor : noOpSessionMonitor);
+  }
+  for (const service3 of getAllHarnesses()) {
+    if (!getSessionMonitor(service3.id)) {
+      registerSessionMonitor(service3.id, noOpSessionMonitor);
+    }
+  }
+  initialized2 = true;
+}
+var initialized2 = false;
+var init_init_session_monitors = __esm(() => {
+  init_agent2();
+  init_cursor_sdk_session_monitor();
+  init_no_op_session_monitor();
+  init_session_monitor_registry();
+  init_registry2();
 });
 
 // src/daemon/entry/init-daemon.ts
@@ -105019,6 +105147,7 @@ function assembleDaemonSessionInit(args2) {
     config: config4,
     convexUrl,
     agentServices,
+    sessionMonitors,
     cachedModels,
     deps
   } = args2;
@@ -105035,6 +105164,7 @@ function assembleDaemonSessionInit(args2) {
     }),
     logSink: activeLogSink,
     agentServices,
+    sessionMonitors,
     backend: deps.backend,
     sessionId: typedSessionId,
     machineId,
@@ -105216,11 +105346,13 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   const config4 = yield* setupMachineEffect();
   const { machineId } = config4;
   initHarnessRegistry();
+  initSessionMonitorRegistry();
   const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
+  const sessionMonitors = getAllSessionMonitors();
   yield* registerMachineEffect(client4, typedSessionId, config4);
   const cachedModels = yield* fetchCachedMachineModelsEffect(client4, typedSessionId, machineId);
   yield* connectDaemonEffect(client4, typedSessionId, machineId);
-  return { typedSessionId, config: config4, machineId, agentServices, cachedModels };
+  return { typedSessionId, config: config4, machineId, agentServices, sessionMonitors, cachedModels };
 }), activeLogSink, activeLogEvent, connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
   try: () => client4.mutation(api.machines.updateDaemonStatus, {
     sessionId: asConvexSessionId(sessionId),
@@ -105308,6 +105440,8 @@ var init_init_daemon = __esm(() => {
   init_agent_process_manager();
   init_registry3();
   init_services2();
+  init_init_session_monitors();
+  init_session_monitor_registry();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
   initDaemonEffect = exports_Effect.gen(function* () {
     const lockAcquired = yield* exports_Effect.tryPromise({
@@ -105337,7 +105471,7 @@ var init_init_daemon = __esm(() => {
       try: () => getConvexClient(),
       catch: (e) => e
     });
-    const { typedSessionId, config: config4, machineId, agentServices, cachedModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
+    const { typedSessionId, config: config4, machineId, agentServices, sessionMonitors, cachedModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
     const init2 = assembleDaemonSessionInit({
       client: client4,
       typedSessionId,
@@ -105345,6 +105479,7 @@ var init_init_daemon = __esm(() => {
       config: config4,
       convexUrl,
       agentServices,
+      sessionMonitors,
       cachedModels,
       deps: createDefaultDeps22()
     });
@@ -110224,8 +110359,9 @@ var init_on_request_stop_agent = __esm(() => {
 // src/daemon/entry/events/agent/on-stop-scope-agent.ts
 var onStopScopeAgentEffect = (event) => exports_Effect.gen(function* () {
   const agentMgr = yield* DaemonAgentProcessManagerService;
-  if (agentMgr.runInboxScopedStop)
-    yield* agentMgr.runInboxScopedStop(event);
+  const stop4 = agentMgr.runInboxScopedStop;
+  if (stop4)
+    yield* stop4(event);
 });
 var init_on_stop_scope_agent = __esm(() => {
   init_esm();
@@ -111779,13 +111915,6 @@ var init_file_content_subscription = __esm(() => {
   init_daemon_services();
 });
 
-// src/infrastructure/services/workspace/file-tree-data-hash.ts
-import { createHash as createHash6 } from "node:crypto";
-function computeFileTreeDataHash(tree) {
-  return createHash6("md5").update(JSON.stringify(tree)).digest("hex");
-}
-var init_file_tree_data_hash = () => {};
-
 // src/infrastructure/services/workspace/file-tree-sync-ranker.ts
 function fileExtension(p) {
   const b = (p.split("/").pop() ?? p).toLowerCase();
@@ -112606,6 +112735,13 @@ var init_file_tree_scanner = __esm(() => {
   init_workspace_visibility_policy();
 });
 
+// src/infrastructure/services/workspace/file-tree-data-hash.ts
+import { createHash as createHash6 } from "node:crypto";
+function computeFileTreeDataHash(tree) {
+  return createHash6("md5").update(JSON.stringify(tree)).digest("hex");
+}
+var init_file_tree_data_hash = () => {};
+
 // src/infrastructure/services/workspace/git-workspace-porcelain.ts
 import { existsSync as existsSync9 } from "node:fs";
 import path4 from "node:path";
@@ -115939,6 +116075,17 @@ var init_workspace_file_tree_delta_send = __esm(() => {
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage(err)}`);
 }
+async function runOneShotFileTreeSync(session2, workingDir) {
+  const normalized = normalizeWorkingDirForLookup(workingDir);
+  const tree = await scanFileTree(normalized);
+  const send = createWorkspaceFileTreeCheckpointSend(session2, normalized);
+  await send({ tree, revision: 0 });
+  await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalized
+  });
+}
 async function stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized) {
   const coordinatorPromise = coordinators.get(normalized);
   if (!coordinatorPromise)
@@ -115947,8 +116094,8 @@ async function stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegist
   await coordinatorPromise.then((coordinator2) => coordinator2.stop()).catch(() => {
     return;
   });
-  await checkpointOutboxRegistry.stop(normalized);
-  await deltaOutboxRegistry.stop(normalized);
+  await checkpointOutboxRegistry?.stop(normalized);
+  await deltaOutboxRegistry?.stop(normalized);
 }
 async function drainPendingFileTreeReleaseRequests(session2, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry) {
   const releases = await session2.backend.query(api.workspaceFiles.getPendingFileTreeReleaseRequests, {
@@ -115973,7 +116120,36 @@ async function drainPendingFileTreeReleaseRequests(session2, coordinators, check
     });
   }
 }
-async function processPendingFileTreeRequests(session2, coordinators, ensureCoordinator, requests) {
+async function processOnePendingFileTreeRequest(session2, coordinators, ensureCoordinator, normalized, force, checkpointOutboxRegistry, deltaOutboxRegistry) {
+  const start3 = Date.now();
+  const lease = await session2.backend.query(api.workspaceFiles.getFileTreeWatchLease, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalized
+  });
+  if (!lease?.leaseActive) {
+    await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+    await runOneShotFileTreeSync(session2, normalized);
+    console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree ready: ${normalized} (${Date.now() - start3}ms, one-shot)`);
+    return;
+  }
+  await ensureCoordinator(normalized, force);
+  await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalized
+  });
+  const leaseAfterFulfill = await session2.backend.query(api.workspaceFiles.getFileTreeWatchLease, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalized
+  });
+  if (!leaseAfterFulfill?.leaseActive) {
+    await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+  }
+  console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree ready: ${normalized} (${Date.now() - start3}ms${force ? ", reconciled" : ", cached"})`);
+}
+async function processPendingFileTreeRequests(session2, coordinators, ensureCoordinator, requests, checkpointOutboxRegistry, deltaOutboxRegistry) {
   if (!requests?.length)
     return;
   const requestsByDir = new Map;
@@ -115983,25 +116159,20 @@ async function processPendingFileTreeRequests(session2, coordinators, ensureCoor
   }
   for (const [normalized, force] of requestsByDir) {
     await enqueueFileTreeSync(session2.machineId, normalized, async () => {
-      const start3 = Date.now();
-      await ensureCoordinator(normalized, force).then(() => session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        workingDir: normalized
-      })).then(() => {
-        console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree ready: ${normalized} (${Date.now() - start3}ms${force ? ", reconciled" : ", cached"})`);
-      }).catch((err) => {
+      try {
+        await processOnePendingFileTreeRequest(session2, coordinators, ensureCoordinator, normalized, force, checkpointOutboxRegistry, deltaOutboxRegistry);
+      } catch (err) {
         logSubscriptionWarn(`File tree failed for ${normalized}`, err);
-      });
+      }
     });
   }
 }
-async function drainPendingFileTreeRequests(session2, coordinators, ensureCoordinator) {
+async function drainPendingFileTreeRequests(session2, coordinators, ensureCoordinator, checkpointOutboxRegistry, deltaOutboxRegistry) {
   const requests = await session2.backend.query(api.workspaceFiles.getPendingFileTreeRequests, {
     sessionId: session2.sessionId,
     machineId: session2.machineId
   });
-  await processPendingFileTreeRequests(session2, coordinators, ensureCoordinator, requests);
+  await processPendingFileTreeRequests(session2, coordinators, ensureCoordinator, requests, checkpointOutboxRegistry, deltaOutboxRegistry);
 }
 var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
@@ -116050,7 +116221,7 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
     });
   };
   return {
-    drainPendingFileTreeRequests: () => drainPendingFileTreeRequests(session2, coordinators, ensureCoordinator),
+    drainPendingFileTreeRequests: () => drainPendingFileTreeRequests(session2, coordinators, ensureCoordinator, checkpointOutboxRegistry, deltaOutboxRegistry),
     drainPendingFileTreeReleaseRequests: () => drainPendingFileTreeReleaseRequests(session2, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry),
     stop: () => {
       (async () => {
@@ -116066,6 +116237,7 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
 var init_file_tree_subscription = __esm(() => {
   init_esm();
   init_api3();
+  init_file_tree_scanner();
   init_workspace_file_tree_coordinator();
   init_workspace_sync_queue();
   init_convex_error();
@@ -134334,7 +134506,9 @@ var init_opencode_install = __esm(() => {
 
 // src/infrastructure/retry-queue.ts
 async function withRetry(fn2, opts) {
-  const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULTS, ...opts };
+  const maxRetries = opts?.maxRetries ?? DEFAULTS.maxRetries;
+  const baseDelayMs = opts?.baseDelayMs ?? DEFAULTS.baseDelayMs;
+  const maxDelayMs = opts?.maxDelayMs ?? DEFAULTS.maxDelayMs;
   for (let attempt = 0;attempt <= maxRetries; attempt++) {
     try {
       return await fn2();
@@ -134957,4 +135131,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1C27BCC36565FE7A64756E2164756E21
+//# debugId=56DD8E367644E33A64756E2164756E21