coding-tool-x 3.8.5 → 3.8.6

package/src/platforms/oauth-credentials-service.js

@@ -359,6 +359,14 @@ function httpPost(url, body, headers = {}) {
   });
 }
 
+function parseJsonBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+
 async function fetchClaudeUsage(accessToken) {
   try {
     const result = await httpGet('https://api.anthropic.com/api/oauth/usage', {
@@ -367,38 +375,40 @@ async function fetchClaudeUsage(accessToken) {
       'anthropic-version': '2023-06-01',
       'User-Agent': 'claude-cli/1.0'
     });
-    const data = JSON.parse(result.body);
+    const data = parseJsonBody(result.body);
     return { raw: data, provider: 'claude', statusCode: result.statusCode };
   } catch (err) {
     return { error: err.message, provider: 'claude' };
   }
 }
 
-async function fetchCodexUsage(accessToken) {
-  // Codex uses JWT id_token; decode it to extract user info directly
-  try {
-    const { decodeJwtPayload } = require('../server/services/oauth-utils');
-    const payload = decodeJwtPayload(accessToken);
-    if (payload && (payload.email || payload.sub)) {
-      return {
-        raw: {
-          email: payload.email || '',
-          accountId: payload.sub || '',
-          name: payload.name || ''
-        },
-        provider: 'codex',
-        statusCode: 200
-      };
+function extractCodexAccountId(...tokens) {
+  const { decodeJwtPayload } = require('../server/services/oauth-utils');
+  for (const token of tokens) {
+    if (!token) continue;
+    try {
+      const payload = decodeJwtPayload(token) || {};
+      const accountId = payload.chatgpt_account_id
+        || payload['https://api.openai.com/auth.chatgpt_account_id']
+        || payload['https://api.openai.com/auth']?.chatgpt_account_id
+        || payload.organizations?.[0]?.id;
+      if (accountId) return String(accountId);
+    } catch (_) {
+      // Try the next token; malformed JWTs should not prevent the usage request.
     }
-  } catch (_) {
-    // fall through to API call
   }
+  return '';
+}
+
+async function fetchCodexUsage(accessToken, accountId = '') {
   try {
-    const result = await httpGet('https://api.openai.com/v1/me', {
+    const headers = {
       'Authorization': `Bearer ${accessToken}`,
-      'User-Agent': 'openai-node/4.0.0'
-    });
-    const data = JSON.parse(result.body);
+      'User-Agent': 'codex-cli/0.1'
+    };
+    if (accountId) headers['ChatGPT-Account-Id'] = accountId;
+    const result = await httpGet('https://chatgpt.com/backend-api/wham/usage', headers);
+    const data = parseJsonBody(result.body);
     return { raw: data, provider: 'codex', statusCode: result.statusCode };
   } catch (err) {
     return { error: err.message, provider: 'codex' };
@@ -409,7 +419,7 @@ async function fetchGeminiUsage(accessToken) {
   try {
     const body = JSON.stringify({
       metadata: {
-        ideType: 'ANTIGRAVITY',
+        ideType: 'IDE_UNSPECIFIED',
         platform: 'PLATFORM_UNSPECIFIED',
         pluginType: 'GEMINI'
       }
@@ -421,8 +431,30 @@ async function fetchGeminiUsage(accessToken) {
       'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
       'Client-Metadata': '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}'
     });
-    const data = JSON.parse(result.body);
-    return { raw: data, provider: 'gemini', statusCode: result.statusCode };
+    const loadData = parseJsonBody(result.body) || {};
+    if (result.statusCode < 200 || result.statusCode >= 300) {
+      return { raw: loadData, provider: 'gemini', statusCode: result.statusCode };
+    }
+
+    const project = typeof loadData.cloudaicompanionProject === 'string'
+      ? loadData.cloudaicompanionProject
+      : loadData.cloudaicompanionProject?.id || '';
+    const quotaResult = await httpPost(
+      'https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota',
+      JSON.stringify(project ? { project } : {}),
+      {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'google-api-nodejs-client/9.15.1',
+        'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
+        'Client-Metadata': '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}'
+      }
+    );
+    return {
+      raw: parseJsonBody(quotaResult.body),
+      provider: 'gemini',
+      statusCode: quotaResult.statusCode
+    };
   } catch (err) {
     return { error: err.message, provider: 'gemini' };
   }
@@ -435,31 +467,122 @@ function clampPercent(value) {
   return Math.max(0, Math.min(100, percent));
 }
 
-function normalizeWindow(window, label) {
+function normalizeResetAt(value, resetAfterSeconds) {
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    const milliseconds = numeric < 1e12 ? numeric * 1000 : numeric;
+    const date = new Date(milliseconds);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+  }
+  if (value) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+  }
+  const afterSeconds = Number(resetAfterSeconds);
+  if (Number.isFinite(afterSeconds) && afterSeconds >= 0) {
+    return new Date(Date.now() + afterSeconds * 1000).toISOString();
+  }
+  return null;
+}
+
+function normalizeWindow(window, label, id = '') {
   if (!window || typeof window !== 'object') return null;
-  const usedPercent = clampPercent(window.used_percent ?? window.utilization);
-  if (usedPercent === null) return null;
+  const usedPercent = clampPercent(window.used_percent ?? window.usedPercent ?? window.utilization);
+  const remainingPercent = clampPercent(
+    window.remaining_percent
+      ?? window.remainingPercent
+      ?? window.remaining_fraction
+      ?? window.remainingFraction
+  );
+  if (usedPercent === null && remainingPercent === null) return null;
+  const normalizedUsedPercent = usedPercent === null ? 100 - remainingPercent : usedPercent;
+  const normalizedRemainingPercent = remainingPercent === null ? 100 - usedPercent : remainingPercent;
   return {
+    ...(id ? { id } : {}),
     label,
-    remainingPercent: Math.max(0, Math.min(100, 100 - usedPercent)),
-    usedPercent,
-    resetsAt: window.reset_at || window.resetAt || null
+    remainingPercent: Math.max(0, Math.min(100, normalizedRemainingPercent)),
+    usedPercent: Math.max(0, Math.min(100, normalizedUsedPercent)),
+    resetsAt: normalizeResetAt(
+      window.resets_at
+        ?? window.resetsAt
+        ?? window.reset_at
+        ?? window.resetAt
+        ?? window.reset_time
+        ?? window.resetTime,
+      window.reset_after_seconds ?? window.resetAfterSeconds
+    )
   };
 }
 
+function normalizeGeminiQuota(value) {
+  const buckets = Array.isArray(value?.buckets) ? value.buckets : [];
+  const windows = buckets.map((bucket, index) => {
+    const remainingPercent = clampPercent(bucket?.remainingFraction ?? bucket?.remaining_fraction);
+    if (remainingPercent === null) return null;
+    const modelId = String(bucket?.modelId || bucket?.model_id || '').trim();
+    return {
+      id: `gemini:${modelId || index}`,
+      label: modelId || 'Gemini',
+      remainingPercent,
+      usedPercent: Math.max(0, Math.min(100, 100 - remainingPercent)),
+      resetsAt: normalizeResetAt(bucket?.resetTime || bucket?.reset_time),
+      scope: modelId ? { modelId } : null
+    };
+  }).filter(Boolean);
+  return windows.length ? { status: 'available', windows } : null;
+}
+
 function normalizeOAuthQuota(tool, raw) {
   const value = raw && typeof raw === 'object' ? raw : {};
-  let primary = normalizeWindow(value.five_hour || value.fiveHour, '5h');
-  let secondary = normalizeWindow(value.seven_day || value.sevenDay, '7d');
+  if (tool === 'gemini') {
+    const geminiQuota = normalizeGeminiQuota(value);
+    if (geminiQuota) return { quota: geminiQuota, status: 'available' };
+  }
+
+  let primary = normalizeWindow(value.five_hour || value.fiveHour, '5h', 'primary');
+  let secondary = normalizeWindow(value.seven_day || value.sevenDay, '7d', 'secondary');
   const rateLimit = value.rate_limit || value.rateLimit;
   if (rateLimit) {
-    primary = primary || normalizeWindow(rateLimit.primary_window || rateLimit.primaryWindow, '5h');
-    secondary = secondary || normalizeWindow(rateLimit.secondary_window || rateLimit.secondaryWindow, '7d');
+    primary = primary || normalizeWindow(rateLimit.primary_window || rateLimit.primaryWindow, '5h', 'primary');
+    secondary = secondary || normalizeWindow(rateLimit.secondary_window || rateLimit.secondaryWindow, '7d', 'secondary');
   }
-  if (!primary && !secondary) {
-    return { quota: null, status: 'unsupported', warning: `${tool}: provider did not return 5h/7d quota windows` };
+
+  const additional = [];
+  const additionalLimits = Array.isArray(value.additional_rate_limits)
+    ? value.additional_rate_limits
+    : Array.isArray(value.additionalRateLimits) ? value.additionalRateLimits : [];
+  additionalLimits.forEach((limit, index) => {
+    const additionalRateLimit = limit?.rate_limit || limit?.rateLimit || limit;
+    const name = String(
+      limit?.limit_name || limit?.limitName || limit?.metered_feature || limit?.meteredFeature || '附加额度'
+    ).trim();
+    const additionalPrimary = normalizeWindow(
+      additionalRateLimit?.primary_window || additionalRateLimit?.primaryWindow,
+      `${name} 5h`,
+      `additional:${index}:primary`
+    );
+    const additionalSecondary = normalizeWindow(
+      additionalRateLimit?.secondary_window || additionalRateLimit?.secondaryWindow,
+      `${name} 7d`,
+      `additional:${index}:secondary`
+    );
+    if (additionalPrimary) additional.push(additionalPrimary);
+    if (additionalSecondary) additional.push(additionalSecondary);
+  });
+
+  if (!primary && !secondary && !additional.length) {
+    return { quota: null, status: 'unsupported', warning: `${tool}: provider did not return usable quota windows` };
   }
-  return { quota: { status: 'available', primary, secondary }, status: 'available' };
+  return {
+    quota: {
+      status: 'available',
+      primary,
+      secondary,
+      additional,
+      windows: [primary, secondary, ...additional].filter(Boolean)
+    },
+    status: 'available'
+  };
 }
 
 async function fetchCredentialUsage(tool, credentialId) {
@@ -474,7 +597,10 @@ async function fetchCredentialUsage(tool, credentialId) {
       response = await fetchClaudeUsage(accessToken);
       break;
     case 'codex':
-      response = await fetchCodexUsage(secrets.idToken || accessToken);
+      response = await fetchCodexUsage(
+        accessToken,
+        extractCodexAccountId(secrets.idToken, accessToken) || entry.accountId || secrets.accountId
+      );
       break;
     case 'gemini':
       response = await fetchGeminiUsage(accessToken);
@@ -485,7 +611,7 @@ async function fetchCredentialUsage(tool, credentialId) {
         ? await fetchClaudeUsage(accessToken)
         : providerId.includes('gemini') || providerId.includes('google')
           ? await fetchGeminiUsage(accessToken)
-          : await fetchCodexUsage(accessToken);
+          : await fetchCodexUsage(accessToken, extractCodexAccountId(accessToken) || entry.accountId || secrets.accountId);
       break;
     }
     default:
@@ -502,5 +628,8 @@ module.exports = {
   SUPPORTED_TOOLS,
   syncLocalCredential,
   normalizeOAuthQuota,
-  fetchCredentialUsage
+  fetchCredentialUsage,
+  extractCodexAccountId,
+  normalizeResetAt,
+  normalizeWindow
 };

package/src/server/services/channel-balance.js

@@ -120,6 +120,22 @@ function resolveBalanceToken(channel = {}) {
   );
 }
 
+function isOAuthChannel(channel = {}) {
+  return channel?.authMode === 'oauth';
+}
+
+function resolveOAuthCacheIdentity(channel = {}) {
+  const ref = channel.authRef && typeof channel.authRef === 'object' ? channel.authRef : {};
+  return [
+    channel.oauthProviderId,
+    ref.credentialId,
+    ref.providerId,
+    ref.accountId,
+    ref.identityKey,
+    ref.accountEmail
+  ].map(value => String(value || '').trim()).filter(Boolean).join('|');
+}
+
 function resolveBalanceUserId(channel = {}) {
   const raw = channel.balanceUserId
     ?? channel.platformUserId
@@ -250,6 +266,64 @@ function makeVisibleSnapshot(platform, input, { stale = false, updatedAt = nowIs
   return snapshot;
 }
 
+function formatPercent(value) {
+  const number = parseFiniteNumber(value);
+  if (number == null) return '';
+  return Number.isInteger(number) ? String(number) : number.toFixed(1).replace(/\.0$/, '');
+}
+
+function normalizeOAuthWindows(quota = {}) {
+  const source = quota && typeof quota === 'object' ? quota : {};
+  const candidates = [];
+  if (source.primary) candidates.push({ id: 'primary', ...source.primary });
+  if (source.secondary) candidates.push({ id: 'secondary', ...source.secondary });
+  if (Array.isArray(source.windows)) candidates.push(...source.windows);
+  if (Array.isArray(source.additional)) candidates.push(...source.additional);
+
+  const seen = new Set();
+  return candidates.map((window, index) => {
+    const remainingPercent = parseFiniteNumber(window?.remainingPercent);
+    const usedPercent = parseFiniteNumber(window?.usedPercent);
+    if (remainingPercent == null && usedPercent == null) return null;
+    const id = String(window?.id || `window-${index}`);
+    if (seen.has(id)) return null;
+    seen.add(id);
+    return {
+      id,
+      label: String(window?.label || id),
+      remainingPercent: remainingPercent != null
+        ? Math.max(0, Math.min(100, remainingPercent))
+        : Math.max(0, Math.min(100, 100 - usedPercent)),
+      usedPercent: usedPercent != null
+        ? Math.max(0, Math.min(100, usedPercent))
+        : Math.max(0, Math.min(100, 100 - remainingPercent)),
+      resetsAt: window?.resetsAt || null,
+      scope: window?.scope || null
+    };
+  }).filter(Boolean);
+}
+
+function buildOAuthBalanceSnapshot(platform, quota, { stale = false, updatedAt = nowIso() } = {}) {
+  const windows = normalizeOAuthWindows(quota);
+  if (!windows.length) return makeHiddenSnapshot(platform, { stale, updatedAt });
+
+  const primaryWindows = windows.filter(window => window.id === 'primary' || window.id === 'secondary');
+  const displayWindows = primaryWindows.length ? primaryWindows : windows;
+  const label = displayWindows
+    .map(window => `${window.label} 剩余 ${formatPercent(window.remainingPercent)}%`)
+    .join(' · ');
+
+  return {
+    visible: true,
+    kind: 'oauth-quota',
+    platform,
+    label,
+    windows,
+    updatedAt,
+    stale
+  };
+}
+
 function normalizeBaseUrl(value) {
   const raw = String(value || '').trim();
   if (!raw) return '';
@@ -1483,14 +1557,16 @@ async function probeBalanceFromBase(baseUrl, channel, token) {
 
 function buildCacheKey(source, channel) {
   const token = resolveBalanceToken(channel);
-  const tokenHash = token
-    ? crypto.createHash('sha256').update(token).digest('hex').slice(0, 16)
-    : 'no-token';
+  const identity = isOAuthChannel(channel)
+    ? `oauth:${resolveOAuthCacheIdentity(channel) || channel.id || channel.name || 'unknown'}`
+    : token
+      ? crypto.createHash('sha256').update(token).digest('hex').slice(0, 16)
+      : 'no-token';
   return [
     source,
     channel.id || channel.name || 'unknown',
     normalizeBaseUrl(channel.baseUrl || ''),
-    tokenHash
+    identity
   ].join(':');
 }
 
@@ -1512,6 +1588,44 @@ async function refreshChannelBalanceSnapshot(source, channel, options = {}) {
     return cached.snapshot;
   }
 
+  if (isOAuthChannel(channel)) {
+    try {
+      const { fetchChannelAuthQuota } = require('../../platforms/channel-auth-service');
+      const result = await fetchChannelAuthQuota(source, channel.id, { refresh: force });
+      const snapshot = buildOAuthBalanceSnapshot(source, result?.quota, {
+        updatedAt: result?.checkedAt || nowIso(currentTime)
+      });
+      if (snapshot.visible) {
+        balanceCache.set(key, {
+          snapshot,
+          expiresAt: currentTime + CACHE_TTL_MS
+        });
+        return snapshot;
+      }
+    } catch {
+      // OAuth providers are best-effort; preserve a previous successful quota below.
+    }
+
+    if (cached?.snapshot?.visible) {
+      const staleSnapshot = {
+        ...cached.snapshot,
+        stale: true
+      };
+      balanceCache.set(key, {
+        snapshot: staleSnapshot,
+        expiresAt: currentTime + CACHE_TTL_MS
+      });
+      return staleSnapshot;
+    }
+
+    const hiddenSnapshot = makeHiddenSnapshot(source, { updatedAt: nowIso(currentTime) });
+    balanceCache.set(key, {
+      snapshot: hiddenSnapshot,
+      expiresAt: currentTime + CACHE_TTL_MS
+    });
+    return hiddenSnapshot;
+  }
+
   const bases = buildBaseCandidates(channel.baseUrl);
   if (!bases.length || !resolveBalanceToken(channel)) {
     return makeHiddenSnapshot(null, { updatedAt: nowIso(currentTime) });
@@ -1766,6 +1880,10 @@ module.exports = {
     buildSub2ApiUsageSnapshot,
     resolveStatusPlatform,
     resolveBalanceToken,
+    isOAuthChannel,
+    resolveOAuthCacheIdentity,
+    normalizeOAuthWindows,
+    buildOAuthBalanceSnapshot,
     resolveBalanceUserId,
     buildCookieCandidates,
     build88CodeApiBaseCandidates,

package/src/server/services/network-access.js

@@ -44,7 +44,17 @@ function isSameOriginRequest(req) {
 
   try {
     const originUrl = new URL(origin);
-    return originUrl.host === host;
+    if (originUrl.host === host) {
+      return true;
+    }
+
+    // The Vite dev UI runs on a separate local port and proxies API calls to
+    // the backend. Treat that as local-only traffic, but do not extend this
+    // exception to requests arriving from a LAN or public address.
+    const originHost = String(originUrl.hostname || '').replace(/^\[|\]$/g, '');
+    return (originUrl.protocol === 'http:' || originUrl.protocol === 'https:')
+      && isLoopbackRequest(req)
+      && isLoopbackAddress(originHost);
   } catch (error) {
     return false;
   }

package/src/server/services/session-history-index.js

@@ -19,6 +19,8 @@ const INDEX_INVENTORY_TTL_MS = 30000;
 const INDEX_COLD_WAIT_MS = 1500;
 /** @type {number} Maximum age for a lock whose owner cannot be inspected */
 const INVENTORY_LOCK_STALE_MS = 30 * 60 * 1000;
+/** @type {number} Maximum time a competing inventory waits for the database writer */
+const INVENTORY_LOCK_WAIT_MS = 30000;
 /** @type {number} Number of files parsed before results are released */
 const INVENTORY_PARSE_BATCH_SIZE = 8;
 /** @type {number} Maximum number of files parsed concurrently */
@@ -34,9 +36,8 @@ function _isUsableRuntime(runtime) {
   return !!runtime && typeof runtime === 'object' && typeof runtime.getDriver === 'function';
 }
 
-function _inventoryLockPath(dbPath, source) {
-  const sourceKey = Buffer.from(String(source), 'utf8').toString('hex');
-  return `${dbPath}.${sourceKey}.inventory.lock`;
+function _inventoryLockPath(dbPath) {
+  return `${path.resolve(String(dbPath))}.inventory.lock`;
 }
 
 function _isProcessAlive(pid) {
@@ -50,19 +51,19 @@ function _isProcessAlive(pid) {
 }
 
 /**
- * Acquire a durable per-database/source lock. The in-memory single-flight
+ * Acquire a durable database-wide inventory lock. The in-memory single-flight
  * map only protects requests inside one Node process; production indexing is
  * deliberately performed in child processes, so it cannot prevent two
- * workers from rebuilding the same source after a parent restart.
+ * workers from writing the same database after a parent restart.
  */
 function _tryAcquireInventoryLock(dbPath, source) {
-  const lockPath = _inventoryLockPath(dbPath, source);
+  const lockPath = _inventoryLockPath(dbPath);
 
   for (let attempt = 0; attempt < 2; attempt++) {
     let fd;
     try {
       fd = fs.openSync(lockPath, 'wx');
-      fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), 'utf8');
+      fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, source, startedAt: Date.now() }), 'utf8');
       return { fd, lockPath };
     } catch (error) {
       if (fd !== undefined) {
@@ -81,7 +82,14 @@ function _tryAcquireInventoryLock(dbPath, source) {
     }
 
     const ownerPid = Number(owner?.pid);
-    if (_isProcessAlive(ownerPid) || (!Number.isFinite(ageMs) || ageMs < INVENTORY_LOCK_STALE_MS)) {
+    if (_isProcessAlive(ownerPid)) {
+      return {
+        busy: true,
+        sameSource: owner?.source && String(owner.source) === String(source)
+      };
+    }
+
+    if ((!Number.isInteger(ownerPid) || ownerPid <= 0) && ageMs < INVENTORY_LOCK_STALE_MS) {
       return null;
     }
 
@@ -95,12 +103,91 @@ function _tryAcquireInventoryLock(dbPath, source) {
   return null;
 }
 
+async function _acquireInventoryLock(dbPath, source) {
+  const deadline = Date.now() + INVENTORY_LOCK_WAIT_MS;
+  while (true) {
+    const lock = _tryAcquireInventoryLock(dbPath, source);
+    if (lock?.busy) {
+      if (lock.sameSource) return null;
+    } else if (lock) {
+      return lock;
+    }
+    if (Date.now() >= deadline) return null;
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+}
+
 function _releaseInventoryLock(lock) {
   if (!lock) return;
   try { fs.closeSync(lock.fd); } catch (_err) {}
   try { fs.unlinkSync(lock.lockPath); } catch (_err) {}
 }
 
+/**
+ * Remove inventory locks left by workers that are no longer alive.
+ *
+ * A normal worker releases its lock in `_runInventory`'s finally block. This
+ * fallback is needed for `ctx stop` when a worker is terminated before that
+ * block can run. Locks owned by a live PID are intentionally retained.
+ *
+ * @param {string} [dbPath]
+ * @returns {{ removed: string[], retained: string[] }}
+ */
+function cleanupStaleInventoryLocks(dbPath = PATHS?.sessionHistoryIndex) {
+  const targetPath = dbPath ? path.resolve(String(dbPath)) : '';
+  if (!targetPath) return { removed: [], retained: [] };
+
+  const directory = path.dirname(targetPath);
+  const prefix = `${path.basename(targetPath)}.`;
+  let entries;
+  try {
+    entries = fs.readdirSync(directory);
+  } catch (_) {
+    return { removed: [], retained: [] };
+  }
+
+  const removed = [];
+  const retained = [];
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix) || !entry.endsWith('.inventory.lock')) continue;
+    const lockPath = path.join(directory, entry);
+    let owner = null;
+    let ageMs = 0;
+    try {
+      ageMs = Math.max(0, Date.now() - fs.statSync(lockPath).mtimeMs);
+    } catch (_) {
+      retained.push(lockPath);
+      continue;
+    }
+    try {
+      owner = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    } catch (_) {
+      // Keep malformed young locks; an old one is handled by the stale rule.
+    }
+
+    const ownerPid = Number(owner?.pid);
+    if (_isProcessAlive(ownerPid)) {
+      retained.push(lockPath);
+      continue;
+    }
+
+    // A valid but dead owner can be cleaned immediately. Unreadable lock
+    // files remain protected by the normal acquisition path's stale check.
+    if ((Number.isInteger(ownerPid) && ownerPid > 0) || ageMs >= INVENTORY_LOCK_STALE_MS) {
+      try {
+        fs.unlinkSync(lockPath);
+        removed.push(lockPath);
+      } catch (_) {
+        retained.push(lockPath);
+      }
+    } else {
+      retained.push(lockPath);
+    }
+  }
+
+  return { removed, retained };
+}
+
 
 // ---------------------------------------------------------------------------
 // Schema
@@ -597,18 +684,23 @@ function createSessionHistoryIndex(opts = {}) {
   }
 
   async function _runInventory(source, { force = false, config = indexConfig } = {}) {
-    const db = _getDb();
-    const inventoryLock = _tryAcquireInventoryLock(dbPath, source);
+    // SQLite's writer lock is database-wide, so source-specific lock files do
+    // not prevent two different sources from entering BEGIN IMMEDIATE at the
+    // same time. Acquire one lock for the whole index before opening/schema
+    // initializing the writer connection.
+    const inventoryLock = await _acquireInventoryLock(dbPath, source);
     if (!inventoryLock) {
       // Another process is already doing the expensive work. Existing rows
       // remain readable, and the next scheduled inventory will observe the
       // new source_state timestamp once that worker finishes.
       return;
     }
+    let db = null;
     let errorMsg = null;
     let stateToRecord = null;
 
     try {
+      db = _getDb();
       if (!force && _isSourceFresh(source)) {
         return;
       }
@@ -798,7 +890,9 @@ function createSessionHistoryIndex(opts = {}) {
     } finally {
       if (stateToRecord) {
         try {
-          _recordSourceState(db, source, stateToRecord.lastInventoryMs, stateToRecord.lastError);
+          if (db) {
+            _recordSourceState(db, source, stateToRecord.lastInventoryMs, stateToRecord.lastError);
+          }
         } catch (_err) {}
       }
       _releaseInventoryLock(inventoryLock);
@@ -1494,4 +1588,5 @@ module.exports = {
   invalidateSource,
   getSourceIndexMeta,
   closeSessionHistoryIndex,
+  cleanupStaleInventoryLocks,
 };