litclaude-ai 0.4.3 → 0.4.4

package/plugins/litclaude/lib/owner-lock.mjs

@@ -14,6 +14,13 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import {
+  directoryIdentity,
+  pathIdentity,
+  sameDirectoryIdentity,
+  samePathIdentity,
+} from "./secure-path-read.mjs";
+
 const MAX_OWNER_BYTES = 4096;
 const sleepSync = (milliseconds) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 const monotonicNowMs = () => Number(process.hrtime.bigint()) / 1_000_000;
@@ -28,7 +35,7 @@ export class OwnerLockError extends Error {
 
 const ownerPathFor = (lockDir) => join(lockDir, "owner.json");
 const safeReceiptToken = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/u.test(value);
-const sameDirectory = (left, right) => left?.dev === right?.dev && left?.ino === right?.ino;
+const sameDirectory = sameDirectoryIdentity;
 
 const assertLockDirectory = (lockDir, expected) => {
   const details = lstatSync(lockDir, { throwIfNoEntry: false });
@@ -36,13 +43,52 @@ const assertLockDirectory = (lockDir, expected) => {
   if (details.isSymbolicLink() || !details.isDirectory()) {
     throw new OwnerLockError("owner lock path must be a regular directory", 65);
   }
-  const identity = { dev: details.dev, ino: details.ino };
+  const identity = directoryIdentity(details);
   if (expected && !sameDirectory(identity, expected)) {
     throw new OwnerLockError("owner lock directory changed", 65);
   }
   return identity;
 };
 
+// Destructive cleanup is commit-by-rename: once the checked path is moved to a private
+// quarantine, a pathname replacement cannot make us remove the replacement. Re-checking the
+// moved entry catches Linux inode reuse (ctime/birthtime differ even when dev+ino are forged).
+const removeVerifiedPath = (path, expectedIdentity, expectedDirectory, quarantinePath, verify) => {
+  if (expectedDirectory) assertLockDirectory(dirname(path), expectedDirectory);
+  const current = lstatSync(path, { throwIfNoEntry: false });
+  const matches = (stat) => {
+    if (!stat) return false;
+    if (expectedIdentity?.ctimeMs === undefined) {
+      return stat.isDirectory() && !stat.isSymbolicLink()
+        && sameDirectoryIdentity(directoryIdentity(stat), expectedIdentity);
+    }
+    return stat.isFile() && !stat.isSymbolicLink() && stat.nlink === 1
+      && samePathIdentity(pathIdentity(stat), expectedIdentity);
+  };
+  if (!current || !matches(current)) return false;
+  const quarantine = quarantinePath ?? `${path}.remove.${randomUUID()}`;
+  try {
+    renameSync(path, quarantine);
+    const moved = lstatSync(quarantine, { throwIfNoEntry: false });
+    const movedMatches = expectedIdentity?.ctimeMs === undefined
+      ? matches(moved)
+      : sameDirectoryIdentity(directoryIdentity(moved), {
+        dev: expectedIdentity.dev,
+        ino: expectedIdentity.ino,
+        birthtimeMs: expectedIdentity.birthtimeMs,
+      });
+    if (!moved || !movedMatches) throw new Error("identity changed");
+    if (verify && !verify(quarantine)) throw new Error("entry content changed");
+    rmSync(quarantine, { recursive: true, force: true });
+    return true;
+  } catch {
+    try {
+      if (!lstatSync(path, { throwIfNoEntry: false })) renameSync(quarantine, path);
+    } catch { /* Leave uncertain quarantine state for the caller to inspect. */ }
+    return false;
+  }
+};
+
 const processIsAlive = (pid) => {
   if (!Number.isSafeInteger(pid) || pid <= 0) return false;
   try {
@@ -64,8 +110,7 @@ export const readOwnerLock = (lockDir) => {
     const openedStats = fstatSync(fd);
     if (
       !openedStats.isFile()
-      || openedStats.dev !== pathStats.dev
-      || openedStats.ino !== pathStats.ino
+      || !samePathIdentity(pathIdentity(openedStats), pathIdentity(pathStats))
       || openedStats.size !== pathStats.size
     ) return null;
     const owner = JSON.parse(readFileSync(fd, "utf8"));
@@ -96,8 +141,7 @@ const readTakeoverClaim = (lockDir, name, ownerNonce) => {
     const openedStats = fstatSync(fd);
     if (
       !openedStats.isFile()
-      || openedStats.dev !== pathStats.dev
-      || openedStats.ino !== pathStats.ino
+      || !samePathIdentity(pathIdentity(openedStats), pathIdentity(pathStats))
       || openedStats.size !== pathStats.size
     ) return null;
     const text = readFileSync(fd, "utf8");
@@ -114,7 +158,7 @@ const readTakeoverClaim = (lockDir, name, ownerNonce) => {
       && claim.pid > 0
       && Number.isFinite(claim.acquired_at_ms)
       && claim.acquired_at_ms >= 0
-    ) return claim;
+    ) return { claim, identity: pathIdentity(pathStats), text };
 
     const legacyPidText = text.trim();
     const legacyPid = Number(legacyPidText);
@@ -127,10 +171,14 @@ const readTakeoverClaim = (lockDir, name, ownerNonce) => {
       || pathStats.mtimeMs < 0
     ) return null;
     return {
-      owner_nonce: ownerNonce,
-      claimant_nonce: `legacy-${legacyPid}`,
-      pid: legacyPid,
-      acquired_at_ms: pathStats.mtimeMs,
+      claim: {
+        owner_nonce: ownerNonce,
+        claimant_nonce: `legacy-${legacyPid}`,
+        pid: legacyPid,
+        acquired_at_ms: pathStats.mtimeMs,
+      },
+      identity: pathIdentity(pathStats),
+      text,
     };
   } catch {
     return null;
@@ -155,14 +203,22 @@ const takeoverWinner = (lockDir, incumbent, ownClaim, staleAfter, expectedLockDi
   const active = [];
   for (const name of names) {
     assertLockDirectory(lockDir, expectedLockDirectory);
-    const claim = readTakeoverClaim(lockDir, name, incumbent.nonce);
-    if (claim === null) return null;
+    const claimRecord = readTakeoverClaim(lockDir, name, incumbent.nonce);
+    if (claimRecord === null) return null;
+    const { claim, identity, text } = claimRecord;
     const alive = processIsAlive(claim.pid);
     const oldEnough = Date.now() - claim.acquired_at_ms >= staleAfter;
     if (!alive && oldEnough) {
       try {
         assertLockDirectory(lockDir, expectedLockDirectory);
-        rmSync(join(lockDir, name));
+        const claimPath = join(lockDir, name);
+        if (!removeVerifiedPath(
+          claimPath,
+          identity,
+          expectedLockDirectory,
+          undefined,
+          (quarantine) => readFileSync(quarantine, "utf8") === text,
+        )) return null;
       } catch (error) {
         if (error?.code !== "ENOENT") return null;
       }
@@ -199,7 +255,7 @@ export const acquireOwnerLock = (lockDir, { timeoutMs = 500, staleMs = 30_000 }
       } catch {
         try {
           assertLockDirectory(lockDir, lockDirectory);
-          rmSync(lockDir, { recursive: true, force: true });
+          if (!removeVerifiedPath(lockDir, lockDirectory)) throw new Error("lock directory changed");
         } catch { /* Leave uncertain state fail-closed. */ }
         throw new OwnerLockError("lock ownership receipt failed", 65);
       }
@@ -237,8 +293,13 @@ export const acquireOwnerLock = (lockDir, { timeoutMs = 500, staleMs = 30_000 }
             const current = readOwnerLock(lockDir);
             if (current?.nonce === incumbent.nonce && current.pid === incumbent.pid) {
               assertLockDirectory(lockDir, lockDirectory);
-              renameSync(lockDir, displaced);
-              rmSync(displaced, { recursive: true, force: true });
+              if (!removeVerifiedPath(lockDir, lockDirectory, undefined, displaced,
+                (quarantine) => {
+                  const replacementOwner = readOwnerLock(quarantine);
+                  return replacementOwner?.nonce === incumbent.nonce && replacementOwner.pid === incumbent.pid;
+                })) {
+                throw new Error("stale lock directory changed");
+              }
               continue;
             }
           }

package/plugins/litclaude/lib/rules/engine.mjs

@@ -27,6 +27,7 @@ import { parseRuleFile } from "./frontmatter.mjs";
 import { isStaticRule, matchRule } from "./matcher.mjs";
 import { sortCandidates } from "./ordering.mjs";
 import { claimInjectedKeys, ruleKey } from "./session-state.mjs";
+import { pathIdentity, samePathIdentity } from "../secure-path-read.mjs";
 
 const MAX_RULE_FILE_BYTES = 256 * 1024;
 
@@ -49,8 +50,7 @@ const readCandidateBounded = (candidate) => {
     const openedStats = fstatSync(fd);
     if (
       !openedStats.isFile()
-      || openedStats.dev !== pathStats.dev
-      || openedStats.ino !== pathStats.ino
+      || !samePathIdentity(pathIdentity(openedStats), pathIdentity(pathStats))
       || openedStats.size !== pathStats.size
     ) return null;
 

package/plugins/litclaude/lib/rules/session-state.mjs

@@ -22,6 +22,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 
 import { acquireOwnerLock, OwnerLockError, releaseOwnerLock } from "../owner-lock.mjs";
 import { POST_COMPACT_REINJECTION_BUDGET } from "./constants.mjs";
+import { pathIdentity, samePathIdentity } from "../secure-path-read.mjs";
 
 const MAX_TRACKED_KEYS = 500;
 const MAX_STATE_BYTES = 256 * 1024;
@@ -83,8 +84,7 @@ const readStateResult = (projectRoot, id) => {
     const openedStats = fstatSync(fd);
     if (
       !openedStats.isFile()
-      || openedStats.dev !== pathStats.dev
-      || openedStats.ino !== pathStats.ino
+      || !samePathIdentity(pathIdentity(openedStats), pathIdentity(pathStats))
       || openedStats.size !== pathStats.size
     ) return { status: "uncertain" };
     const parsed = JSON.parse(readFileSync(fd, "utf8"));

package/plugins/litclaude/lib/secure-path-read.mjs

@@ -14,6 +14,24 @@ import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 export const MAX_BOUNDED_FILE_BYTES = 8 * 1024 * 1024;
 export const MAX_BOUNDED_AGGREGATE_BYTES = 32 * 1024 * 1024;
 
+export const pathIdentity = (stat) => ({
+  dev: stat?.dev,
+  ino: stat?.ino,
+  ctimeMs: stat?.ctimeMs,
+  birthtimeMs: stat?.birthtimeMs,
+});
+export const samePathIdentity = (left, right) => Boolean(left && right)
+  && ["dev", "ino", "ctimeMs", "birthtimeMs"].every((field) => Number.isFinite(left[field])
+    && Number.isFinite(right[field]) && left[field] === right[field]);
+export const directoryIdentity = (stat) => ({
+  dev: stat?.dev,
+  ino: stat?.ino,
+  birthtimeMs: stat?.birthtimeMs,
+});
+export const sameDirectoryIdentity = (left, right) => Boolean(left && right)
+  && ["dev", "ino", "birthtimeMs"].every((field) => Number.isFinite(left[field])
+    && Number.isFinite(right[field]) && left[field] === right[field]);
+
 const identity = (stat) => ({
   dev: stat.dev,
   ino: stat.ino,

package/plugins/litclaude/lib/skill-loop/common.mjs

@@ -18,6 +18,7 @@ import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
 import { acquireOwnerLock, releaseOwnerLock } from "../owner-lock.mjs";
+import { directoryIdentity, pathIdentity, sameDirectoryIdentity, samePathIdentity } from "../secure-path-read.mjs";
 import { containsSecret } from "../secret-shapes.mjs";
 import { decodeStrictUtf8, parseStrictJson } from "../strict-json.mjs";
 
@@ -147,14 +148,14 @@ export function captureDirectoryIdentity(path, ErrorType, code, { allowMissing =
   if (!details.isDirectory() || details.isSymbolicLink()) {
     throw new ErrorType(code, "expected path is not a real directory");
   }
-  return { dev: details.dev, ino: details.ino };
+  return directoryIdentity(details);
 }
 
 export function directoryIdentityMatches(path, expected) {
   const details = lstatSync(path, { throwIfNoEntry: false });
   if (expected === null) return !details;
   return Boolean(details?.isDirectory() && !details.isSymbolicLink()
-    && details.dev === expected.dev && details.ino === expected.ino);
+    && sameDirectoryIdentity(directoryIdentity(details), expected));
 }
 
 export function assertRegularSingleLink(path, ErrorType, code, { maxBytes } = {}) {
@@ -167,14 +168,14 @@ export function assertRegularSingleLink(path, ErrorType, code, { maxBytes } = {}
   try {
     descriptor = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
     const opened = fstatSync(descriptor);
-    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== named.dev || opened.ino !== named.ino
+    if (!opened.isFile() || opened.nlink !== 1 || !samePathIdentity(pathIdentity(opened), pathIdentity(named))
       || opened.size !== named.size || opened.mtimeMs !== named.mtimeMs) {
       throw new ErrorType(code, "record identity changed while opening");
     }
     const bytes = readFileSync(descriptor);
     const after = fstatSync(descriptor);
-    if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size
-      || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs) {
+    if (!samePathIdentity(pathIdentity(after), pathIdentity(opened)) || after.size !== opened.size
+      || after.mtimeMs !== opened.mtimeMs) {
       throw new ErrorType(code, "record identity changed while reading");
     }
     return bytes;

package/plugins/litclaude/lib/skill-loop/curator.mjs

@@ -203,7 +203,24 @@ function removeEmptyOwnedDirectory(path, identity) {
   if (!directoryIdentityMatches(path, identity)) {
     throw new SkillLoopCuratorError("CURATOR_CLEANUP_UNSAFE");
   }
-  rmdirSync(path);
+  const quarantine = `${path}.remove.${randomUUID()}`;
+  try {
+    renameSync(path, quarantine);
+    if (!directoryIdentityMatches(quarantine, identity)) throw new Error("directory identity changed");
+    let quarantined;
+    try {
+      quarantined = opendirSync(quarantine);
+      if (quarantined.readSync() !== null) throw new Error("directory gained an entry");
+    } finally {
+      quarantined?.closeSync();
+    }
+    rmdirSync(quarantine);
+  } catch {
+    try {
+      if (!existsSync(path) && existsSync(quarantine)) renameSync(quarantine, path);
+    } catch { /* Leave uncertain cleanup as a visible residue. */ }
+    throw new SkillLoopCuratorError("CURATOR_CLEANUP_UNSAFE");
+  }
 }
 
 export function runCurator(root, {
@@ -462,7 +479,24 @@ export function runCurator(root, {
         if (!directoryIdentityMatches(record.path, record.identity)) {
           throw new SkillLoopCuratorError("CURATOR_CLEANUP_UNSAFE");
         }
-        rmSync(record.path, { recursive: true });
+        const quarantine = join(skills, `.${skill}.rollback-${randomUUID()}`);
+        try {
+          renameSync(record.path, quarantine);
+          if (!directoryIdentityMatches(quarantine, record.identity)) throw new Error("backup identity changed");
+          const quarantinedSnapshot = captureStagedSnapshot(root, quarantine, limits === null ? {} : {
+            workLimits: limits,
+            work: createSnapshotWorkBudget(),
+          });
+          if (!isDeepStrictEqual(quarantinedSnapshot, record.snapshot)) {
+            throw new Error("backup contents changed");
+          }
+          rmSync(quarantine, { recursive: true, force: true });
+        } catch {
+          try {
+            if (!existsSync(record.path) && existsSync(quarantine)) renameSync(quarantine, record.path);
+          } catch { /* Leave uncertain cleanup as a visible residue. */ }
+          throw new SkillLoopCuratorError("CURATOR_CLEANUP_UNSAFE");
+        }
         backupRecords.delete(skill);
       }
       removeEmptyOwnedDirectory(backupOwnership.stamp?.path, backupOwnership.stamp?.identity ?? null);

package/plugins/litclaude/lib/skill-loop/mutation-transaction.mjs

@@ -1,5 +1,6 @@
 import { lstatSync, renameSync, rmSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
 
 import { validateProposal } from "./proposal-record.mjs";
 import { readProposalRecord, transitionProposalRecordUnlocked } from "./proposal-store.mjs";
@@ -110,9 +111,10 @@ function journalPath(root, create) {
 }
 
 function validIdentity(identity) {
-  return identity === null || (isPlainObject(identity) && requireExactKeys(identity, ["dev", "ino"])
+  return identity === null || (isPlainObject(identity) && requireExactKeys(identity, ["dev", "ino", "birthtimeMs"])
     && Number.isSafeInteger(identity.dev) && identity.dev >= 0
-    && Number.isSafeInteger(identity.ino) && identity.ino > 0);
+    && Number.isSafeInteger(identity.ino) && identity.ino > 0
+    && Number.isFinite(identity.birthtimeMs) && identity.birthtimeMs >= 0);
 }
 
 function validTemporaryName(name, skill, kind, suffix) {
@@ -304,7 +306,28 @@ function assertExactDirectory(root, path, identity, snapshot, targetRoot, skill,
 
 function removeExactDirectory(root, path, identity, snapshot, targetRoot, skill, snapshotOptions) {
   assertExactDirectory(root, path, identity, snapshot, targetRoot, skill, snapshotOptions);
-  rmSync(path, { recursive: true });
+  const skills = ensureSafeDirectoryChain(root, [".claude", "skills"], {
+    create: false,
+    ErrorType: SkillLoopMutationTransactionError,
+    code: "MUTATION_TRANSACTION_UNSAFE",
+  });
+  if (skills === null || dirname(path) !== skills) fail("MUTATION_TRANSACTION_AMBIGUOUS");
+  const quarantine = join(skills, `.${skill}.rollback-${randomUUID()}`);
+  try {
+    renameSync(path, quarantine);
+    if (!directoryIdentityMatches(quarantine, identity)) throw new Error("directory identity changed");
+    const quarantinedSnapshot = captureStagedSnapshot(root, quarantine, snapshotOptions);
+    if (!snapshotsMatch(quarantinedSnapshot, snapshot)) throw new Error("directory contents changed");
+    rmSync(quarantine, { recursive: true, force: true });
+  } catch (error) {
+    try {
+      if (!lstatSync(path, { throwIfNoEntry: false }) && lstatSync(quarantine, { throwIfNoEntry: false })) {
+        renameSync(quarantine, path);
+      }
+    } catch { /* Leave uncertain cleanup as a visible residue. */ }
+    if (error instanceof SkillLoopMutationTransactionError) throw error;
+    fail("MUTATION_TRANSACTION_AMBIGUOUS");
+  }
 }
 
 function ensureLedgerCommitted(root, journal) {
@@ -497,7 +520,8 @@ export function recoverSkillMutationTransactionUnlocked(root, {
     if (stageDetails && stage !== null) removeExactDirectory(root, stage, journal.stageIdentity, journal.after,
       journal.targetRoot, journal.targetSkill, snapshotOptions);
     renameSync(displaced, target);
-    if (!directoryIdentityMatches(target, journal.beforeIdentity)) fail("MUTATION_TRANSACTION_AMBIGUOUS");
+    assertExactDirectory(root, target, journal.beforeIdentity, journal.before,
+      journal.targetRoot, journal.targetSkill, snapshotOptions);
     clearJournalUnlocked(root);
     return { status: "rolled-back", kind: journal.kind, requestId: journal.requestId };
   }

package/plugins/litclaude/lib/skill-loop/proposal-store.mjs

@@ -1,4 +1,5 @@
-import { lstatSync, opendirSync, unlinkSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { lstatSync, opendirSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import {
@@ -7,10 +8,12 @@ import {
   ensureSafeDirectoryChain,
   PROPOSAL_MAX_BYTES,
   readStrictJsonFile,
+  prettyJsonBytes,
   RECORD_ID,
   skillRootsEquivalent,
   withSkillLoopLock,
 } from "./common.mjs";
+import { directoryIdentity, pathIdentity, sameDirectoryIdentity, samePathIdentity } from "../secure-path-read.mjs";
 import { SkillLoopProposalError, validateProposal } from "./proposal-record.mjs";
 import { recoverReviewTransactionUnlocked } from "./review-transaction.mjs";
 import { recoverSkillMutationTransactionUnlocked } from "./mutation-transaction.mjs";
@@ -96,7 +99,13 @@ export function queueProposalRecordUnlocked(root, proposal) {
   if (!written?.isFile() || written.isSymbolicLink() || written.nlink !== 1) {
     throw new SkillLoopProposalError("PROPOSAL_STORE_UNSAFE");
   }
-  return { proposal: persistedProposal, path, identity: { dev: written.dev, ino: written.ino } };
+  const bytes = prettyJsonBytes(persistedProposal);
+  return {
+    proposal: persistedProposal,
+    path,
+    identity: pathIdentity(written),
+    sha256: createHash("sha256").update(bytes).digest("hex"),
+  };
 }
 
 export function normalizeProposalTargetRoot(root, proposal) {
@@ -110,10 +119,33 @@ export function normalizeProposalTargetRoot(root, proposal) {
 export function removeQueuedProposalRecordUnlocked(record) {
   const current = lstatSync(record.path, { throwIfNoEntry: false });
   if (!current?.isFile() || current.isSymbolicLink() || current.nlink !== 1
-    || current.dev !== record.identity.dev || current.ino !== record.identity.ino) {
+    || !samePathIdentity(pathIdentity(current), record.identity)) {
+    throw new SkillLoopProposalError("PROPOSAL_ROLLBACK_UNSAFE");
+  }
+  const quarantine = `${record.path}.remove.${randomUUID()}`;
+  try {
+    renameSync(record.path, quarantine);
+    const moved = lstatSync(quarantine, { throwIfNoEntry: false });
+    if (!moved?.isFile() || moved.isSymbolicLink() || moved.nlink !== 1
+      || !sameDirectoryIdentity(directoryIdentity(moved), {
+        dev: record.identity.dev,
+        ino: record.identity.ino,
+        birthtimeMs: record.identity.birthtimeMs,
+      })) {
+      throw new Error("proposal identity changed");
+    }
+    if (record.sha256
+      && createHash("sha256").update(readFileSync(quarantine)).digest("hex") !== record.sha256) {
+      throw new Error("proposal contents changed");
+    }
+    rmSync(quarantine, { force: true });
+  } catch {
+    try {
+      if (!lstatSync(record.path, { throwIfNoEntry: false })
+        && lstatSync(quarantine, { throwIfNoEntry: false })) renameSync(quarantine, record.path);
+    } catch { /* Leave uncertain cleanup as a visible residue. */ }
     throw new SkillLoopProposalError("PROPOSAL_ROLLBACK_UNSAFE");
   }
-  unlinkSync(record.path);
 }
 
 function proposalEntriesBounded(root) {

package/plugins/litclaude/lib/skill-loop/review.mjs

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 
 import { canonicalSkillIds } from "../canonical-skill-catalog.mjs";
 import { containsSecret } from "../secret-shapes.mjs";
+import { pathIdentity, samePathIdentity } from "../secure-path-read.mjs";
 import { decodeStrictUtf8, parseStrictJson } from "../strict-json.mjs";
 import { resolveAgentTarget } from "./authority.mjs";
 import { skillRootFor } from "./common.mjs";
@@ -70,14 +71,14 @@ function readStableTranscript(path) {
   try {
     descriptor = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
     const opened = fstatSync(descriptor);
-    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== named.dev || opened.ino !== named.ino
+    if (!opened.isFile() || opened.nlink !== 1 || !samePathIdentity(pathIdentity(opened), pathIdentity(named))
       || opened.size !== named.size || opened.mtimeMs !== named.mtimeMs) {
       throw new SkillLoopReviewError("TRANSCRIPT_UNSAFE");
     }
     const bytes = readFileSync(descriptor);
     const after = fstatSync(descriptor);
-    if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size
-      || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs) {
+    if (!samePathIdentity(pathIdentity(after), pathIdentity(opened)) || after.size !== opened.size
+      || after.mtimeMs !== opened.mtimeMs) {
       throw new SkillLoopReviewError("TRANSCRIPT_UNSAFE");
     }
     return bytes;