@modelprofile.com/authswitch 10.0.0 → 10.1.0

package/dist_ts/timetext.js

@@ -0,0 +1,88 @@
+/**
+ * Human time text: countdowns to a deadline and timestamps in local calendar time.
+ *
+ * It imports nothing, so the browser-safe `./preuse-text` entry point can render a reset exactly as the
+ * command line does without pulling a Node built-in into a bundle.
+ */
+/** A countdown is a snapshot of the provider's deadline, not proof a quota has reset. */
+export const until = (timestampArg, nowArg) => {
+    if (timestampArg === null)
+        return 'Not scheduled';
+    const remaining = Date.parse(timestampArg) - nowArg;
+    if (!Number.isFinite(remaining))
+        return 'Unavailable';
+    if (remaining <= 0)
+        return 'due';
+    const minutes = Math.floor(remaining / 60000);
+    if (!minutes)
+        return '<1min';
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor(minutes % 1440 / 60);
+    return [days ? `${days}d` : '', hours ? `${hours}h` : '', minutes % 60 ? `${minutes % 60}min` : ''].filter(Boolean).join(' ');
+};
+/**
+ * A two-unit countdown for condensed tables: `2h 13m`, `3d 4h`, `45m`.
+ *
+ * `until` stays the long form used by the list view and the TUI. This one trades the third unit for
+ * a column that never wraps, and it never invents a deadline: an unknown or unparseable timestamp is
+ * reported as such rather than as zero time remaining.
+ */
+const twoUnits = (millisecondsArg) => {
+    const minutes = Math.floor(millisecondsArg / 60000);
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor(minutes % 1440 / 60);
+    if (days)
+        return hours ? `${days}d ${hours}h` : `${days}d`;
+    if (hours)
+        return minutes % 60 ? `${hours}h ${minutes % 60}m` : `${hours}h`;
+    return `${minutes}m`;
+};
+export const compactUntil = (timestampArg, nowArg, unavailableArg = 'n/a') => {
+    if (timestampArg === null)
+        return 'not scheduled';
+    const remaining = Date.parse(timestampArg) - nowArg;
+    if (!Number.isFinite(remaining))
+        return unavailableArg;
+    if (remaining <= 0)
+        return 'due';
+    return remaining < 60000 ? '<1m' : twoUnits(remaining);
+};
+/**
+ * The same two-unit form for a past timestamp, for "saved 3d 4h ago".
+ *
+ * The result is always a bare duration or the caller's unavailable marker, never a phrase: callers
+ * suffix it ("... ago"), and a phrase would read as "just now ago". A span under a minute is `<1m`,
+ * exactly as `compactUntil` reports one.
+ */
+export const compactSince = (timestampArg, nowArg, unavailableArg = 'n/a') => {
+    if (timestampArg === null)
+        return unavailableArg;
+    const elapsed = nowArg - Date.parse(timestampArg);
+    if (!Number.isFinite(elapsed))
+        return unavailableArg;
+    return elapsed < 60000 ? '<1m' : twoUnits(elapsed);
+};
+const twoDigits = (valueArg) => String(valueArg).padStart(2, '0');
+/**
+ * A timestamp in local calendar time: `2026-10-08`, or `2026-10-08 23:14` with the time. Human output never prints
+ * a raw ISO timestamp; an unknown or unparseable one reads as the caller's unavailable marker.
+ */
+const localTimestamp = (timestampArg, withTimeArg, unavailableArg) => {
+    const time = timestampArg === null ? Number.NaN : Date.parse(timestampArg);
+    if (!Number.isFinite(time))
+        return unavailableArg;
+    const date = new Date(time);
+    const day = `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+    return withTimeArg ? `${day} ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}` : day;
+};
+export const localDate = (timestampArg, unavailableArg = 'n/a') => localTimestamp(timestampArg, false, unavailableArg);
+export const localDateTime = (timestampArg, unavailableArg = 'n/a') => localTimestamp(timestampArg, true, unavailableArg);
+/** A moment's local time of day with seconds, `14:02:07`, for a log line whose date is implied. */
+export const localTime = (timeArg) => {
+    const date = new Date(timeArg);
+    return [date.getHours(), date.getMinutes(), date.getSeconds()].map(twoDigits).join(':');
+};
+const ISO_TIMESTAMP = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})/g;
+/** Provider text with every ISO 8601 timestamp in it rewritten as local date and time. */
+export const localiseTimestamps = (textArg) => textArg.replace(ISO_TIMESTAMP, match => localDateTime(match, match));
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/watchpolicy.js

@@ -1,4 +1,5 @@
-import { compactUntil, usagePercentText } from './accounts.js';
+import { usagePercentText } from './accounts.js';
+import { compactUntil } from './timetext.js';
 import { plainText } from './formatting.js';
 /**
  * How far below the threshold a switch target must be on every limit, so that a switch never lands on an account that
@@ -79,4 +80,4 @@ export const decideWatchAction = (inputArg) => {
     }
     return stay(true, `every limit below ${threshold}%`);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "10.0.0",
+  "version": "10.1.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -14,6 +14,10 @@
       "types": "./dist_ts/mutation.d.ts",
       "import": "./dist_ts/mutation.js"
     },
+    "./preuse-text": {
+      "types": "./dist_ts/preuse-text.d.ts",
+      "import": "./dist_ts/preuse-text.js"
+    },
     "./authority-contract": {
       "types": "./dist_ts/authority-contract.d.ts",
       "import": "./dist_ts/authority-contract.js"

package/readme.md

@@ -291,6 +291,26 @@ reason is `outcome_unknown` with problem `request_uncertain` and carries its cau
 (`{ kind, status, providerCode }`, for example `{ "kind": "http", "status": 503, "providerCode": null }`),
 never the provider's text. Human output prints both as sentences.
 
+A host that shows receipts in a browser words them the same way through
+`@modelprofile.com/authswitch/preuse-text`, the browser-safe entry point for those sentences:
+
+```ts
+import { describePreuseFailure, describePreuseLimit, localDateTime } from '@modelprofile.com/authswitch/preuse-text';
+import type { IAuthSwitchPreuseOperation } from '@modelprofile.com/authswitch/authority-contract';
+
+const lines = (operation: IAuthSwitchPreuseOperation): string[] => [
+  ...(operation.limit ? [describePreuseLimit(operation.limit, Date.now())] : []),
+  ...(operation.failure ? [`Cause: ${describePreuseFailure(operation.failure)}`] : []),
+];
+```
+
+`describePreuseLimit(limit, now)` names the window and the limit, and a stated reset as a countdown from
+`now` with the local time (`Weekly usage limit reached, resets in 16h 46min (2026-09-27 05:12)`, or `due
+to reset now` once it has passed); `describePreuseFailure(failure)` names the cause as the tail of a
+sentence (`the provider answered HTTP 503`). `localDateTime(timestamp)` is the local time both use,
+`2026-09-27 05:12`. The module loads nothing but that time text, which imports nothing either; the package
+root exports the same three functions from the same source.
+
 For `account add`, `account reauth` and `account operation resume`, `--json` writes JSON Lines:
 each line is one complete operation receipt, and unchanged revisions are omitted. `account
 operation get --json` and `account operation cancel --json` each write one JSON object followed by
@@ -332,10 +352,21 @@ been adopted. Until a verified `claude_native` import has adopted one, every Cla
 `CLAUDE_CONFIG_DIR` that is not an absolute path is refused when the daemon starts, because the same
 variable also decides which file the import would read; it is never resolved against a working directory.
 
-A switch is only attempted when the host can prove Claude Code uses that native login: exactly the
-verified Claude Code release, a subscriber login in the store, no credential override in the
-environment, no managed or local settings selecting another auth source, and no scoped Claude session
-running. Anything else refuses and leaves both logins where they were. A move that reaches the home and
+A switch is only attempted when the host can prove Claude Code uses that native login: Claude Code
+2.1.273 or newer installed, a subscriber login in the store, no credential override in the environment
+(including the remote well-known token files), no managed or local settings selecting another auth source,
+and every Claude Code session running in that home on a verified release -- one whose lock table, live
+credential pickup and refresh compare-and-swap were read from its bundle, currently 2.1.273 and 2.1.282.
+An installed release above 2.1.273 that is not verified is proven by Claude Code's own answer instead:
+`claude auth status --json` must report the claude.ai login of the outgoing account -- its organization and
+email, the only account identifiers it names -- read from this home and with no API key, before the write,
+and of the incoming account after it. That path runs only while
+no Claude Code session runs in the home. If Claude Code does not report the incoming login after the
+write, or the proof fails for any other reason, the exact outgoing bytes are written back while the locks
+are provably still held and the handoff is aborted with `problem: unsupported_effective_auth`; when they
+cannot be, the home is quarantined. A write whose proof never ran is proven by the reconcile that finds it
+before it can commit. Anything else refuses and leaves
+both logins where they were. A move that reaches the home and
 then cannot complete that proof is quarantined with `problem: unsupported_effective_auth`, and the
 handoff's optional `proofFailure` names which condition failed -- `unsupported_release`, `subscription`,
 `override`, `settings`, `profile`, `profile_unreadable` or `running_session` -- so an owner is told what
@@ -649,7 +680,7 @@ copy's own tokens, and nothing else. `preuse` remains a Codex capability.
 
 **Claude Code picks a switch up live.** A running session re-reads its credential
 file whenever the file changes, before its next request, and reloads `.claude.json`
-when that changes (verified against Claude Code 2.1.273). So `use`, `stash` and a
+when that changes (verified against Claude Code 2.1.273 and 2.1.282). So `use`, `stash` and a
 backend activation never ask for Claude Code to be stopped and never suggest a
 restart; a switch reports `Running Claude Code sessions use it from their next
 request.` What authswitch must not do is write in the middle of that session's own
@@ -773,8 +804,8 @@ such as AGL all read this one rule; `remove` and a save that keeps the login
 active leave the loaded login in place.
 
 That rule, `assertAuthSwitchMutation` and the `TAuthSwitchMutation` command are also
-published on their own at `@modelprofile.com/authswitch/mutation`, which is the one
-import of this package a browser can bundle:
+published on their own at `@modelprofile.com/authswitch/mutation`, which a browser can
+bundle, as it can the preuse sentences at `./preuse-text`:
 
 ```ts
 import { authSwitchMutationReplacesLogin, type TAuthSwitchMutation } from '@modelprofile.com/authswitch/mutation';

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '10.0.0',
+  version: '10.1.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/accounts.ts

