@openclaw/crabline 0.1.10 → 0.1.12

package/dist/src/openclaw/smoke-lock.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import fsSync, { readFileSync } from "node:fs";
 import fs, {} from "node:fs/promises";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
@@ -8,10 +8,12 @@ import { isCrablineServerChannel } from "../servers/index.js";
 import { resolveWindowsPowerShellPath, securePrivateDirectory } from "./private-file.js";
 import { OPENCLAW_CRABLINE_MANIFEST_PATH } from "./shared.js";
 const LOCK_OWNER_FILE = "owner.json";
-const LOCK_COMMIT_STAGE_FILE_PREFIX = "commit-stage";
 const LOCK_LEASE_FILE_PREFIX = "lease.";
+const LOCK_COMMIT_STAGE_FILE_PREFIX = "commit-stage.";
+const LOCK_STAGED_FILE_PREFIX = ".commit-file.";
 const LEGACY_RECOVERY_SUFFIX = ".recovering";
 const COMMIT_CLAIM_SUFFIX = ".commit";
+const OWNED_CLAIM_SUFFIX = ".owned";
 const RELEASE_CLAIM_SUFFIX = ".release";
 const LOCK_LEASE_MS = 10 * 60 * 1000;
 const RELEASE_ATTEMPTS = 3;
@@ -26,58 +28,6 @@ export function processStartedAtMsFromTimeOrigin(timeOrigin) {
     }
     return Math.trunc(timeOrigin);
 }
