What causes "Cannot verify tracker lock ownership at ${lockDir}" in santifer/career-ops?

Inspect /owner.json — if it is corrupt or belongs to a dead process, remove the stale lock directory manually and retry

Cannot verify tracker lock ownership at

Error message

Cannot verify tracker lock ownership at ${lockDir}

What it means

During lock release, if no lock owner is readable but an owner.json still exists inside the lock directory, the code cannot prove who holds the lock and refuses to release, throwing instead of risking a stale/foreign lock removal. This is a safety check against deleting a lock whose ownership is unverifiable (corrupt or unreadable owner.json).

Solutions

Inspect <lockDir>/owner.json — if it is corrupt or belongs to a dead process, remove the stale lock directory manually and retry
Check read permissions on owner.json for the current user (chmod/chown as needed)
Retry release; a transient read race may resolve on a second attempt
If the owning process is confirmed dead, delete the lock dir (rm -rf the lock directory) as a last resort

Example fix

// before
release(tx);  // throws: corrupt owner.json
// after
// remove stale lock, then retry
fs.rmSync(lockDir, { recursive: true, force: true });
release(tx);

Defensive patterns

Strategy: try-catch

Validate before calling

// before releasing, confirm the lock is readable and attributable
const ownerPath = join(lockDir, 'owner.json');
if (existsSync(ownerPath)) {
  JSON.parse(readFileSync(ownerPath, 'utf-8')); // throws early if corrupt
}

Type guard

const canVerifyOwner = (lockDir) => {
  try { return !!readLockOwner(lockDir) || !existsSync(join(lockDir, 'owner.json')); }
  catch { return false; }
};

Try / catch

try {
  tx.release();
} catch (e) {
  if (String(e.message).startsWith('Cannot verify tracker lock ownership')) {
    // inspect/clean stale lock dir, then retry
  }
}

Prevention

Don't kill processes mid-lock-write; use graceful shutdown to release locks
Keep lock directories on local filesystems, not sync tools or NFS
Check lock dir permissions stay consistent across users/containers
Inspect owner.json before manually cleaning lock directories

When it happens

Trigger: Calling tracker transaction release() when the lock directory exists and contains owner.json, but readLockOwner returns null — e.g. owner.json is corrupt/empty JSON, unreadable due to permissions, or was truncated by a crashed process mid-write.

Common situations: A previous process was killed while writing owner.json, leaving invalid JSON; permissions changed between acquire and release (run as different user/container); an antivirus/sync tool (Dropbox) locked or altered owner.json; manually inspecting/cleaning the lock dir and damaging owner.json.

Related errors

AI-assisted analysis of santifer/career-ops@e7abd431fc (2026-09-16). Data as JSON: /api/errors/0822c61595da4f9d. Report an issue: GitHub.

Appendix: source

Thrown at tracker-utils.mjs:456

              currentDir = statSync(lockDir);
            } catch (err) {
              if (err?.code === 'ENOENT') {
                released = true;
                return;
              }
              throw err;
            }
            if (!sameLockDirectory(verifiedDir, currentDir)) {
              released = true;
              return;
            }
            const owner = readLockOwner(lockDir);
            if (owner && owner.token !== token) {
              released = true;
              return;
            }
            if (!owner && existsSync(join(lockDir, 'owner.json'))) {
              throw new Error(`Cannot verify tracker lock ownership at ${lockDir}`);
            }
          } else {
            let beforeRead;
            try {
              beforeRead = statSync(lockDir);
            } catch (err) {
              if (err?.code === 'ENOENT') {
                released = true;
                return;
              }
              throw err;
            }
            const owner = readLockOwner(lockDir);
            if (owner?.token !== token) {
              if (owner) released = true;
              else throw new Error(`Cannot verify tracker lock ownership at ${lockDir}`);
              return;
            }

View on GitHub (pinned to e7abd431fc)