@openclaw/crabline 0.1.12 → 0.1.13

package/dist/src/openclaw/{smoke-lock.js → provider-readiness-lock.js}

@@ -11,7 +11,7 @@ const LOCK_OWNER_FILE = "owner.json";
 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 RECOVERY_CLAIM_SUFFIX = ".recovery";
 const COMMIT_CLAIM_SUFFIX = ".commit";
 const OWNED_CLAIM_SUFFIX = ".owned";
 const RELEASE_CLAIM_SUFFIX = ".release";
@@ -57,7 +57,9 @@ const startHeartbeat = (renew, intervalMs) => {
     return {
         assertHealthy() {
             if (failure !== undefined) {
-                throw new Error("OpenClaw Crabline smoke lock heartbeat failed.", { cause: failure });
+                throw new Error("OpenClaw Crabline provider readiness lock heartbeat failed.", {
+                    cause: failure,
+                });
             }
         },
         async settle() {
@@ -89,7 +91,7 @@ async function readDirectoryIdentity(directoryPath) {
     try {
         const stats = await fs.lstat(directoryPath, { bigint: true });
         if (!stats.isDirectory() || stats.ino <= 0n) {
-            throw new Error("OpenClaw Crabline smoke lock claim is not a directory.");
+            throw new Error("OpenClaw Crabline provider readiness lock claim is not a directory.");
         }
         return {
             device: stats.dev,
@@ -136,7 +138,7 @@ function isOwnedLockArtifactName(name, token) {
 }
 async function removeVerifiedLockDirectory(params) {
     if (!hasSameDirectoryIdentity(params.expectedIdentity, await readDirectoryIdentity(params.directoryPath))) {
-        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+        throw new Error("OpenClaw Crabline provider readiness lock cleanup target changed.");
     }
     await params.beforeRemove?.();
     const quarantinePath = `${params.directoryPath}.cleanup.${randomUUID()}`;
@@ -147,13 +149,13 @@ async function removeVerifiedLockDirectory(params) {
         quarantinedIdentity = { device: stats.dev, inode: stats.ino };
     }
     if (!hasSameDirectoryIdentity(params.expectedIdentity, quarantinedIdentity)) {
-        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+        throw new Error("OpenClaw Crabline provider readiness 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.");
+            throw new Error("OpenClaw Crabline provider readiness lock cleanup found an unexpected artifact.");
         }
         const artifactPath = path.join(quarantinePath, entry);
         const artifactStats = fsSync.lstatSync(artifactPath, { bigint: true });
@@ -161,7 +163,7 @@ async function removeVerifiedLockDirectory(params) {
             artifactStats.isSymbolicLink() ||
             artifactStats.nlink !== 1n ||
             artifactStats.ino <= 0n) {
-            throw new Error("OpenClaw Crabline smoke lock cleanup found an unsafe artifact.");
+            throw new Error("OpenClaw Crabline provider readiness lock cleanup found an unsafe artifact.");
         }
         artifacts.push({
             identity: { device: artifactStats.dev, inode: artifactStats.ino },
@@ -182,7 +184,7 @@ async function removeVerifiedLockDirectory(params) {
             artifactStats.nlink !== 1n ||
             artifactStats.dev !== artifact.identity.device ||
             artifactStats.ino !== artifact.identity.inode) {
-            throw new Error("OpenClaw Crabline smoke lock cleanup artifact changed.");
+            throw new Error("OpenClaw Crabline provider readiness lock cleanup artifact changed.");
         }
         fsSync.unlinkSync(artifact.path);
     }
@@ -191,7 +193,7 @@ async function removeVerifiedLockDirectory(params) {
         finalStats.isSymbolicLink() ||
         finalStats.dev !== params.expectedIdentity.device ||
         finalStats.ino !== params.expectedIdentity.inode) {
-        throw new Error("OpenClaw Crabline smoke lock cleanup target changed.");
+        throw new Error("OpenClaw Crabline provider readiness lock cleanup target changed.");
     }
     fsSync.rmdirSync(quarantinePath);
 }
@@ -208,32 +210,22 @@ function parseLockOwner(contents) {
         parsed = JSON.parse(contents);
     }
     catch (error) {
-        throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.", {
+        throw new Error("OpenClaw Crabline provider readiness 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.");
+        throw new Error("OpenClaw Crabline provider readiness lock owner metadata is malformed.");
     }
     const owner = parsed;
     if (typeof owner.channel !== "string" ||
         !isCrablineServerChannel(owner.channel) ||
+        !isPositiveSafeInteger(owner.createdAtMs) ||
+        owner.lockVersion !== 1 ||
         !isValidProcessId(owner.pid) ||
-        typeof owner.token !== "string" ||
-        !LOCK_TOKEN_PATTERN.test(owner.token)) {
-        throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.");
-    }
-    const hasCreatedAt = owner.createdAtMs !== undefined;
-    const hasProcessStartedAt = owner.processStartedAtMs !== undefined;
-    if (!hasCreatedAt && !hasProcessStartedAt && owner.leaseVersion === undefined) {
-        return {
-            channel: owner.channel,
-            pid: owner.pid,
-            token: owner.token,
-        };
-    }
-    if (!isPositiveSafeInteger(owner.createdAtMs) ||
         !isPositiveSafeInteger(owner.processStartedAtMs) ||
+        typeof owner.token !== "string" ||
+        !LOCK_TOKEN_PATTERN.test(owner.token) ||
         (owner.processIdentity !== undefined &&
             (typeof owner.processIdentity !== "string" ||
                 owner.processIdentity.length === 0 ||
@@ -242,26 +234,12 @@ function parseLockOwner(contents) {
             (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) {
-        return {
-            channel: owner.channel,
-            createdAtMs: owner.createdAtMs,
-            pid: owner.pid,
-            ...(owner.processIdentity ? { processIdentity: owner.processIdentity } : {}),
-            ...(owner.processIdentityV2 ? { processIdentityV2: owner.processIdentityV2 } : {}),
-            processStartedAtMs: owner.processStartedAtMs,
-            token: owner.token,
-        };
-    }
-    if (owner.leaseVersion !== 1) {
-        throw new Error("OpenClaw Crabline smoke lock owner metadata is malformed.");
+        throw new Error("OpenClaw Crabline provider readiness lock owner metadata is malformed.");
     }
     return {
         channel: owner.channel,
         createdAtMs: owner.createdAtMs,
-        leaseVersion: owner.leaseVersion,
+        lockVersion: owner.lockVersion,
         pid: owner.pid,
         ...(owner.processIdentity ? { processIdentity: owner.processIdentity } : {}),
         ...(owner.processIdentityV2 ? { processIdentityV2: owner.processIdentityV2 } : {}),
@@ -288,17 +266,15 @@ async function readLockRecord(lockDirectory) {
     try {
         handle = await fs.open(path.join(lockDirectory, LOCK_OWNER_FILE), "r");
         const record = await readLockRecordFromHandle(handle);
-        if (isRenewableOwner(record.owner)) {
-            try {
-                const leaseStats = await fs.stat(path.join(lockDirectory, leaseFileName(record.owner.token)));
-                if (Number.isFinite(leaseStats.mtimeMs) && leaseStats.mtimeMs > 0) {
-                    record.renewedAtMs = Math.max(record.renewedAtMs, leaseStats.mtimeMs);
-                }
+        try {
+            const leaseStats = await fs.stat(path.join(lockDirectory, leaseFileName(record.owner.token)));
+            if (Number.isFinite(leaseStats.mtimeMs) && leaseStats.mtimeMs > 0) {
+                record.renewedAtMs = Math.max(record.renewedAtMs, leaseStats.mtimeMs);
             }
-            catch (error) {
-                if (!isMissingPathError(error)) {
-                    throw error;
-                }
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
             }
         }
         return { kind: "record", record };
@@ -313,12 +289,6 @@ async function readLockRecord(lockDirectory) {
         await handle?.close();
     }
 }
-function hasProcessIdentity(owner) {
-    return "processStartedAtMs" in owner;
-}
-function isRenewableOwner(owner) {
-    return "leaseVersion" in owner && owner.leaseVersion === 1;
-}
 export const isProcessAlive = (pid) => {
     if (!isValidProcessId(pid)) {
         return false;
@@ -443,29 +413,22 @@ function getCachedCurrentProcessIdentityV2() {
     return (cachedCurrentProcessIdentityV2 ??= getProcessIdentityV2(process.pid));
 }
 function hasExactProcessIdentity(owner) {
-    return hasProcessIdentity(owner) && typeof owner.processIdentity === "string";
-}
-function hasCoarseDarwinProcessIdentity(owner) {
-    if (!hasExactProcessIdentity(owner)) {
-        return false;
-    }
-    return /^darwin:\d+\.\d+:(?!us:).+$/u.test(owner.processIdentity);
+    return typeof owner.processIdentity === "string";
 }
 function compareProcessIdentity(owner, runtime) {
-    if (hasProcessIdentity(owner) &&
-        owner.pid === runtime.currentPid &&
+    if (owner.pid === runtime.currentPid &&
         owner.processStartedAtMs !== runtime.currentProcessStartedAtMs) {
         return "mismatch";
     }
     if (!hasExactProcessIdentity(owner)) {
         return "unknown";
     }
-    if (hasProcessIdentity(owner) && typeof owner.processIdentityV2 === "string") {
+    if (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";
+            return owner.processIdentityV2 === actualProcessIdentityV2 ? "match" : "mismatch";
         }
     }
     const actualProcessIdentity = owner.pid === runtime.currentPid
@@ -474,7 +437,7 @@ function compareProcessIdentity(owner, runtime) {
     if (actualProcessIdentity === null) {
         return "unknown";
     }
-    return owner.processIdentity === actualProcessIdentity ? "legacy" : "mismatch";
+    return owner.processIdentity === actualProcessIdentity ? "match" : "mismatch";
 }
 function hasProcessIdentityMismatch(owner, runtime) {
     return compareProcessIdentity(owner, runtime) === "mismatch";
@@ -488,21 +451,11 @@ function isLockOwnerActive(record, 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);
     return ageMs >= -runtime.leaseMs && ageMs <= runtime.leaseMs;
 }
 function needsLiveOwnerConfirmation(record, runtime) {
-    return (isRenewableOwner(record.owner) &&
-        runtime.isProcessAlive(record.owner.pid) &&
+    return (runtime.isProcessAlive(record.owner.pid) &&
         !hasProcessIdentityMismatch(record.owner, runtime) &&
         !isLockOwnerActive(record, runtime));
 }
@@ -527,7 +480,7 @@ async function confirmObservedOwner(lockDirectory, observed, runtime) {
         : "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 });
+    return new Error(`OpenClaw Crabline provider readiness 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);
@@ -537,7 +490,7 @@ function isPathConfinedTo(rootPath, candidatePath) {
 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.`);
+        throw new Error(`OpenClaw Crabline provider readiness lock ${description} escapes its output directory.`);
     }
     const parentPath = candidateKind === "directory" ? resolvedPath : path.dirname(resolvedPath);
     let realParentPath;
@@ -545,10 +498,10 @@ async function resolveConfinedPath(rootPath, candidatePath, description, candida
         realParentPath = await fs.realpath(parentPath);
     }
     catch {
-        throw new Error(`OpenClaw Crabline smoke lock ${description} is invalid.`);
+        throw new Error(`OpenClaw Crabline provider readiness lock ${description} is invalid.`);
     }
     if (!isPathConfinedTo(rootPath, realParentPath)) {
-        throw new Error(`OpenClaw Crabline smoke lock ${description} escapes its output directory.`);
+        throw new Error(`OpenClaw Crabline provider readiness lock ${description} escapes its output directory.`);
     }
     return candidateKind === "directory"
         ? realParentPath
@@ -616,56 +569,31 @@ async function removeOwnedLock(params) {
     }
     return true;
 }
-async function renewCompatibilityMarker(params) {
-    await params.securedDirectory.assertIdentityAt(params.lockDirectory);
+async function assertReservationOwned(params) {
     const observed = await readLockRecord(params.lockDirectory);
     if (observed.kind === "missing" || observed.record.owner.token !== params.token) {
-        return false;
+        throw new Error("OpenClaw Crabline provider readiness lock reservation was lost.");
+    }
+    try {
+        await params.securedDirectory.assertIdentityAt(params.lockDirectory);
+    }
+    catch (error) {
+        throw new Error("OpenClaw Crabline provider readiness lock reservation was lost.", {
+            cause: error,
+        });
     }
-    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.");
+    if (revalidated.kind === "missing" || revalidated.record.owner.token !== params.token) {
+        throw new Error("OpenClaw Crabline provider readiness lock reservation 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 {
         const observed = await readLockRecord(lockDirectory);
         if (observed.kind === "missing" ||
             observed.record.owner.token !== token ||
-            !isRenewableOwner(observed.record.owner)) {
+            observed.record.owner.lockVersion !== 1) {
             return false;
         }
         await fs.writeFile(temporaryLeasePath, `${JSON.stringify({ renewedAtMs, token })}\n`, {
@@ -679,7 +607,7 @@ async function renewOwnedLock(lockDirectory, token, renewedAtMs) {
         const revalidated = await readLockRecord(lockDirectory);
         if (revalidated.kind === "missing" ||
             revalidated.record.owner.token !== token ||
-            !isRenewableOwner(revalidated.record.owner)) {
+            revalidated.record.owner.lockVersion !== 1) {
             return false;
         }
         await fs.rename(temporaryLeasePath, path.join(lockDirectory, leaseFileName(token)));
@@ -701,7 +629,7 @@ function claimPrefix(lockDirectory, suffix) {
 async function listLockClaims(lockDirectory) {
     const directory = path.dirname(lockDirectory);
     const prefixes = [
-        { kind: "recovering", prefix: claimPrefix(lockDirectory, LEGACY_RECOVERY_SUFFIX) },
+        { kind: "recovery", prefix: claimPrefix(lockDirectory, RECOVERY_CLAIM_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) },
@@ -714,7 +642,7 @@ async function listLockClaims(lockDirectory) {
             continue;
         }
         if (!entry.isDirectory()) {
-            throw new Error("OpenClaw Crabline smoke lock claim is not a directory.");
+            throw new Error("OpenClaw Crabline provider readiness lock claim is not a directory.");
         }
         claims.push({
             directoryPath: path.join(directory, entry.name),
@@ -723,26 +651,6 @@ async function listLockClaims(lockDirectory) {
     }
     return claims.sort((left, right) => left.directoryPath.localeCompare(right.directoryPath));
 }
-async function claimLegacyRecoveryDirectory(lockDirectory, expectedToken) {
-    const legacyRecoveryDirectory = `${lockDirectory}${LEGACY_RECOVERY_SUFFIX}`;
-    if (!(await pathExists(legacyRecoveryDirectory))) {
-        return;
-    }
-    if (expectedToken !== undefined) {
-        const observed = await readLockRecord(legacyRecoveryDirectory);
-        if (observed.kind === "missing" || observed.record.owner.token !== expectedToken) {
-            return;
-        }
-    }
-    try {
-        await fs.rename(legacyRecoveryDirectory, `${lockDirectory}${LEGACY_RECOVERY_SUFFIX}.${randomUUID()}`);
-    }
-    catch (error) {
-        if (!isMissingPathError(error)) {
-            throw error;
-        }
-    }
-}
 async function resolveLockClaim(params) {
     const observed = await readLockRecord(params.claim.directoryPath);
     if (observed.kind === "missing") {
@@ -766,7 +674,7 @@ async function resolveLockClaim(params) {
         return;
     }
     if (isLockOwnerActive(observed.record, params.runtime)) {
-        if (params.claim.kind === "recovering") {
+        if (params.claim.kind === "recovery") {
             try {
                 await fs.rename(params.claim.directoryPath, params.lockDirectory);
             }
@@ -784,7 +692,7 @@ async function resolveLockClaim(params) {
     }
     const confirmation = await confirmObservedOwner(params.claim.directoryPath, observed.record, params.runtime);
     if (confirmation === "renewed") {
-        if (params.claim.kind === "recovering") {
+        if (params.claim.kind === "recovery") {
             try {
                 await fs.rename(params.claim.directoryPath, params.lockDirectory);
             }
@@ -825,7 +733,6 @@ async function resolveLockClaim(params) {
     }
 }
 async function resolveLockClaims(params) {
-    await claimLegacyRecoveryDirectory(params.lockDirectory);
     for (const claim of await listLockClaims(params.lockDirectory)) {
         await resolveLockClaim({
             ...params,
@@ -858,7 +765,7 @@ async function resolveLockContention(params) {
         }
     }
     await params.beforeRecoveryClaim();
-    const claimDirectory = `${params.lockDirectory}${LEGACY_RECOVERY_SUFFIX}.${randomUUID()}`;
+    const claimDirectory = `${params.lockDirectory}${RECOVERY_CLAIM_SUFFIX}.${randomUUID()}`;
     try {
         await fs.rename(params.lockDirectory, claimDirectory);
     }
@@ -873,7 +780,7 @@ async function resolveLockContention(params) {
         ...params,
         claim: {
             directoryPath: claimDirectory,
-            kind: "recovering",
+            kind: "recovery",
         },
     });
 }
@@ -918,7 +825,7 @@ async function createLockCandidate(params) {
         throw error;
     }
 }
-export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies = {}) {
+export async function acquireOpenClawCrablineProviderReadinessLock(params, dependencies = {}) {
     const requestedOutputDir = path.resolve(params.outputDir);
     await fs.mkdir(requestedOutputDir, { recursive: true });
     const outputDir = await fs.realpath(requestedOutputDir);
@@ -932,7 +839,7 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
     await securedOutputDirectory.assertIdentityAt(outputDir);
     const outputDirectoryIdentity = await readDirectoryIdentity(outputDir);
     if (outputDirectoryIdentity === null) {
-        throw new Error("OpenClaw Crabline smoke lock output directory is invalid.");
+        throw new Error("OpenClaw Crabline provider readiness lock output directory is invalid.");
     }
     const lockDirectory = path.join(outputDir, `.${OPENCLAW_CRABLINE_MANIFEST_PATH}.lock`);
     const token = randomUUID();
@@ -968,12 +875,12 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         !isPositiveSafeInteger(runtime.currentProcessStartedAtMs) ||
         !isPositiveSafeInteger(runtime.leaseMs) ||
         !isPositiveSafeInteger(createdAtMs)) {
-        throw new Error("Invalid OpenClaw Crabline smoke lock runtime.");
+        throw new Error("Invalid OpenClaw Crabline provider readiness lock runtime.");
     }
     const owner = {
         channel: params.channel,
         createdAtMs,
-        leaseVersion: 1,
+        lockVersion: 1,
         pid: runtime.currentPid,
         ...(runtime.currentProcessIdentity ? { processIdentity: runtime.currentProcessIdentity } : {}),
         ...(runtime.currentProcessIdentityV2
@@ -982,13 +889,9 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         processStartedAtMs: runtime.currentProcessStartedAtMs,
         token,
     };
-    const compatibilityOwner = {
-        ...owner,
-        createdAtMs: 1,
-    };
     for (;;) {
         const lockClaims = await listLockClaims(lockDirectory);
-        if (lockClaims.length > 0 || (await pathExists(`${lockDirectory}${LEGACY_RECOVERY_SUFFIX}`))) {
+        if (lockClaims.length > 0) {
             await resolveLockClaims({
                 beforeRecoveryDeleteClaim: dependencies.beforeRecoveryDeleteClaim ?? (async () => undefined),
                 lockDirectory,
@@ -1000,12 +903,11 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         }
         const ownerDirectory = `${lockDirectory}${OWNED_CLAIM_SUFFIX}.${token}`;
         const { candidateDirectory, securedDirectory } = await createLockCandidate({
-            ...(dependencies.afterLockOwnerWrite
-                ? { afterOwnerWrite: dependencies.afterLockOwnerWrite }
+            ...(dependencies.afterLockReservationWrite
+                ? { afterOwnerWrite: dependencies.afterLockReservationWrite }
                 : {}),
-            includeLease: false,
             lockDirectory,
-            owner: compatibilityOwner,
+            owner,
             ...(dependencies.platform ? { platform: dependencies.platform } : {}),
             ...(dependencies.secureWindowsDirectory
                 ? { secureWindowsDirectory: dependencies.secureWindowsDirectory }
@@ -1027,34 +929,10 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
             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 })
@@ -1076,8 +954,6 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
             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;
             }
@@ -1099,44 +975,38 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                 else {
                     await fs.rm(ownerCandidate.candidateDirectory, { force: true, recursive: true });
                 }
-                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+                await removeOwnedLock({
+                    lockDirectory,
+                    ownedDirectory: lockDirectory,
+                    token,
+                });
             }
             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.");
+                const aggregateError = new AggregateError([error, cleanupError], "OpenClaw Crabline provider readiness 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}`))) {
+        if (competingClaims.length > 0) {
             const removed = await removeOwnedLock({
                 lockDirectory,
                 ownedDirectory: ownerDirectory,
                 token,
             });
             if (!removed) {
-                await markerHandle.close();
-                throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
-            }
-            try {
-                await retireCompatibilityMarker(markerHandle, compatibilityOwner);
+                throw new Error("OpenClaw Crabline provider readiness lock ownership was lost.");
             }
-            finally {
-                await markerHandle.close();
+            if (!(await removeOwnedLock({
+                lockDirectory,
+                ownedDirectory: lockDirectory,
+                token,
+            }))) {
+                throw new Error("OpenClaw Crabline provider readiness lock reservation was lost.");
             }
             await resolveLockClaims({
                 beforeRecoveryDeleteClaim: dependencies.beforeRecoveryDeleteClaim ?? (async () => undefined),
@@ -1153,19 +1023,7 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         let lastRenewedAtMs = createdAtMs;
         let pendingRenewal = Promise.resolve();
         let commitFenceConsumed = false;
-        let markerClosed = false;
-        let markerRetired = false;
         let heartbeat;
-        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)
@@ -1180,20 +1038,14 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                 lastObservedNowMs = nowMs;
                 const renewedAtMs = clockRegressed ? lastRenewedAtMs + 1 : nowMs;
                 if (!Number.isSafeInteger(renewedAtMs)) {
-                    throw new Error("OpenClaw Crabline smoke lock renewal timestamp overflowed.");
+                    throw new Error("OpenClaw Crabline provider readiness lock renewal timestamp overflowed.");
                 }
                 if (!(await renewOwnedLock(ownedDirectory, token, renewedAtMs))) {
-                    throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+                    throw new Error("OpenClaw Crabline provider readiness 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.");
+                await dependencies.beforeReservationRenew?.();
+                if (!(await renewOwnedLock(lockDirectory, token, renewedAtMs))) {
+                    throw new Error("OpenClaw Crabline provider readiness lock reservation was lost.");
                 }
                 lastRenewedAtMs = renewedAtMs;
             });
@@ -1210,10 +1062,14 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                     ownedDirectory: ownerDirectory,
                     token,
                 });
-                await retireMarker();
+                await removeOwnedLock({
+                    lockDirectory,
+                    ownedDirectory: lockDirectory,
+                    token,
+                });
             }
             catch (cleanupError) {
-                const aggregateError = new AggregateError([error, cleanupError], "OpenClaw Crabline smoke lock heartbeat startup and cleanup failed.");
+                const aggregateError = new AggregateError([error, cleanupError], "OpenClaw Crabline provider readiness lock heartbeat startup and cleanup failed.");
                 aggregateError.cause = error;
                 throw aggregateError;
             }
@@ -1224,12 +1080,12 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
         return {
             async assertOwned() {
                 if (released || heartbeatStopped) {
-                    throw new Error("OpenClaw Crabline smoke lock has already been released.");
+                    throw new Error("OpenClaw Crabline provider readiness lock has already been released.");
                 }
                 heartbeat.assertHealthy();
                 await renew();
                 heartbeat.assertHealthy();
-                await assertCompatibilityMarkerOwned({
+                await assertReservationOwned({
                     lockDirectory,
                     securedDirectory,
                     token,
@@ -1237,10 +1093,10 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
             },
             async commitFileAtomically({ contents, destinationPath, stageDirectory, stageFile }) {
                 if (released) {
-                    throw new Error("OpenClaw Crabline smoke lock has already been released.");
+                    throw new Error("OpenClaw Crabline provider readiness lock has already been released.");
                 }
                 if (commitFenceConsumed || heartbeatStopped || ownedDirectory !== ownerDirectory) {
-                    throw new Error("OpenClaw Crabline smoke lock has already committed its fence.");
+                    throw new Error("OpenClaw Crabline provider readiness lock has already committed its fence.");
                 }
                 heartbeat.assertHealthy();
                 await renew();
@@ -1253,10 +1109,10 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                 await securedDestinationDirectory.assertIdentityAt(destinationDirectory);
                 const destinationDirectoryIdentity = await readDirectoryIdentity(destinationDirectory);
                 if (destinationDirectoryIdentity === null) {
-                    throw new Error("OpenClaw Crabline smoke lock commit destination is invalid.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit destination is invalid.");
                 }
                 if (destinationDirectoryIdentity.device !== outputDirectoryIdentity.device) {
-                    throw new Error("OpenClaw Crabline smoke lock commit destination is on another filesystem.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit destination is on another filesystem.");
                 }
                 const resolvedStageDirectory = stageDirectory
                     ? await resolveConfinedPath(outputDir, stageDirectory, "commit stage directory", "directory")
@@ -1267,35 +1123,35 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                         stageDirectoryIdentity = await readDirectoryIdentity(resolvedStageDirectory);
                     }
                     catch (error) {
-                        throw new Error("OpenClaw Crabline smoke lock commit stage directory is invalid.", {
+                        throw new Error("OpenClaw Crabline provider readiness lock commit stage directory is invalid.", {
                             cause: error,
                         });
                     }
                 }
                 if (stageDirectory && stageDirectoryIdentity === null) {
-                    throw new Error("OpenClaw Crabline smoke lock commit stage directory is invalid.");
+                    throw new Error("OpenClaw Crabline provider readiness 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.");
+                    throw new Error("OpenClaw Crabline provider readiness 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.");
+                        throw new Error("OpenClaw Crabline provider readiness 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.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit stage file is invalid.");
                 }
                 heartbeat.assertHealthy();
                 await renew();
                 heartbeat.assertHealthy();
                 await dependencies.beforeCommitClaim?.();
-                await assertCompatibilityMarkerOwned({
+                await assertReservationOwned({
                     lockDirectory,
                     securedDirectory,
                     token,
@@ -1306,14 +1162,14 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                 if (observedIdentity === null ||
                     observed.kind === "missing" ||
                     observed.record.owner.token !== token) {
-                    throw new Error("OpenClaw Crabline smoke lock ownership was lost.");
+                    throw new Error("OpenClaw Crabline provider readiness 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.", {
+                        throw new Error("OpenClaw Crabline provider readiness lock ownership was lost.", {
                             cause: error,
                         });
                     }
@@ -1337,7 +1193,7 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                             }
                         }
                     }
-                    throw new Error("OpenClaw Crabline smoke lock commit fence was lost.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit fence was lost.");
                 }
                 await dependencies.beforeCommitFileRename?.();
                 heartbeat.assertHealthy();
@@ -1346,7 +1202,7 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                 await heartbeat.settle();
                 heartbeat.assertHealthy();
                 await dependencies.beforeCommitRename?.();
-                await assertCompatibilityMarkerOwned({
+                await assertReservationOwned({
                     lockDirectory,
                     securedDirectory,
                     token,
@@ -1357,16 +1213,16 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                     const currentFileIdentity = await readFileIdentity(claimedStagedFilePath);
                     if (!hasSameDirectoryIdentity(stageDirectoryIdentity, currentDirectoryIdentity) ||
                         !hasSameDirectoryIdentity(stagedFileIdentity, currentFileIdentity)) {
-                        const error = new Error("OpenClaw Crabline smoke lock commit stage identity changed.");
+                        const error = new Error("OpenClaw Crabline provider readiness 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.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit stage identity changed.");
                 }
                 if (!hasSameDirectoryIdentity(outputDirectoryIdentity, await readDirectoryIdentity(outputDir))) {
-                    throw new Error("OpenClaw Crabline smoke lock output directory identity changed.");
+                    throw new Error("OpenClaw Crabline provider readiness lock output directory identity changed.");
                 }
                 await securedOutputDirectory.assertIdentityAt(outputDir);
                 let currentDestinationDirectoryIdentity = null;
@@ -1377,14 +1233,14 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                     // 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.");
+                    throw new Error("OpenClaw Crabline provider readiness 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.");
+                    throw new Error("OpenClaw Crabline provider readiness lock commit destination path identity changed.");
                 }
-                // The owner-only output tree and smoke lock serialize supported writers; confinement does
+                // The owner-only output tree and provider readiness 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);
             },
@@ -1424,7 +1280,6 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                         : {}),
                     token,
                 });
-                await claimLegacyRecoveryDirectory(lockDirectory, token);
                 for (const claim of await listLockClaims(lockDirectory)) {
                     await removeOwnedLock({
                         lockDirectory,
@@ -1435,13 +1290,20 @@ export async function acquireOpenClawCrablineSmokeRunLock(params, dependencies =
                         token,
                     });
                 }
-                await retireMarker();
+                await removeOwnedLock({
+                    lockDirectory,
+                    ownedDirectory: lockDirectory,
+                    ...(dependencies.removeDirectory
+                        ? { removeDirectory: dependencies.removeDirectory }
+                        : {}),
+                    token,
+                });
                 released = true;
             },
         };
     }
 }
-export async function releaseOpenClawCrablineSmokeRunLock(lock, dependencies = {}) {
+export async function releaseOpenClawCrablineProviderReadinessLock(lock, dependencies = {}) {
     for (let attempt = 1;; attempt += 1) {
         try {
             await lock.release();
@@ -1455,4 +1317,4 @@ export async function releaseOpenClawCrablineSmokeRunLock(lock, dependencies = {
         }
     }
 }
-//# sourceMappingURL=smoke-lock.js.map
+//# sourceMappingURL=provider-readiness-lock.js.map