-function parseCommitStagePath(contents, token) {
-    let value;
-    try {
-        value = JSON.parse(contents);
-    }
-    catch (error) {
-        throw new Error("OpenClaw Crabline smoke lock commit stage metadata is malformed.", {
-            cause: error,
-        });
-    }
-    const expectedPrefix = `.commit-file.${token}.`;
-    if (value.token !== token ||
-        typeof value.path !== "string" ||
-        !path.isAbsolute(value.path) ||
-        !path.basename(value.path).startsWith(expectedPrefix) ||
-        !path.basename(value.path).endsWith(".tmp")) {
-        throw new Error("OpenClaw Crabline smoke lock commit stage metadata is malformed.");
-    }
-    return value.path;
-}
-async function readCommitStagePath(lockDirectory, token) {
-    try {
-        return parseCommitStagePath(await fs.readFile(path.join(lockDirectory, commitStageFileName(token)), "utf8"), token);
-    }
-    catch (error) {
-        if (isMissingPathError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-function commitStageFileName(token) {
-    return `${LOCK_COMMIT_STAGE_FILE_PREFIX}.${token}.json`;
-}
-async function writeCommitStagePath(lockDirectory, stagedFilePath, token) {
-    const temporaryPath = path.join(lockDirectory, `.${commitStageFileName(token)}.${randomUUID()}.tmp`);
-    try {
-        await fs.writeFile(temporaryPath, `${JSON.stringify({ path: stagedFilePath, token })}\n`, {
-            encoding: "utf8",
-            flag: "wx",
-            mode: 0o600,
-        });
-        await fs.chmod(temporaryPath, 0o600);
-        await fs.rename(temporaryPath, path.join(lockDirectory, commitStageFileName(token)));
-    }
-    finally {
-        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
-    }
-}
-const removeLockDirectory = async (lockDirectory) => {
-    await fs.rm(lockDirectory, { force: true, recursive: true });
-};
 const sleep = async (delayMs) => {
     await new Promise((resolve) => setTimeout(resolve, delayMs));
 };
@@ -153,9 +103,98 @@ async function readDirectoryIdentity(directoryPath) {
         throw error;
     }
 }
+async function readFileIdentity(filePath) {
+    try {
+        const stats = await fs.lstat(filePath, { bigint: true });
+        if (!stats.isFile() || stats.nlink !== 1n || stats.ino <= 0n) {
+            return null;
+        }
+        return {
+            device: stats.dev,
+            inode: stats.ino,
+        };
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
 function hasSameDirectoryIdentity(left, right) {
     return (left !== null && right !== null && left.device === right.device && left.inode === right.inode);
 }
+function isOwnedLockArtifactName(name, token) {
+    const leaseName = leaseFileName(token);
+    const commitStageName = `${LOCK_COMMIT_STAGE_FILE_PREFIX}${token}.json`;
+    return (name === LOCK_OWNER_FILE ||
+        name === leaseName ||
+        (name.startsWith(`.${leaseName}.`) && name.endsWith(".tmp")) ||
+        name === commitStageName ||
+        (name.startsWith(`.${LOCK_COMMIT_STAGE_FILE_PREFIX}${token}.`) && name.endsWith(".tmp")) ||
+        (name.startsWith(`${LOCK_STAGED_FILE_PREFIX}${token}.`) && name.endsWith(".tmp")));
+}
+async function removeVerifiedLockDirectory(params) {
+    if (!hasSameDirectoryIdentity(params.expectedIdentity, await readDirectoryIdentity(params.directoryPath))) {
+        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+    }
+    await params.beforeRemove?.();
+    const quarantinePath = `${params.directoryPath}.cleanup.${randomUUID()}`;
+    fsSync.renameSync(params.directoryPath, quarantinePath);
+    let quarantinedIdentity = null;
+    const stats = fsSync.lstatSync(quarantinePath, { bigint: true });
+    if (stats.isDirectory() && !stats.isSymbolicLink() && stats.ino > 0n) {
+        quarantinedIdentity = { device: stats.dev, inode: stats.ino };
+    }
+    if (!hasSameDirectoryIdentity(params.expectedIdentity, quarantinedIdentity)) {
+        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+    }
+    const entries = fsSync.readdirSync(quarantinePath);
+    const artifacts = [];
+    for (const entry of entries) {
+        if (!isOwnedLockArtifactName(entry, params.token)) {
+            throw new Error("OpenClaw Crabline smoke lock cleanup found an unexpected artifact.");
+        }
+        const artifactPath = path.join(quarantinePath, entry);
+        const artifactStats = fsSync.lstatSync(artifactPath, { bigint: true });
+        if (!artifactStats.isFile() ||
+            artifactStats.isSymbolicLink() ||
+            artifactStats.nlink !== 1n ||
+            artifactStats.ino <= 0n) {
+            throw new Error("OpenClaw Crabline smoke lock cleanup found an unsafe artifact.");
+        }
+        artifacts.push({
+            identity: { device: artifactStats.dev, inode: artifactStats.ino },
+            path: artifactPath,
+        });
+    }
+    artifacts.sort((left, right) => Number(path.basename(left.path) === LOCK_OWNER_FILE) -
+        Number(path.basename(right.path) === LOCK_OWNER_FILE));
+    for (const artifact of artifacts) {
+        const directoryStats = fsSync.lstatSync(quarantinePath, { bigint: true });
+        const artifactStats = fsSync.lstatSync(artifact.path, { bigint: true });
+        if (!directoryStats.isDirectory() ||
+            directoryStats.isSymbolicLink() ||
+            directoryStats.dev !== params.expectedIdentity.device ||
+            directoryStats.ino !== params.expectedIdentity.inode ||
+            !artifactStats.isFile() ||
+            artifactStats.isSymbolicLink() ||
+            artifactStats.nlink !== 1n ||
+            artifactStats.dev !== artifact.identity.device ||
+            artifactStats.ino !== artifact.identity.inode) {
+            throw new Error("OpenClaw Crabline smoke lock cleanup artifact changed.");
+        }
+        fsSync.unlinkSync(artifact.path);
+    }
+    const finalStats = fsSync.lstatSync(quarantinePath, { bigint: true });
+    if (!finalStats.isDirectory() ||
+        finalStats.isSymbolicLink() ||
+        finalStats.dev !== params.expectedIdentity.device ||
+        finalStats.ino !== params.expectedIdentity.inode) {
+        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+    }
+    fsSync.rmdirSync(quarantinePath);
+}
 function isPositiveSafeInteger(value) {
     return Number.isSafeInteger(value) && Number(value) > 0;
 }
@@ -164,15 +203,19 @@ function isValidProcessId(value) {
 }
 const LOCK_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 function parseLockOwner(contents) {
-    let owner;
+    let parsed;
     try {
-        owner = JSON.parse(contents);
+        parsed = JSON.parse(contents);
     }
     catch (error) {
         throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.", {
             cause: error,
         });
     }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.");
+    }
+    const owner = parsed;
     if (typeof owner.channel !== "string" ||
         !isCrablineServerChannel(owner.channel) ||
         !isValidProcessId(owner.pid) ||
@@ -194,7 +237,11 @@ function parseLockOwner(contents) {
         (owner.processIdentity !== undefined &&
             (typeof owner.processIdentity !== "string" ||
                 owner.processIdentity.length === 0 ||
-                owner.processIdentity.length > 256))) {
+                owner.processIdentity.length > 256)) ||
+        (owner.processIdentityV2 !== undefined &&
+            (typeof owner.processIdentityV2 !== "string" ||
+                owner.processIdentityV2.length === 0 ||
+                owner.processIdentityV2.length > 256))) {
         throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.");
     }
     if (owner.leaseVersion === undefined) {
@@ -203,6 +250,7 @@ function parseLockOwner(contents) {
             createdAtMs: owner.createdAtMs,
             pid: owner.pid,
             ...(owner.processIdentity ? { processIdentity: owner.processIdentity } : {}),
+            ...(owner.processIdentityV2 ? { processIdentityV2: owner.processIdentityV2 } : {}),
             processStartedAtMs: owner.processStartedAtMs,
             token: owner.token,
         };
@@ -216,6 +264,7 @@ function parseLockOwner(contents) {
         leaseVersion: owner.leaseVersion,
         pid: owner.pid,
         ...(owner.processIdentity ? { processIdentity: owner.processIdentity } : {}),
+        ...(owner.processIdentityV2 ? { processIdentityV2: owner.processIdentityV2 } : {}),
         processStartedAtMs: owner.processStartedAtMs,
         token: owner.token,
     };
@@ -303,6 +352,17 @@ export function processIdentityFromLinuxStat(value, bootId) {
 }
 export function processIdentityFromDarwin(processStartedAt, bootTime) {
     const bootMatch = /\bsec = (\d+), usec = (\d+)\b/u.exec(bootTime);
+    const launchMatch = /^Launch Time:\s*(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})\.(\d{3,6}) ([+-])(\d{2})(\d{2})$/mu.exec(processStartedAt);
+    if (bootMatch && launchMatch) {
+        const [, year, month, day, hour, minute, second, fraction, sign, offsetHour, offsetMinute] = launchMatch;
+        const offsetMs = (Number(offsetHour) * 60 + Number(offsetMinute)) * 60_000 * (sign === "+" ? 1 : -1);
+        const fractionMicros = Number(fraction.padEnd(6, "0"));
+        const utcMilliseconds = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Math.floor(fractionMicros / 1_000)) - offsetMs;
+        if (Number.isSafeInteger(utcMilliseconds) && utcMilliseconds > 0) {
+            const startedAtMicros = BigInt(utcMilliseconds) * 1000n + BigInt(fractionMicros % 1_000);
+            return `darwin:${bootMatch[1]}.${bootMatch[2]}:us:${startedAtMicros}`;
+        }
+    }
     const normalizedStartedAt = processStartedAt.trim().replace(/\s+/gu, " ");
     if (!bootMatch || normalizedStartedAt.length === 0 || normalizedStartedAt.length > 64) {
         return null;
@@ -325,11 +385,15 @@ const getProcessIdentity = (pid) => {
         const options = {
             encoding: "utf8",
             env: darwinProcessIdentityEnvironment(process.env),
+            maxBuffer: 512 * 1024,
             timeout: 1_000,
         };
-        const startedAt = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], options);
-        const bootTime = spawnSync("sysctl", ["-n", "kern.boottime"], options);
-        return startedAt.status === 0 && bootTime.status === 0
+        const bootTime = spawnSync("/usr/sbin/sysctl", ["-n", "kern.boottime"], options);
+        if (bootTime.status !== 0) {
+            return null;
+        }
+        const startedAt = spawnSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], options);
+        return startedAt.status === 0
             ? processIdentityFromDarwin(startedAt.stdout, bootTime.stdout)
             : null;
     }
@@ -352,32 +416,85 @@ const getProcessIdentity = (pid) => {
     const ticks = result.status === 0 ? result.stdout.trim() : "";
     return /^\d+$/u.test(ticks) ? `windows:${ticks}` : null;
 };
+const getProcessIdentityV2 = (pid) => {
+    if (process.platform !== "darwin") {
+        return null;
+    }
+    const options = {
+        encoding: "utf8",
+        env: darwinProcessIdentityEnvironment(process.env),
+        maxBuffer: 512 * 1024,
+        timeout: 3_000,
+    };
+    const bootTime = spawnSync("/usr/sbin/sysctl", ["-n", "kern.boottime"], options);
+    const processDetails = spawnSync("/usr/bin/vmmap", ["-summary", String(pid)], options);
+    if (bootTime.status !== 0 || processDetails.status !== 0) {
+        return null;
+    }
+    const identity = processIdentityFromDarwin(processDetails.stdout, bootTime.stdout);
+    return identity?.includes(":us:") ? identity : null;
+};
+let cachedCurrentProcessIdentity = null;
+let cachedCurrentProcessIdentityV2 = null;
+function getCachedCurrentProcessIdentity() {
+    return (cachedCurrentProcessIdentity ??= getProcessIdentity(process.pid));
+}
+function getCachedCurrentProcessIdentityV2() {
+    return (cachedCurrentProcessIdentityV2 ??= getProcessIdentityV2(process.pid));
+}
 function hasExactProcessIdentity(owner) {
     return hasProcessIdentity(owner) && typeof owner.processIdentity === "string";
 }