@@ -1,5 +1,6 @@
 import type { IAccountType, IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessStatusOptions, IHarnessUsageWindow } from './interfaces.harness.js';
 import { plainText } from './formatting.js';
+import { compactUntil, localDateTime, localiseTimestamps, until } from './timetext.js';
 
 export interface IAccountRow {
   harness: IAuthHarness;
@@ -23,75 +24,6 @@ const WINDOW_PERIODS: ReadonlyMap<number, string> = new Map([[18000, 'five-hour'
  * The narrow table cells stay on the compact form throughout (`5h 37% · 2h 13m`); a column is not a label.
  */
 export const usageWindowPeriod = (secondsArg: number): string => WINDOW_PERIODS.get(secondsArg) ?? duration(secondsArg);
-/** A countdown is a snapshot of the provider's deadline, not proof a quota has reset. */
-export const until = (timestampArg: string | null, nowArg: number): string => {
-  if (timestampArg === null) return 'Not scheduled';
-  const remaining = Date.parse(timestampArg) - nowArg;
-  if (!Number.isFinite(remaining)) return 'Unavailable';
-  if (remaining <= 0) return 'due';
-  const minutes = Math.floor(remaining / 60000);
-  if (!minutes) return '<1min';
-  const days = Math.floor(minutes / 1440);
-  const hours = Math.floor(minutes % 1440 / 60);
-  return [days ? `${days}d` : '', hours ? `${hours}h` : '', minutes % 60 ? `${minutes % 60}min` : ''].filter(Boolean).join(' ');
-};
-/**
- * A two-unit countdown for condensed tables: `2h 13m`, `3d 4h`, `45m`.
- *
- * `until` stays the long form used by the list view and the TUI. This one trades the third unit for
- * a column that never wraps, and it never invents a deadline: an unknown or unparseable timestamp is
- * reported as such rather than as zero time remaining.
- */
-const twoUnits = (millisecondsArg: number): string => {
-  const minutes = Math.floor(millisecondsArg / 60000);
-  const days = Math.floor(minutes / 1440);
-  const hours = Math.floor(minutes % 1440 / 60);
-  if (days) return hours ? `${days}d ${hours}h` : `${days}d`;
-  if (hours) return minutes % 60 ? `${hours}h ${minutes % 60}m` : `${hours}h`;
-  return `${minutes}m`;
-};
-export const compactUntil = (timestampArg: string | null, nowArg: number, unavailableArg = 'n/a'): string => {
-  if (timestampArg === null) return 'not scheduled';
-  const remaining = Date.parse(timestampArg) - nowArg;
-  if (!Number.isFinite(remaining)) return unavailableArg;
-  if (remaining <= 0) return 'due';
-  return remaining < 60000 ? '<1m' : twoUnits(remaining);
-};
-/**
- * The same two-unit form for a past timestamp, for "saved 3d 4h ago".
- *
- * The result is always a bare duration or the caller's unavailable marker, never a phrase: callers
- * suffix it ("... ago"), and a phrase would read as "just now ago". A span under a minute is `<1m`,
- * exactly as `compactUntil` reports one.
- */
-export const compactSince = (timestampArg: string | null, nowArg: number, unavailableArg = 'n/a'): string => {
-  if (timestampArg === null) return unavailableArg;
-  const elapsed = nowArg - Date.parse(timestampArg);
-  if (!Number.isFinite(elapsed)) return unavailableArg;
-  return elapsed < 60000 ? '<1m' : twoUnits(elapsed);
-};
-const twoDigits = (valueArg: number): string => String(valueArg).padStart(2, '0');
-/**
- * A timestamp in local calendar time: `2026-10-08`, or `2026-10-08 23:14` with the time. Human output never prints
- * a raw ISO timestamp; an unknown or unparseable one reads as the caller's unavailable marker.
- */
-const localTimestamp = (timestampArg: string | null, withTimeArg: boolean, unavailableArg: string): string => {
-  const time = timestampArg === null ? Number.NaN : Date.parse(timestampArg);
-  if (!Number.isFinite(time)) return unavailableArg;
-  const date = new Date(time);
-  const day = `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
-  return withTimeArg ? `${day} ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}` : day;
-};
-export const localDate = (timestampArg: string | null, unavailableArg = 'n/a'): string => localTimestamp(timestampArg, false, unavailableArg);
-export const localDateTime = (timestampArg: string | null, unavailableArg = 'n/a'): string => localTimestamp(timestampArg, true, unavailableArg);
-/** A moment's local time of day with seconds, `14:02:07`, for a log line whose date is implied. */
-export const localTime = (timeArg: number): string => {
-  const date = new Date(timeArg);
-  return [date.getHours(), date.getMinutes(), date.getSeconds()].map(twoDigits).join(':');
-};
-const ISO_TIMESTAMP = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})/g;
-/** Provider text with every ISO 8601 timestamp in it rewritten as local date and time. */
-export const localiseTimestamps = (textArg: string): string => textArg.replace(ISO_TIMESTAMP, match => localDateTime(match, match));
 
 /**
  * One sentence for a credential file that no longer holds the account the last switch wrote.

package/ts/classes.authoritycli.ts

@@ -6,7 +6,8 @@ import type { IAuthSwitchImportInventory, IAuthSwitchImportResult, IAuthSwitchIm
   IReq_AuthSwitchImportStatus, TAuthSwitchImportAction } from './authority-import-contract.js';
 import { AuthSwitchClient } from './classes.authorityclient.js';
 import { resolveAuthSwitchAuthorityPaths } from './classes.authorityservice.js';
-import { defaultPreusePrompt, describePreuseFailure, describePreuseLimit, validatePreuseOptions } from './preuse.js';
+import { defaultPreusePrompt, validatePreuseOptions } from './preuse.js';
+import { describePreuseFailure, describePreuseLimit } from './preuse-text.js';
 import { plainText } from './formatting.js';
 import * as plugins from './plugins.js';
 

package/ts/classes.claudeauthority.ts

@@ -418,7 +418,13 @@ export class ClaudeNativeAuthority {
     return publicHandoff(result.handoff);
   }
 
-  private async classify(operationId: string, session: IClaudeNativeLockedSession): Promise<IAuthSwitchClaudeNativeHandoff> {
+  /**
+   * Settles a handoff from what its native home holds. A pair that is exactly the prepared target commits only
+   * once Claude Code is proven to select it: by the switch that just wrote it (`targetProven`), or here, under
+   * this lease -- which is what a restarted daemon relies on for a write whose proof it never ran.
+   */
+  private async classify(operationId: string, session: IClaudeNativeLockedSession,
+    options: { targetProven?: boolean } = {}): Promise<IAuthSwitchClaudeNativeHandoff> {
     const context = await this.database.readClaudeHandoffContext(operationId);
     if (!context) throw new Error('Claude handoff operation is missing.');
     const handoff = context.handoff;
@@ -441,6 +447,14 @@ export class ClaudeNativeAuthority {
     if (handoff.after && samePair(observed, handoff.after)
       && sameIdentity(observed.identity, handoff.targetIdentity)
       && accessDigest === handoff.targetAccessDigest) {
+      if (!options.targetProven) {
+        try { await session.proveEffectiveLogin(await this.unsealLogin(context.incomingAccount, context.incoming)); }
+        catch (error) {
+          // The original bytes are not journaled, so an unproven write cannot be undone here; it is held apart.
+          return this.settle(operationId, 'quarantined', observed.runningEffectiveAuth, 'unsupported_effective_auth',
+            error instanceof ClaudeNativeEffectiveAuthUnsupportedError ? error.reason : null);
+        }
+      }
       return this.settle(operationId, 'committed', observed.runningEffectiveAuth);
     }
     return this.settle(operationId, 'quarantined', observed.runningEffectiveAuth, 'foreign_or_torn');
@@ -504,6 +518,14 @@ export class ClaudeNativeAuthority {
         if (!context || !sameIdentity(before.identity, context.handoff.sourceIdentity) || !before.login) {
           return this.classify(operationId, session);
         }
+        // Claude Code must be running on the outgoing login before anything is written, or nothing here says
+        // what the handoff replaces; nothing is written yet, so the reservation is simply undone.
+        try { await session.proveEffectiveLogin(before.login); }
+        catch (error) {
+          if (!(error instanceof ClaudeNativeEffectiveAuthUnsupportedError)) throw error;
+          return this.settle(operationId, 'aborted', before.runningEffectiveAuth, 'unsupported_effective_auth',
+            error.reason);
+        }
         let outgoingProof: Awaited<ReturnType<IClaudeNativeLockedSession['verifyProfileIdentity']>>;
         try { outgoingProof = await session.verifyProfileIdentity(before, context.handoff.sourceIdentity); }
         catch {
@@ -518,8 +540,20 @@ export class ClaudeNativeAuthority {
         await this.prepare(operationId, loginId, prepared.plan.before, prepared.plan.after,
           outgoingProof.accessTokenDigest, prepared.plan.profile.accessTokenDigest,
           sealedOutgoing, before.runningEffectiveAuth);
-        session.writePreparedIfCurrent(prepared.plan);
-        return this.classify(operationId, session);
+        const written = session.writePreparedIfCurrent(prepared.plan);
+        if (written.kind !== 'written') return this.classify(operationId, session);
+        // Claude Code must now select the incoming login. Whatever keeps that from being proven -- its answer,
+        // a lost lock, a failed read -- is a failed proof: the exact outgoing bytes go back while the locks are
+        // provably still held and the handoff is aborted; if they cannot, the home is quarantined.
+        try { await session.proveEffectiveLogin(incomingLogin); }
+        catch (error) {
+          const reason = error instanceof ClaudeNativeEffectiveAuthUnsupportedError ? error.reason : null;
+          let restored = false;
+          try { restored = session.restorePreparedSource(prepared.plan); } catch { restored = false; }
+          return this.settle(operationId, restored ? 'aborted' : 'quarantined', written.snapshot.runningEffectiveAuth,
+            'unsupported_effective_auth', reason);
+        }
+        return this.classify(operationId, session, { targetProven: true });
       });
     } catch {
       const outcome = await this.reconcileOperation(operationId);

package/ts/classes.claudecodelocks.ts

@@ -17,8 +17,18 @@ interface IClaudeCodeLock {
 interface IHeldLock {
   lockfilePath: string;
   release: () => Promise<void>;
+  /** After how long another process may take this lock over when its time is not renewed. */
+  stale: number;
+  /** The lock directory as it was created for this hold: a takeover removes it and creates another. */
+  identity: { device: number; inode: number; birthtimeMs: number };
 }
 
+/**
+ * How much of a lock's stale time must remain when a lease is asserted. Everything a caller does after an
+ * assertion is a synchronous file write, so no other process can find the lock stale before it completes.
+ */
+const HOLD_MARGIN_MS = 2_000;
+
 export interface IClaudeCodeLocksOptions {
   /** How long an operation waits for a lock that Claude Code holds. */
   timeoutMs?: number;
@@ -26,6 +36,12 @@ export interface IClaudeCodeLocksOptions {
 
 /** The vendor locks may be lost while an awaited database operation is in flight. */
 export interface IClaudeCodeLockLease {
+  /**
+   * Proves, at this moment, that every lock is still this hold's: its directory is the one this hold created,
+   * and its time was renewed recently enough that no other process may take it over before a synchronous write
+   * that follows completes. A lock whose renewal stalled -- an event loop blocked past its update interval --
+   * fails this even when nobody has taken it yet.
+   */
   assertHeld(): void;
 }
 
@@ -134,6 +150,16 @@ export class ClaudeCodeLocks {
     const lease: IClaudeCodeLockLease = {
       assertHeld: () => {
         if (!active || compromised) throw new ClaudeCodeLockOutcomeUnknownError(false);
+        for (const lock of held) {
+          let current: plugins.fs.Stats;
+          try { current = plugins.fs.lstatSync(lock.lockfilePath); }
+          catch { throw new ClaudeCodeLockOutcomeUnknownError(false); }
+          if (!current.isDirectory() || current.dev !== lock.identity.device || current.ino !== lock.identity.inode
+            || current.birthtimeMs !== lock.identity.birthtimeMs
+            || Date.now() - current.mtimeMs > lock.stale - HOLD_MARGIN_MS) {
+            throw new ClaudeCodeLockOutcomeUnknownError(false);
+          }
+        }
       },
     };
     const releaseAll = async (): Promise<void> => {
@@ -189,7 +215,11 @@ export class ClaudeCodeLocks {
         const release = await lockfileArg.lock(lock.file, {
           lockfilePath: lock.lockfilePath, realpath: false, stale: lock.stale, update: lock.update, onCompromised: onCompromisedArg,
         });
-        heldArg.push({ lockfilePath: lock.lockfilePath, release });
+        let created: plugins.fs.Stats;
+        try { created = plugins.fs.lstatSync(lock.lockfilePath); }
+        catch (error) { await release().catch(() => undefined); throw error; }
+        heldArg.push({ lockfilePath: lock.lockfilePath, release, stale: lock.stale,
+          identity: { device: created.dev, inode: created.ino, birthtimeMs: created.birthtimeMs } });
       } catch (error) {
         if (errorCode(error) === 'ELOCKED') return lock;
         if (requireAllArg || !lock.bestEffort) {