fix(agents): preserve stale lock acquire budget

giodl73-repo · giodl73-repo · commit 2696c8b89f94 · 2026-05-30T20:00:25.000-07:00
diff --git a/src/agents/session-write-lock.test.ts b/src/agents/session-write-lock.test.ts
@@ -1179,6 +1179,52 @@ describe("acquireSessionWriteLock", () => {
     });
   });
 
+  it("preserves one acquire timeout budget after stale lock retries", async () => {
+    if (process.platform !== "linux") {
+      return;
+    }
+    await withTempSessionLockFile(async ({ sessionFile, lockPath }) => {
+      let nowMs = 1_000;
+      const dateNowSpy = vi.spyOn(Date, "now").mockImplementation(() => nowMs);
+      const acquireTimeouts: number[] = [];
+      testing.setSessionLockAcquireForTest(async (_targetPath, options) => {
+        acquireTimeouts.push(options.timeoutMs ?? -1);
+        if (acquireTimeouts.length % 2 === 1) {
+          nowMs += 89;
+          throw Object.assign(new Error("stale"), {
+            code: "file_lock_stale",
+            lockPath,
+          });
+        }
+        throw Object.assign(new Error("timeout"), {
+          code: "file_lock_timeout",
+          lockPath,
+        });
+      });
+      try {
+        await expect(
+          acquireSessionWriteLock({
+            sessionFile,
+            timeoutMs: 90,
+            allowReentrant: false,
+          }),
+        ).rejects.toThrow(/session file locked/);
+
+        expect(acquireTimeouts).toEqual([90, 1]);
+        await expect(
+          acquireSessionWriteLock({
+            sessionFile,
+            timeoutMs: 90,
+            allowReentrant: false,
+          }),
+        ).rejects.toThrow(/session file locked/);
+        expect(acquireTimeouts).toEqual([90, 1, 90, 1]);
+      } finally {
+        dateNowSpy.mockRestore();
+      }
+    });
+  });
+
   it("reclaims orphan lock files without starttime when PID matches current process", async () => {
     await withTempSessionLockFile(async ({ sessionFile, lockPath }) => {
       // Simulate an old-format lock file left behind by a previous process
diff --git a/src/agents/session-write-lock.ts b/src/agents/session-write-lock.ts
@@ -3,7 +3,7 @@ import type fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { MAX_TIMER_TIMEOUT_MS } from "@openclaw/normalization-core/number-coercion";
-import { createFileLockManager } from "../infra/file-lock-manager.js";
+import { createFileLockManager, type FileLockManager } from "../infra/file-lock-manager.js";
 import { readGatewayProcessArgsSync as readProcessArgsSync } from "../infra/gateway-processes.js";
 import { getProcessStartTime, isPidAlive } from "../shared/pid-alive.js";
 import { SessionWriteLockTimeoutError } from "./session-write-lock-error.js";
@@ -77,8 +77,10 @@ type LockInspectionDetails = Pick<
   "pid" | "pidAlive" | "createdAt" | "ageMs" | "stale" | "staleReasons"
 >;
 
+type SessionLockAcquire = FileLockManager["acquire"];
 const SESSION_LOCKS = createFileLockManager("openclaw.session-write-lock");
 let resolveProcessStartTimeForLock = getProcessStartTime;
+let acquireSessionLockForTest: SessionLockAcquire | null = null;
 
 function isFileLockError(error: unknown, code: string): boolean {
   return (error as { code?: unknown } | null)?.code === code;
@@ -818,10 +820,24 @@ export async function acquireSessionWriteLock(params: {
   await fs.mkdir(sessionDir, { recursive: true });
 
   while (true) {
+    const elapsedBeforeAcquireMs = Date.now() - startedAt;
+    const acquireTimeoutMs =
+      timeoutMs === Number.POSITIVE_INFINITY
+        ? timeoutMs
+        : Math.max(0, timeoutMs - elapsedBeforeAcquireMs);
+    if (acquireTimeoutMs <= 0) {
+      await throwSessionWriteLockTimeout({
+        timeoutMs,
+        lockPath,
+      });
+    }
+
     try {
-      const lock = await SESSION_LOCKS.acquire(sessionFile, {
+      const acquireSessionLock =
+        acquireSessionLockForTest ?? SESSION_LOCKS.acquire.bind(SESSION_LOCKS);
+      const lock = await acquireSessionLock(sessionFile, {
         staleMs,
-        timeoutMs,
+        timeoutMs: acquireTimeoutMs,
         retry: { minTimeout: 50, maxTimeout: 1000, factor: 1 },
         staleRecovery: "remove-if-unchanged",
         allowReentrant,
@@ -915,6 +931,9 @@ export const testing = {
   setProcessStartTimeResolverForTest(resolver: ((pid: number) => number | null) | null): void {
     resolveProcessStartTimeForLock = resolver ?? getProcessStartTime;
   },
+  setSessionLockAcquireForTest(acquire: SessionLockAcquire | null): void {
+    acquireSessionLockForTest = acquire;
+  },
 };
 
 export async function drainSessionWriteLockStateForTest(): Promise<void> {
@@ -928,5 +947,6 @@ export function resetSessionWriteLockStateForTest(): void {
   stopWatchdogTimer();
   unregisterCleanupHandlers();
   resolveProcessStartTimeForLock = getProcessStartTime;
+  acquireSessionLockForTest = null;
 }
 export { testing as __testing };