-function hasProcessIdentityMismatch(owner, runtime) {
+function hasCoarseDarwinProcessIdentity(owner) {
+    if (!hasExactProcessIdentity(owner)) {
+        return false;
+    }
+    return /^darwin:\d+\.\d+:(?!us:).+$/u.test(owner.processIdentity);
+}
+function compareProcessIdentity(owner, runtime) {
     if (hasProcessIdentity(owner) &&
         owner.pid === runtime.currentPid &&
         owner.processStartedAtMs !== runtime.currentProcessStartedAtMs) {
-        return true;
+        return "mismatch";
     }
     if (!hasExactProcessIdentity(owner)) {
-        return false;
+        return "unknown";
+    }
+    if (hasProcessIdentity(owner) && typeof owner.processIdentityV2 === "string") {
+        const actualProcessIdentityV2 = owner.pid === runtime.currentPid
+            ? runtime.currentProcessIdentityV2
+            : runtime.getProcessIdentityV2(owner.pid);
+        if (actualProcessIdentityV2 !== null) {
+            return owner.processIdentityV2 === actualProcessIdentityV2 ? "v2" : "mismatch";
+        }
     }
     const actualProcessIdentity = owner.pid === runtime.currentPid
         ? runtime.currentProcessIdentity
         : runtime.getProcessIdentity(owner.pid);
-    return actualProcessIdentity !== null && owner.processIdentity !== actualProcessIdentity;
+    if (actualProcessIdentity === null) {
+        return "unknown";
+    }
+    return owner.processIdentity === actualProcessIdentity ? "legacy" : "mismatch";
+}
+function hasProcessIdentityMismatch(owner, runtime) {
+    return compareProcessIdentity(owner, runtime) === "mismatch";
 }
 function isLockOwnerActive(record, runtime) {
     const { owner } = record;
     if (!runtime.isProcessAlive(owner.pid)) {
         return false;
     }
-    if (hasProcessIdentityMismatch(owner, runtime)) {
+    const identityMatch = compareProcessIdentity(owner, runtime);
+    if (identityMatch === "mismatch") {
         return false;
     }
     if (!isRenewableOwner(owner)) {
+        if (owner.pid !== runtime.currentPid &&
+            hasCoarseDarwinProcessIdentity(owner) &&
+            identityMatch !== "v2") {
+            const ageMs = runtime.now() - Math.max(owner.createdAtMs, record.renewedAtMs);
+            return ageMs >= -runtime.leaseMs && ageMs <= runtime.leaseMs;
+        }
         return true;
     }
     const ageMs = runtime.now() - Math.max(owner.createdAtMs, record.renewedAtMs);
@@ -389,21 +506,56 @@ function needsLiveOwnerConfirmation(record, runtime) {
         !hasProcessIdentityMismatch(record.owner, runtime) &&
         !isLockOwnerActive(record, runtime));
 }
-async function observedOwnerChangedDuringConfirmation(lockDirectory, observed, runtime) {
+function heartbeatIntervalMs(leaseMs) {
+    return Math.max(1, Math.floor(leaseMs / 3));
+}
+async function confirmObservedOwner(lockDirectory, observed, runtime) {
     if (!needsLiveOwnerConfirmation(observed, runtime)) {
-        return false;
+        return "unchanged";
     }
-    await runtime.sleep(runtime.leaseMs);
+    await runtime.sleep(heartbeatIntervalMs(runtime.leaseMs));
     const revalidated = await readLockRecord(lockDirectory);
-    return (revalidated.kind === "record" &&
-        (revalidated.record.owner.token !== observed.owner.token ||
-            revalidated.record.renewedAtMs !== observed.renewedAtMs ||
-            isLockOwnerActive(revalidated.record, runtime)));
+    if (revalidated.kind !== "record") {
+        return "unchanged";
+    }
+    if (revalidated.record.owner.token !== observed.owner.token) {
+        return "changed";
+    }
+    return revalidated.record.renewedAtMs !== observed.renewedAtMs ||
+        isLockOwnerActive(revalidated.record, runtime)
+        ? "renewed"
+        : "unchanged";
 }
 function activeRunError(params) {
     return new Error(`OpenClaw Crabline smoke is already running for channel "${params.channel ?? "unknown"}" in "${params.outputDir}"; cannot start channel "${params.requestedChannel}".`, params.cause === undefined ? undefined : { cause: params.cause });
 }
+function isPathConfinedTo(rootPath, candidatePath) {
+    const relative = path.relative(rootPath, candidatePath);
+    return (relative === "" ||
+        (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`)));
+}
+async function resolveConfinedPath(rootPath, candidatePath, description, candidateKind) {
+    const resolvedPath = path.resolve(candidatePath);
+    if (resolvedPath !== candidatePath) {
+        throw new Error(`OpenClaw Crabline smoke lock ${description} escapes its output directory.`);
+    }
+    const parentPath = candidateKind === "directory" ? resolvedPath : path.dirname(resolvedPath);
+    let realParentPath;
+    try {
+        realParentPath = await fs.realpath(parentPath);
+    }
+    catch {
+        throw new Error(`OpenClaw Crabline smoke lock ${description} is invalid.`);
+    }
+    if (!isPathConfinedTo(rootPath, realParentPath)) {
+        throw new Error(`OpenClaw Crabline smoke lock ${description} escapes its output directory.`);
+    }
+    return candidateKind === "directory"
+        ? realParentPath
+        : path.join(realParentPath, path.basename(resolvedPath));
+}
 async function removeOwnedLock(params) {
+    await params.beforeClaim?.();
     const observed = await readLockRecord(params.ownedDirectory);
     if (observed.kind === "missing" || observed.record.owner.token !== params.token) {
         return false;
@@ -412,7 +564,15 @@ async function removeOwnedLock(params) {
     if (observedIdentity === null) {
         return false;
     }
-    await params.beforeClaim?.();
+    const revalidated = await readLockRecord(params.ownedDirectory);
+    const revalidatedIdentity = await readDirectoryIdentity(params.ownedDirectory);
+    if (revalidated.kind === "missing" ||
+        revalidated.record.owner.token !== params.token ||
+        !hasSameDirectoryIdentity(observedIdentity, revalidatedIdentity) ||
+        (params.runtime !== undefined && isLockOwnerActive(revalidated.record, params.runtime))) {
+        return false;
+    }
+    await params.beforeRename?.();
     const releaseClaim = `${params.lockDirectory}${RELEASE_CLAIM_SUFFIX}.${params.token}.${randomUUID()}`;
     try {
         await fs.rename(params.ownedDirectory, releaseClaim);
@@ -443,22 +603,62 @@ async function removeOwnedLock(params) {
         }
         return false;
     }
-    const stagedFilePath = await readCommitStagePath(releaseClaim, params.token);
-    if (stagedFilePath) {
-        const revokedStagePath = path.join(path.dirname(stagedFilePath), `.revoked-commit-file.${params.token}.${randomUUID()}.tmp`);
-        try {
-            await fs.rename(stagedFilePath, revokedStagePath);
-            await fs.rm(revokedStagePath, { force: true });
-        }
-        catch (error) {
-            if (!isMissingPathError(error)) {
-                throw error;
-            }
-        }
+    if (params.removeDirectory) {
+        await params.removeDirectory(releaseClaim);
+    }
+    else {
+        await removeVerifiedLockDirectory({
+            ...(params.beforeRemove ? { beforeRemove: params.beforeRemove } : {}),
+            directoryPath: releaseClaim,
+            expectedIdentity: observedIdentity,
+            token: params.token,
+        });
     }
-    await (params.removeDirectory ?? removeLockDirectory)(releaseClaim);
     return true;
 }
+async function renewCompatibilityMarker(params) {
+    await params.securedDirectory.assertIdentityAt(params.lockDirectory);
+    const observed = await readLockRecord(params.lockDirectory);
+    if (observed.kind === "missing" || observed.record.owner.token !== params.token) {
+        return false;
+    }
+    const renewedAt = new Date(params.renewedAtMs);
+    await params.handle.utimes(renewedAt, renewedAt);
+    await params.handle.sync();
+    await params.securedDirectory.assertIdentityAt(params.lockDirectory);
+    const revalidated = await readLockRecord(params.lockDirectory);
+    return revalidated.kind === "record" && revalidated.record.owner.token === params.token;
+}
+async function assertCompatibilityMarkerOwned(params) {
+    await params.securedDirectory.assertIdentityAt(params.lockDirectory);
+    const observed = await readLockRecord(params.lockDirectory);
+    if (observed.kind === "missing" || observed.record.owner.token !== params.token) {
+        throw new Error("OpenClaw Crabline smoke lock compatibility marker was lost.");
+    }
+}
+async function retireCompatibilityMarker(handle, owner) {
+    const retiredOwner = {
+        ...owner,
+        createdAtMs: 1,
+        pid: MAX_PROCESS_ID,
+        ...(owner.processIdentity ? { processIdentity: "retired" } : {}),
+        ...(owner.processIdentityV2 ? { processIdentityV2: "retired" } : {}),
+        processStartedAtMs: 1,
+    };
+    const originalBytes = Buffer.byteLength(`${JSON.stringify(owner)}\n`, "utf8");
+    const retiredJson = JSON.stringify(retiredOwner);
+    const retiredBytes = Buffer.byteLength(retiredJson, "utf8") + 1;
+    const targetBytes = Math.max(originalBytes, retiredBytes);
+    const paddingBytes = targetBytes - retiredBytes;
+    const retiredContents = `${retiredJson}${" ".repeat(paddingBytes)}\n`;
+    const written = await handle.write(retiredContents, 0, "utf8");
+    if (written.bytesWritten !== targetBytes) {
+        throw new Error("OpenClaw Crabline smoke lock compatibility marker retirement was incomplete.");
+    }
+    const retiredAt = new Date(1);
+    await handle.utimes(retiredAt, retiredAt);
+    await handle.sync();
+}
 async function renewOwnedLock(lockDirectory, token, renewedAtMs) {
     const temporaryLeasePath = path.join(lockDirectory, `.${leaseFileName(token)}.${randomUUID()}.tmp`);
     try {
@@ -503,6 +703,7 @@ async function listLockClaims(lockDirectory) {
     const prefixes = [
         { kind: "recovering", prefix: claimPrefix(lockDirectory, LEGACY_RECOVERY_SUFFIX) },
         { kind: "commit", prefix: claimPrefix(lockDirectory, COMMIT_CLAIM_SUFFIX) },
+        { kind: "owned", prefix: claimPrefix(lockDirectory, OWNED_CLAIM_SUFFIX) },
         { kind: "release", prefix: claimPrefix(lockDirectory, RELEASE_CLAIM_SUFFIX) },
     ];
     const entries = await fs.readdir(directory, { withFileTypes: true });
@@ -581,7 +782,25 @@ async function resolveLockClaim(params) {
             requestedChannel: params.requestedChannel,
         });
     }
-    if (await observedOwnerChangedDuringConfirmation(params.claim.directoryPath, observed.record, params.runtime)) {
+    const confirmation = await confirmObservedOwner(params.claim.directoryPath, observed.record, params.runtime);
+    if (confirmation === "renewed") {
+        if (params.claim.kind === "recovering") {
+            try {
+                await fs.rename(params.claim.directoryPath, params.lockDirectory);
+            }
+            catch (error) {
+                if (!(await pathExists(params.lockDirectory))) {
+                    throw error;
+                }
+            }
+        }
+        throw activeRunError({
+            channel: observed.record.owner.channel,
+            outputDir: params.outputDir,
+            requestedChannel: params.requestedChannel,
+        });
+    }
+    if (confirmation === "changed") {
         await resolveLockClaim(params);
         return;
     }
@@ -624,10 +843,19 @@ async function resolveLockContention(params) {
             requestedChannel: params.requestedChannel,
         });
     }
-    if (observed.kind === "record" &&
-        (await observedOwnerChangedDuringConfirmation(params.lockDirectory, observed.record, params.runtime))) {
-        await resolveLockContention(params);
-        return;
+    if (observed.kind === "record") {
+        const confirmation = await confirmObservedOwner(params.lockDirectory, observed.record, params.runtime);
+        if (confirmation === "renewed") {
+            throw activeRunError({
+                channel: observed.record.owner.channel,
+                outputDir: params.outputDir,
+                requestedChannel: params.requestedChannel,
+            });
+        }
+        if (confirmation === "changed") {
+            await resolveLockContention(params);
+            return;
+        }
     }
     await params.beforeRecoveryClaim();
     const claimDirectory = `${params.lockDirectory}${LEGACY_RECOVERY_SUFFIX}.${randomUUID()}`;
@@ -650,7 +878,8 @@ async function resolveLockContention(params) {
     });
 }
 async function createLockCandidate(params) {
-    const candidateDirectory = `${params.lockDirectory}.${params.owner.pid}.${params.owner.token}.tmp`;
+    const candidateDirectory = params.candidateDirectory ??
+        `${params.lockDirectory}.${params.owner.pid}.${params.owner.token}.tmp`;
     await fs.mkdir(candidateDirectory, { mode: 0o700 });
     try {
         const securedDirectory = await securePrivateDirectory(candidateDirectory, {
@@ -671,14 +900,16 @@ async function createLockCandidate(params) {
         await fs.utimes(ownerPath, createdAt, createdAt);
         await params.afterOwnerWrite?.(candidateDirectory);
         await securedDirectory.assertIdentityAt();
-        const leasePath = path.join(candidateDirectory, leaseFileName(params.owner.token));
-        await fs.writeFile(leasePath, `${JSON.stringify({ renewedAtMs: params.owner.createdAtMs, token: params.owner.token })}\n`, {
-            encoding: "utf8",
-            flag: "wx",
-            mode: 0o600,
-        });
-        await fs.chmod(leasePath, 0o600);
-        await fs.utimes(leasePath, createdAt, createdAt);
+        if (params.includeLease !== false) {
+            const leasePath = path.join(candidateDirectory, leaseFileName(params.owner.token));
+            await fs.writeFile(leasePath, `${JSON.stringify({ renewedAtMs: params.owner.createdAtMs, token: params.owner.token })}\n`, {
+                encoding: "utf8",
+                flag: "wx",
+                mode: 0o600,
+            });
+            await fs.chmod(leasePath, 0o600);
+            await fs.utimes(leasePath, createdAt, createdAt);
+        }
         await securedDirectory.assertIdentityAt();
         return { candidateDirectory, securedDirectory };
     }
@@ -688,18 +919,39 @@ async function createLockCandidate(params) {
     }
 }
 export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies = {}) {
-    const outputDir = path.resolve(params.outputDir);
+    const requestedOutputDir = path.resolve(params.outputDir);
+    await fs.mkdir(requestedOutputDir, { recursive: true });
+    const outputDir = await fs.realpath(requestedOutputDir);
+    const privateDirectoryOptions = {
+        ...(dependencies.platform ? { platform: dependencies.platform } : {}),
+        ...(dependencies.secureWindowsDirectory
+            ? { secureWindowsDirectory: dependencies.secureWindowsDirectory }
+            : {}),
+    };
+    const securedOutputDirectory = await securePrivateDirectory(outputDir, privateDirectoryOptions);
+    await securedOutputDirectory.assertIdentityAt(outputDir);
+    const outputDirectoryIdentity = await readDirectoryIdentity(outputDir);
+    if (outputDirectoryIdentity === null) {
+        throw new Error("OpenClaw Crabline smoke lock output directory is invalid.");
+    }
     const lockDirectory = path.join(outputDir, `.${OPENCLAW_CRABLINE_MANIFEST_PATH}.lock`);
     const token = randomUUID();
     const currentPid = dependencies.pid ?? process.pid;
-    const getRuntimeProcessIdentity = dependencies.getProcessIdentity ?? getProcessIdentity;
+    const getRuntimeProcessIdentity = dependencies.getProcessIdentity ??
+        ((pid) => (pid === process.pid ? getCachedCurrentProcessIdentity() : getProcessIdentity(pid)));
+    const getRuntimeProcessIdentityV2 = dependencies.getProcessIdentityV2 ??
+        ((pid) => pid === process.pid ? getCachedCurrentProcessIdentityV2() : getProcessIdentityV2(pid));
     const runtime = {
         currentPid,
         currentProcessIdentity: dependencies.processIdentity === undefined
             ? getRuntimeProcessIdentity(currentPid)
             : dependencies.processIdentity,
+        currentProcessIdentityV2: dependencies.processIdentityV2 === undefined
+            ? getRuntimeProcessIdentityV2(currentPid)
+            : dependencies.processIdentityV2,
         currentProcessStartedAtMs: dependencies.processStartedAtMs ?? CURRENT_PROCESS_STARTED_AT_MS,
         getProcessIdentity: getRuntimeProcessIdentity,
+        getProcessIdentityV2: getRuntimeProcessIdentityV2,
         isProcessAlive: dependencies.isProcessAlive ?? isProcessAlive,
         leaseMs: dependencies.leaseMs ?? LOCK_LEASE_MS,
         now: dependencies.now ?? Date.now,
@@ -710,6 +962,9 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         (runtime.currentProcessIdentity !== null &&
             (runtime.currentProcessIdentity.length === 0 ||
                 runtime.currentProcessIdentity.length > 256)) ||
+        (runtime.currentProcessIdentityV2 !== null &&
+            (runtime.currentProcessIdentityV2.length === 0 ||
+                runtime.currentProcessIdentityV2.length > 256)) ||
         !isPositiveSafeInteger(runtime.currentProcessStartedAtMs) ||
         !isPositiveSafeInteger(runtime.leaseMs) ||
         !isPositiveSafeInteger(createdAtMs)) {
@@ -721,191 +976,444 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         leaseVersion: 1,
         pid: runtime.currentPid,
         ...(runtime.currentProcessIdentity ? { processIdentity: runtime.currentProcessIdentity } : {}),
+        ...(runtime.currentProcessIdentityV2
+            ? { processIdentityV2: runtime.currentProcessIdentityV2 }
+            : {}),
         processStartedAtMs: runtime.currentProcessStartedAtMs,
         token,
     };
-    await fs.mkdir(outputDir, { recursive: true });
+    const compatibilityOwner = {
+        ...owner,
+        createdAtMs: 1,
+    };
     for (;;) {
         const lockClaims = await listLockClaims(lockDirectory);
         if (lockClaims.length > 0 || (await pathExists(`${lockDirectory}${LEGACY_RECOVERY_SUFFIX}`))) {
             await resolveLockClaims({
                 beforeRecoveryDeleteClaim: dependencies.beforeRecoveryDeleteClaim ?? (async () => undefined),
                 lockDirectory,
-                outputDir,
+                outputDir: requestedOutputDir,
                 requestedChannel: params.channel,
                 runtime,
             });
             continue;
         }
+        const ownerDirectory = `${lockDirectory}${OWNED_CLAIM_SUFFIX}.${token}`;
         const { candidateDirectory, securedDirectory } = await createLockCandidate({
             ...(dependencies.afterLockOwnerWrite
                 ? { afterOwnerWrite: dependencies.afterLockOwnerWrite }
                 : {}),
+            includeLease: false,
             lockDirectory,
-            owner,
+            owner: compatibilityOwner,
             ...(dependencies.platform ? { platform: dependencies.platform } : {}),
             ...(dependencies.secureWindowsDirectory
                 ? { secureWindowsDirectory: dependencies.secureWindowsDirectory }
                 : {}),
         });
+        let ownerCandidate;
+        try {
+            ownerCandidate = await createLockCandidate({
+                candidateDirectory: `${lockDirectory}.${runtime.currentPid}.${token}.owned.tmp`,
+                lockDirectory: ownerDirectory,
+                owner,
+                ...(dependencies.platform ? { platform: dependencies.platform } : {}),
+                ...(dependencies.secureWindowsDirectory
+                    ? { secureWindowsDirectory: dependencies.secureWindowsDirectory }
+                    : {}),
+            });
+        }
+        catch (error) {
+            await fs.rm(candidateDirectory, { force: true, recursive: true }).catch(() => undefined);
+            throw error;
+        }
+        let compatibilityMarkerHandle;
+        try {
+            compatibilityMarkerHandle = await fs.open(path.join(candidateDirectory, LOCK_OWNER_FILE), "r+");
+            const compatibilityRecord = await readLockRecordFromHandle(compatibilityMarkerHandle);
+            if (compatibilityRecord.owner.token !== token) {
+                throw new Error("OpenClaw Crabline smoke lock compatibility marker was replaced.");
+            }
+            const activeAt = new Date(createdAtMs);
+            await compatibilityMarkerHandle.utimes(activeAt, activeAt);
+            await compatibilityMarkerHandle.sync();
+        }
+        catch (error) {
+            await compatibilityMarkerHandle?.close().catch(() => undefined);
+            await fs.rm(candidateDirectory, { force: true, recursive: true }).catch(() => undefined);
+            await fs
+                .rm(ownerCandidate.candidateDirectory, { force: true, recursive: true })
+                .catch(() => undefined);
+            throw error;
+        }
+        if (!compatibilityMarkerHandle) {
+            throw new Error("OpenClaw Crabline smoke lock compatibility marker was not opened.");
+        }
+        const markerHandle = compatibilityMarkerHandle;
         try {
             await fs.rename(candidateDirectory, lockDirectory);
         }
         catch (error) {
+            await markerHandle.close().catch(() => undefined);
             await fs.rm(candidateDirectory, { force: true, recursive: true }).catch(() => undefined);
+            await fs
+                .rm(ownerCandidate.candidateDirectory, { force: true, recursive: true })
+                .catch(() => undefined);
             await resolveLockContention({
                 beforeRecoveryDeleteClaim: dependencies.beforeRecoveryDeleteClaim ?? (async () => undefined),
                 cause: error,
                 lockDirectory,
-                outputDir,
+                outputDir: requestedOutputDir,
                 requestedChannel: params.channel,
                 runtime,
                 beforeRecoveryClaim: dependencies.beforeRecoveryClaim ?? (async () => undefined),
             });
             continue;
         }
-        await dependencies.afterLockCandidateInstall?.(lockDirectory);
-        await securedDirectory.assertIdentityAt(lockDirectory);
-        if ((await listLockClaims(lockDirectory)).length > 0 ||
+        let ownerInstalled = false;
+        try {
+            await dependencies.afterLockCandidateInstall?.(lockDirectory);
+            await securedDirectory.assertIdentityAt(lockDirectory);
+            const installed = await readLockRecord(lockDirectory);
+            if (installed.kind !== "record" || installed.record.owner.token !== token) {
+                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+                await markerHandle.close();
+                await fs.rm(ownerCandidate.candidateDirectory, { force: true, recursive: true });
+                continue;
+            }
+            await fs.rename(ownerCandidate.candidateDirectory, ownerDirectory);
+            ownerInstalled = true;
+            await dependencies.afterLockOwnerClaimInstall?.(ownerDirectory);
+            await ownerCandidate.securedDirectory.assertIdentityAt(ownerDirectory);
+        }
+        catch (error) {
+            let cleanupError;
+            try {
+                if (ownerInstalled) {
+                    await removeOwnedLock({
+                        lockDirectory,
+                        ownedDirectory: ownerDirectory,
+                        token,
+                    });
+                }
+                else {
+                    await fs.rm(ownerCandidate.candidateDirectory, { force: true, recursive: true });
+                }
+                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+            }
+            catch (caughtCleanupError) {
+                cleanupError = caughtCleanupError;
+            }
+            try {
+                await markerHandle.close();
+            }
+            catch (closeError) {
+                cleanupError =
+                    cleanupError === undefined
+                        ? closeError
+                        : new AggregateError([cleanupError, closeError], "OpenClaw Crabline smoke lock setup cleanup also failed.");
+            }
+            if (cleanupError !== undefined) {
+                const aggregateError = new AggregateError([error, cleanupError], "OpenClaw Crabline smoke lock setup and cleanup failed.");
+                aggregateError.cause = error;
+                throw aggregateError;
+            }
+            throw error;
+        }
+        const competingClaims = (await listLockClaims(lockDirectory)).filter((claim) => claim.directoryPath !== ownerDirectory);
+        if (competingClaims.length > 0 ||
             (await pathExists(`${lockDirectory}${LEGACY_RECOVERY_SUFFIX}`))) {
-            await removeOwnedLock({
+            const removed = await removeOwnedLock({
                 lockDirectory,
-                ownedDirectory: lockDirectory,
+                ownedDirectory: ownerDirectory,
                 token,
             });
+            if (!removed) {
+                await markerHandle.close();
+                throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+            }
+            try {
+                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+            }
+            finally {
+                await markerHandle.close();
+            }
             await resolveLockClaims({
                 beforeRecoveryDeleteClaim: dependencies.beforeRecoveryDeleteClaim ?? (async () => undefined),
                 lockDirectory,
-                outputDir,
+                outputDir: requestedOutputDir,
                 requestedChannel: params.channel,
                 runtime,
             });
             continue;
         }
-        const installed = await readLockRecord(lockDirectory);
-        if (installed.kind !== "record" || installed.record.owner.token !== token) {
-            continue;
-        }
-        let ownedDirectory = lockDirectory;
+        let ownedDirectory = ownerDirectory;
+        let clockRegressed = false;
+        let lastObservedNowMs = createdAtMs;
+        let lastRenewedAtMs = createdAtMs;
+        let pendingRenewal = Promise.resolve();
         let commitFenceConsumed = false;
+        let markerClosed = false;
+        let markerRetired = false;
         let heartbeat;
-        const renew = async () => {
-            const renewedAtMs = runtime.now();
-            if (!(await renewOwnedLock(ownedDirectory, token, renewedAtMs))) {
-                throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+        const retireMarker = async () => {
+            if (!markerRetired) {
+                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+                markerRetired = true;
+            }
+            if (!markerClosed) {
+                await markerHandle.close();
+                markerClosed = true;
             }
         };
+        const renew = async () => {
+            const renewal = pendingRenewal
+                .catch(() => undefined)
+                .then(async () => {
+                const nowMs = runtime.now();
+                if (nowMs < lastObservedNowMs) {
+                    clockRegressed = true;
+                }
+                else if (clockRegressed && nowMs >= lastRenewedAtMs) {
+                    clockRegressed = false;
+                }
+                lastObservedNowMs = nowMs;
+                const renewedAtMs = clockRegressed ? lastRenewedAtMs + 1 : nowMs;
+                if (!Number.isSafeInteger(renewedAtMs)) {
+                    throw new Error("OpenClaw Crabline smoke lock renewal timestamp overflowed.");
+                }
+                if (!(await renewOwnedLock(ownedDirectory, token, renewedAtMs))) {
+                    throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+                }
+                await dependencies.beforeCompatibilityMarkerRenew?.();
+                if (!(await renewCompatibilityMarker({
+                    handle: markerHandle,
+                    lockDirectory,
+                    renewedAtMs,
+                    securedDirectory,
+                    token,
+                }))) {
+                    throw new Error("OpenClaw Crabline smoke lock compatibility marker was lost.");
+                }
+                lastRenewedAtMs = renewedAtMs;
+            });
+            pendingRenewal = renewal;
+            await renewal;
+        };
         try {
-            heartbeat = (dependencies.startHeartbeat ?? startHeartbeat)(renew, Math.max(1, Math.floor(runtime.leaseMs / 3)));
+            heartbeat = (dependencies.startHeartbeat ?? startHeartbeat)(renew, heartbeatIntervalMs(runtime.leaseMs));
         }
         catch (error) {
-            await removeOwnedLock({
-                lockDirectory,
-                ownedDirectory: lockDirectory,
-                token,
-            });
+            try {
+                await removeOwnedLock({
+                    lockDirectory,
+                    ownedDirectory: ownerDirectory,
+                    token,
+                });
+                await retireMarker();
+            }
+            catch (cleanupError) {
+                const aggregateError = new AggregateError([error, cleanupError], "OpenClaw Crabline smoke lock heartbeat startup and cleanup failed.");
+                aggregateError.cause = error;
+                throw aggregateError;
+            }
             throw error;
         }
         let heartbeatStopped = false;
         let released = false;
         return {
             async assertOwned() {
-                if (released) {
+                if (released || heartbeatStopped) {
                     throw new Error("OpenClaw Crabline smoke lock has already been released.");
                 }
                 heartbeat.assertHealthy();
                 await renew();
                 heartbeat.assertHealthy();
+                await assertCompatibilityMarkerOwned({
+                    lockDirectory,
+                    securedDirectory,
+                    token,
+                });
             },
             async commitFileAtomically({ contents, destinationPath, stageDirectory, stageFile }) {
                 if (released) {
                     throw new Error("OpenClaw Crabline smoke lock has already been released.");
                 }
-                if (commitFenceConsumed || heartbeatStopped || ownedDirectory !== lockDirectory) {
+                if (commitFenceConsumed || heartbeatStopped || ownedDirectory !== ownerDirectory) {
                     throw new Error("OpenClaw Crabline smoke lock has already committed its fence.");
                 }
                 heartbeat.assertHealthy();
                 await renew();
                 heartbeat.assertHealthy();
-                const stagedFileName = `.commit-file.${token}.${randomUUID()}.tmp`;
-                const stagedFilePath = path.join(stageDirectory ?? lockDirectory, stagedFileName);
-                let committed = false;
-                try {
-                    await stageFile(stagedFilePath, contents);
-                    if (stageDirectory) {
-                        await writeCommitStagePath(lockDirectory, stagedFilePath, token);
-                    }
-                    heartbeat.assertHealthy();
-                    await renew();
-                    heartbeat.assertHealthy();
-                    const observedIdentity = await readDirectoryIdentity(lockDirectory);
-                    const observed = await readLockRecord(lockDirectory);
-                    if (observedIdentity === null ||
-                        observed.kind === "missing" ||
-                        observed.record.owner.token !== token) {
-                        throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
-                    }
-                    await dependencies.beforeCommitClaim?.();
-                    const commitClaim = `${lockDirectory}${COMMIT_CLAIM_SUFFIX}.${token}.${randomUUID()}`;
+                const resolvedDestinationPath = await resolveConfinedPath(outputDir, destinationPath, "commit destination", "file");
+                const destinationDirectory = path.dirname(resolvedDestinationPath);
+                const securedDestinationDirectory = destinationDirectory === outputDir
+                    ? securedOutputDirectory
+                    : await securePrivateDirectory(destinationDirectory, privateDirectoryOptions);
+                await securedDestinationDirectory.assertIdentityAt(destinationDirectory);
+                const destinationDirectoryIdentity = await readDirectoryIdentity(destinationDirectory);
+                if (destinationDirectoryIdentity === null) {
+                    throw new Error("OpenClaw Crabline smoke lock commit destination is invalid.");
+                }
+                if (destinationDirectoryIdentity.device !== outputDirectoryIdentity.device) {
+                    throw new Error("OpenClaw Crabline smoke lock commit destination is on another filesystem.");
+                }
+                const resolvedStageDirectory = stageDirectory
+                    ? await resolveConfinedPath(outputDir, stageDirectory, "commit stage directory", "directory")
+                    : ownerDirectory;
+                let stageDirectoryIdentity = null;
+                if (stageDirectory) {
                     try {
-                        await fs.rename(lockDirectory, commitClaim);
+                        stageDirectoryIdentity = await readDirectoryIdentity(resolvedStageDirectory);
                     }
                     catch (error) {
-                        if (isMissingPathError(error)) {
-                            throw new Error("OpenClaw Crabline smoke lock ownership was lost.", {
-                                cause: error,
-                            });
-                        }
-                        throw error;
+                        throw new Error("OpenClaw Crabline smoke lock commit stage directory is invalid.", {
+                            cause: error,
+                        });
                     }
-                    ownedDirectory = commitClaim;
-                    commitFenceConsumed = true;
-                    const claimed = await readLockRecord(commitClaim);
-                    const claimedIdentity = await readDirectoryIdentity(commitClaim);
-                    if (claimed.kind === "missing" ||
-                        claimed.record.owner.token !== token ||
-                        !hasSameDirectoryIdentity(observedIdentity, claimedIdentity)) {
-                        if (!(await pathExists(lockDirectory))) {
-                            try {
-                                await fs.rename(commitClaim, lockDirectory);
-                                ownedDirectory = lockDirectory;
-                            }
-                            catch (error) {
-                                if (!isMissingPathError(error)) {
-                                    throw error;
-                                }
+                }
+                if (stageDirectory && stageDirectoryIdentity === null) {
+                    throw new Error("OpenClaw Crabline smoke lock commit stage directory is invalid.");
+                }
+                if (stageDirectoryIdentity !== null &&
+                    stageDirectoryIdentity.device !== outputDirectoryIdentity.device) {
+                    throw new Error("OpenClaw Crabline smoke lock commit stage directory is on another filesystem.");
+                }
+                const stagedFileName = `.commit-file.${token}.${randomUUID()}.tmp`;
+                const stagedFilePath = path.join(ownerDirectory, stagedFileName);
+                await stageFile(stagedFilePath, contents);
+                if (stageDirectory) {
+                    if (!hasSameDirectoryIdentity(stageDirectoryIdentity, await readDirectoryIdentity(resolvedStageDirectory))) {
+                        throw new Error("OpenClaw Crabline smoke lock commit stage directory identity changed.");
+                    }
+                }
+                const stagedFileIdentity = await readFileIdentity(stagedFilePath);
+                if (stagedFileIdentity === null) {
+                    throw new Error("OpenClaw Crabline smoke lock commit stage file is invalid.");
+                }
+                heartbeat.assertHealthy();
+                await renew();
+                heartbeat.assertHealthy();
+                await dependencies.beforeCommitClaim?.();
+                await assertCompatibilityMarkerOwned({
+                    lockDirectory,
+                    securedDirectory,
+                    token,
+                });
+                const commitClaim = `${lockDirectory}${COMMIT_CLAIM_SUFFIX}.${token}.${randomUUID()}`;
+                const observedIdentity = await readDirectoryIdentity(ownerDirectory);
+                const observed = await readLockRecord(ownerDirectory);
+                if (observedIdentity === null ||
+                    observed.kind === "missing" ||
+                    observed.record.owner.token !== token) {
+                    throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+                }
+                try {
+                    await fs.rename(ownerDirectory, commitClaim);
+                }
+                catch (error) {
+                    if (isMissingPathError(error)) {
+                        throw new Error("OpenClaw Crabline smoke lock ownership was lost.", {
+                            cause: error,
+                        });
+                    }
+                    throw error;
+                }
+                ownedDirectory = commitClaim;
+                commitFenceConsumed = true;
+                const claimed = await readLockRecord(commitClaim);
+                const claimedIdentity = await readDirectoryIdentity(commitClaim);
+                if (claimed.kind === "missing" ||
+                    claimed.record.owner.token !== token ||
+                    !hasSameDirectoryIdentity(observedIdentity, claimedIdentity)) {
+                    if (!(await pathExists(ownerDirectory))) {
+                        try {
+                            await fs.rename(commitClaim, ownerDirectory);
+                            ownedDirectory = ownerDirectory;
+                        }
+                        catch (error) {
+                            if (!isMissingPathError(error)) {
+                                throw error;
                             }
                         }
-                        throw new Error("OpenClaw Crabline smoke lock commit fence was lost.");
                     }
-                    await dependencies.beforeCommitFileRename?.();
-                    heartbeat.assertHealthy();
-                    await renew();
-                    heartbeat.assertHealthy();
-                    await heartbeat.settle();
-                    heartbeat.assertHealthy();
-                    await dependencies.beforeCommitRename?.();
-                    await fs.rename(stageDirectory ? stagedFilePath : path.join(commitClaim, stagedFileName), destinationPath);
-                    committed = true;
-                }
-                finally {
-                    if (!committed && stageDirectory) {
-                        await fs.rm(stagedFilePath, { force: true }).catch(() => undefined);
+                    throw new Error("OpenClaw Crabline smoke lock commit fence was lost.");
+                }
+                await dependencies.beforeCommitFileRename?.();
+                heartbeat.assertHealthy();
+                await renew();
+                heartbeat.assertHealthy();
+                await heartbeat.settle();
+                heartbeat.assertHealthy();
+                await dependencies.beforeCommitRename?.();
+                await assertCompatibilityMarkerOwned({
+                    lockDirectory,
+                    securedDirectory,
+                    token,
+                });
+                const claimedStagedFilePath = path.join(commitClaim, stagedFileName);
+                if (stageDirectory) {
+                    const currentDirectoryIdentity = await readDirectoryIdentity(resolvedStageDirectory);
+                    const currentFileIdentity = await readFileIdentity(claimedStagedFilePath);
+                    if (!hasSameDirectoryIdentity(stageDirectoryIdentity, currentDirectoryIdentity) ||
+                        !hasSameDirectoryIdentity(stagedFileIdentity, currentFileIdentity)) {
+                        const error = new Error("OpenClaw Crabline smoke lock commit stage identity changed.");
+                        Object.assign(error, { code: "ENOENT", path: claimedStagedFilePath });
+                        throw error;
                     }
                 }
+                else if (!hasSameDirectoryIdentity(stagedFileIdentity, await readFileIdentity(claimedStagedFilePath))) {
+                    throw new Error("OpenClaw Crabline smoke lock commit stage identity changed.");
+                }
+                if (!hasSameDirectoryIdentity(outputDirectoryIdentity, await readDirectoryIdentity(outputDir))) {
+                    throw new Error("OpenClaw Crabline smoke lock output directory identity changed.");
+                }
+                await securedOutputDirectory.assertIdentityAt(outputDir);
+                let currentDestinationDirectoryIdentity = null;
+                try {
+                    currentDestinationDirectoryIdentity = await readDirectoryIdentity(destinationDirectory);
+                }
+                catch {
+                    // A replaced directory or symlink is an identity mismatch.
+                }
+                if (!hasSameDirectoryIdentity(destinationDirectoryIdentity, currentDestinationDirectoryIdentity)) {
+                    throw new Error("OpenClaw Crabline smoke lock commit destination directory identity changed.");
+                }
+                await securedDestinationDirectory.assertIdentityAt(destinationDirectory);
+                const revalidatedDestinationPath = await resolveConfinedPath(outputDir, resolvedDestinationPath, "commit destination", "file");
+                if (revalidatedDestinationPath !== resolvedDestinationPath) {
+                    throw new Error("OpenClaw Crabline smoke lock commit destination path identity changed.");
+                }
+                // The owner-only output tree and smoke lock serialize supported writers; confinement does
+                // not treat another process running as the same OS user as a lower-privilege adversary.
+                await fs.rename(claimedStagedFilePath, revalidatedDestinationPath);
             },
             async release() {
                 if (released) {
                     return;
                 }
                 if (!heartbeatStopped) {
-                    await heartbeat.stop();
                     heartbeatStopped = true;
+                    try {
+                        await heartbeat.stop();
+                    }
+                    finally {
+                        await pendingRenewal.catch(() => undefined);
+                    }
+                }
+                else {
+                    await pendingRenewal.catch(() => undefined);
                 }
                 await removeOwnedLock({
                     ...(dependencies.beforeReleaseClaim
                         ? { beforeClaim: dependencies.beforeReleaseClaim }
                         : {}),
+                    ...(dependencies.beforeReleaseRename
+                        ? { beforeRename: dependencies.beforeReleaseRename }
+                        : {}),
+                    ...(dependencies.beforeReleaseRemove
+                        ? { beforeRemove: dependencies.beforeReleaseRemove }
+                        : {}),
                     lockDirectory,
                     onOwnedDirectoryChange: (directoryPath) => {
                         ownedDirectory = directoryPath;
@@ -927,6 +1435,7 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                         token,
                     });
                 }
+                await retireMarker();
                 released = true;
             },
         };