@@ -52,4 +52,37 @@ describe('KnowledgeGraphManager cross-process exclusion', () => {
     await manager.createEntities([entity('x')]);
     expect((await manager.readGraph()).entities).toHaveLength(1);
   });
+
+  it('lets exactly one of many simultaneous stale-lock reclaimers win', async () => {
+    // The review case: N waiters all observe the same stale lock. A bare
+    // unlink+open lets the slow waiter delete the fast waiter's fresh lock.
+    await fs.mkdir(testDir, { recursive: true });
+    await fs.writeFile(`${testFilePath}.lock`, 'dead-holder');
+    const old = new Date(Date.now() - 60_000);
+    await fs.utimes(`${testFilePath}.lock`, old, old);
+
+    const managers = Array.from({ length: 8 }, () => new KnowledgeGraphManager(testFilePath));
+    await Promise.all(managers.map((m, i) => m.createEntities([entity(`r${i}`)])));
+
+    const names = (await managers[0].readGraph()).entities.map(e => e.name).sort();
+    expect(names).toEqual(Array.from({ length: 8 }, (_, i) => `r${i}`).sort());
+    await expect(fs.stat(`${testFilePath}.lock`)).rejects.toMatchObject({ code: 'ENOENT' });
+  });
+
+  it("does not let a slow holder's release remove a successor's lock", async () => {
+    // A heartbeating holder must not be stolen from, and a release must never
+    // unlink a lock it does not own.
+    const a = new KnowledgeGraphManager(testFilePath);
+    const b = new KnowledgeGraphManager(testFilePath);
+    const slow = (a as any).withFileLock(async () => {
+      await new Promise(r => setTimeout(r, 400));
+      return 'a-done';
+    });
+    await new Promise(r => setTimeout(r, 50));
+    const fast = b.createEntities([entity('b1')]);
+    expect(await slow).toBe('a-done');
+    await fast;
+    expect((await a.readGraph()).entities.map(e => e.name)).toEqual(['b1']);
+    await expect(fs.stat(`${testFilePath}.lock`)).rejects.toMatchObject({ code: 'ENOENT' });
+  });
 });
@@ -113,10 +113,20 @@ export class KnowledgeGraphManager {
   // each run their own queue and still overwrite each other's load→mutate→save
   // (#1819, #3286). Measured on this commit: 20 writes split across two
   // processes keep exactly 10 — each process serialises its own half and the
-  // last one to write the file wins. A sidecar lock file created with O_EXCL is
-  // atomic on POSIX and Windows and needs no dependency. A lock older than
-  // LOCK_STALE_MS is treated as left behind by a crashed process.
+  // last one to write the file wins.
+  //
+  // The lock is a sidecar file created with O_EXCL (atomic on POSIX and
+  // Windows, no dependency) that contains the holder's token. Three rules make
+  // it ownership-safe, which a bare unlink-and-retry is not:
+  //   1. A live holder heartbeats the lock's mtime, so a long operation is
+  //      never mistaken for a crashed one.
+  //   2. Stale takeover goes through rename(2), not unlink: of N waiters that
+  //      all saw the same stale lock, exactly one rename succeeds; the others
+  //      get ENOENT and retry against the new holder's lock.
+  //   3. Release removes the lock only if it still holds our token, so a
+  //      holder can never delete a replacement's lock.
   private static readonly LOCK_STALE_MS = 30_000;
+  private static readonly LOCK_HEARTBEAT_MS = 5_000;
   private static readonly LOCK_RETRY_MS = 15;
   private static readonly LOCK_TIMEOUT_MS = 10_000;
 
@@ -126,37 +136,71 @@ export class KnowledgeGraphManager {
 
   private async withFileLock<T>(operation: () => Promise<T>): Promise<T> {
     await fs.mkdir(path.dirname(this.memoryFilePath), { recursive: true }).catch(() => {});
+    const token = `${process.pid}:${randomBytes(12).toString('hex')}`;
     const deadline = Date.now() + KnowledgeGraphManager.LOCK_TIMEOUT_MS;
     for (;;) {
       let handle: fs.FileHandle;
       try {
         handle = await fs.open(this.lockFilePath, 'wx');
       } catch (error) {
         if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-        try {
-          const stat = await fs.stat(this.lockFilePath);
-          if (Date.now() - stat.mtimeMs > KnowledgeGraphManager.LOCK_STALE_MS) {
-            await fs.unlink(this.lockFilePath).catch(() => {});
-            continue;
-          }
-        } catch {
-          continue; // the holder released between open and stat; retry now
-        }
+        await this.reclaimIfStale();
         if (Date.now() > deadline) {
           throw new Error(`Timed out waiting for lock ${this.lockFilePath}`);
         }
         await new Promise(resolve => setTimeout(resolve, KnowledgeGraphManager.LOCK_RETRY_MS));
         continue;
       }
+      // Acquired. Record who holds it, then keep it visibly alive.
+      await handle.writeFile(token);
+      await handle.close().catch(() => {});
+      const heartbeat = setInterval(() => {
+        const now = new Date();
+        fs.utimes(this.lockFilePath, now, now).catch(() => {});
+      }, KnowledgeGraphManager.LOCK_HEARTBEAT_MS);
       try {
         return await operation();
       } finally {
-        await handle.close().catch(() => {});
-        await fs.unlink(this.lockFilePath).catch(() => {});
+        clearInterval(heartbeat);
+        await this.releaseIfOwned(token);
       }
     }
   }
 
+  // Take over a lock whose holder has stopped heartbeating. rename(2) is the
+  // arbiter: N waiters may all decide the lock is stale, but only the first
+  // rename succeeds; the rest fail with ENOENT and go back to waiting on
+  // whatever lock the winner creates next.
+  private async reclaimIfStale(): Promise<void> {
+    let stat;
+    try {
+      stat = await fs.stat(this.lockFilePath);
+    } catch {
+      return; // released between our open() and stat(); retry immediately
+    }
+    if (Date.now() - stat.mtimeMs <= KnowledgeGraphManager.LOCK_STALE_MS) return;
+    const tomb = `${this.lockFilePath}.stale.${randomBytes(8).toString('hex')}`;
+    try {
+      await fs.rename(this.lockFilePath, tomb);
+    } catch {
+      return; // another waiter won the reclaim; fall through to retry
+    }
+    await fs.unlink(tomb).catch(() => {});
+  }
+
+  // Remove the lock only if it is still ours. If a (wrongly) stale-reclaimed
+  // lock has since been taken by someone else, their token is in the file and
+  // we must leave it alone.
+  private async releaseIfOwned(token: string): Promise<void> {
+    try {
+      const current = await fs.readFile(this.lockFilePath, 'utf8');
+      if (current !== token) return;
+      await fs.unlink(this.lockFilePath);
+    } catch {
+      // already gone, or unreadable: nothing of ours to remove
+    }
+  }
+
   private async loadGraph(): Promise<KnowledgeGraph> {
     try {
       const data = await fs.readFile(this.memoryFilePath, "utf-8");