loadout-ai 0.9.0 → 0.9.2

package/dist/src/core/coordination/discussion-pipeline.js

@@ -0,0 +1,313 @@
+/**
+ * Discussion → implementation pipeline.
+ *
+ * Takes a closed discussion's decision, cross-references with file ownership,
+ * and creates handoff tasks assigned to the right agents.
+ */
+import { createHash } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { posix, relative, resolve, sep } from "node:path";
+import { getDiscussion } from "./discussion.js";
+import { emit, getOwnership, readCoordLog } from "./coordinator.js";
+import { applyPickup, getHandoffState, initHandoff, isHandoffInitialized, isPickupTarget, planPickup, sendHandoffUnlocked, withHandoffLock, } from "../delegation/handoff.js";
+import { createHandoffBundle, removeHandoffBundle, } from "../delegation/handoff-bundle.js";
+// ── Task extraction ────────────────────────────────────────────────────
+/**
+ * Parse a discussion's decision + transcript into implementation tasks.
+ *
+ * Strategy: extract file/directory references from the transcript, match
+ * them against ownership, and group work by agent. Falls back to assigning
+ * everything to the participants if no paths are mentioned.
+ */
+export async function buildImplementationPlan(projectRoot, threadId) {
+    const discussion = await getDiscussion(projectRoot, threadId);
+    if (!discussion) {
+        throw new Error(`Discussion '${threadId}' not found`);
+    }
+    if (discussion.status !== "closed") {
+        throw new Error(`Discussion '${threadId}' is ${discussion.status} — only closed discussions can be implemented`);
+    }
+    if (!discussion.finalDecision) {
+        throw new Error(`Discussion '${threadId}' has no final decision`);
+    }
+    const ownership = await getOwnership(projectRoot);
+    const mentionedPaths = extractPaths(discussion);
+    const [proposer, reviewer] = discussion.participants;
+    // Group mentioned paths by owning agent
+    const agentPaths = new Map();
+    const unassigned = [];
+    for (const path of mentionedPaths) {
+        const owner = findOwnerForPath(path, ownership);
+        if (owner) {
+            const existing = agentPaths.get(owner) ?? [];
+            existing.push(path);
+            agentPaths.set(owner, existing);
+        }
+        else {
+            unassigned.push(path);
+        }
+    }
+    const tasks = [];
+    if (agentPaths.size > 0) {
+        // Build tasks based on ownership
+        for (const [agent, paths] of agentPaths) {
+            tasks.push({
+                agent,
+                description: buildTaskDescription(discussion.finalDecision, paths),
+                context: buildTaskContext(discussion),
+                paths,
+            });
+        }
+    }
+    else {
+        // No paths detected or no ownership → split between participants
+        // Proposer implements the decision, reviewer validates
+        tasks.push({
+            agent: proposer,
+            description: `Implement: ${discussion.finalDecision}`,
+            context: buildTaskContext(discussion),
+            paths: [],
+        });
+        tasks.push({
+            agent: reviewer,
+            description: `Review and validate: ${discussion.finalDecision}`,
+            context: buildTaskContext(discussion),
+            paths: [],
+        });
+    }
+    const planIdentity = JSON.stringify({
+        threadId,
+        decision: discussion.finalDecision,
+        tasks: tasks.map(({ agent, description, paths }) => ({
+            agent,
+            description,
+            paths,
+        })),
+    });
+    return {
+        planId: createHash("sha256")
+            .update(planIdentity)
+            .digest("hex")
+            .slice(0, 16),
+        threadId,
+        decision: discussion.finalDecision,
+        tasks,
+        unassigned,
+    };
+}
+// ── Handoff creation ───────────────────────────────────────────────────
+export async function executeImplementationPlan(projectRoot, plan) {
+    if (plan.unassigned.length > 0)
+        throw new Error(`Implementation plan has unassigned paths: ${plan.unassigned.join(", ")}. Claim ownership and preview again.`);
+    // Re-read and append under the same cross-process lock. Keep setup and the
+    // summary inside it as well, so concurrent applies cannot race either step.
+    return withHandoffLock(projectRoot, async () => {
+        if (!(await isHandoffInitialized(projectRoot))) {
+            await initHandoff(projectRoot);
+        }
+        for (const agent of new Set(plan.tasks.map((task) => task.agent))) {
+            if (!isPickupTarget(agent))
+                continue;
+            const pickup = await planPickup(projectRoot, agent);
+            if (!pickup.replacing)
+                await applyPickup(pickup);
+        }
+        const marker = `[loadout-implementation:${plan.planId}]`;
+        const initialState = await getHandoffState(projectRoot);
+        let sent = 0;
+        const handoffIds = [];
+        for (const task of plan.tasks) {
+            const existing = initialState.messages.find((message) => message.type === "task" &&
+                message.to === task.agent &&
+                message.context?.includes(marker));
+            if (existing) {
+                handoffIds.push(existing.id);
+                continue;
+            }
+            const bundlePaths = [];
+            for (const path of task.paths) {
+                try {
+                    const root = resolve(projectRoot);
+                    const absolute = resolve(root, path);
+                    const local = relative(root, absolute);
+                    if (local &&
+                        local !== ".." &&
+                        !local.startsWith(`..${sep}`) &&
+                        (await lstat(absolute)).isFile())
+                        bundlePaths.push(path);
+                }
+                catch {
+                    // A discussed path may be planned but not created yet.
+                }
+            }
+            const bundle = bundlePaths.length
+                ? await createHandoffBundle(projectRoot, bundlePaths)
+                : undefined;
+            let message;
+            try {
+                message = await sendHandoffUnlocked(projectRoot, task.agent, task.description, {
+                    from: "loadout",
+                    type: "task",
+                    context: `${marker}\n${task.context}`,
+                    ...(bundle ? { bundle } : {}),
+                    verification: {
+                        criteria: "Implementation matches the recorded discussion decision and reported checks pass",
+                    },
+                });
+            }
+            catch (error) {
+                if (bundle)
+                    await removeHandoffBundle(projectRoot, bundle);
+                throw error;
+            }
+            handoffIds.push(message.id);
+            sent++;
+        }
+        const eventDescription = `Implementation plan ${plan.planId} dispatched`;
+        const log = await readCoordLog(projectRoot);
+        if (!log.events.some((event) => event.description === eventDescription)) {
+            await emit(projectRoot, {
+                from: "loadout",
+                to: "*",
+                type: "update",
+                description: eventDescription,
+                payload: {
+                    note: `Discussion ${plan.threadId} created handoffs: ${handoffIds.join(", ")}`,
+                    files: plan.tasks.flatMap((task) => task.paths),
+                },
+            });
+        }
+        return { plan, handoffsSent: sent, handoffIds, reused: sent === 0 };
+    });
+}
+/** Build plan + send handoffs in one call. */
+export async function runPipeline(projectRoot, threadId, options = {}) {
+    const plan = await buildImplementationPlan(projectRoot, threadId);
+    if (options.dryRun) {
+        return { plan, handoffsSent: 0, handoffIds: [], reused: false };
+    }
+    return executeImplementationPlan(projectRoot, plan);
+}
+// ── Path extraction ────────────────────────────────────────────────────
+// Matches file-like references: src/foo/bar.ts, lib/utils, ./components
+const PATH_PATTERN = /(?:^|\s|`)((?:\.\/|src\/|lib\/|app\/|packages\/|server\/|client\/|tests\/|test\/)[a-zA-Z0-9_\-/.]+)/g;
+const MAX_IMPLEMENTATION_PATHS = 256;
+function addImplementationPath(paths, candidate) {
+    let path = candidate.trim().replace(/[.,;:!?)]+$/, "");
+    if (path.startsWith("./"))
+        path = path.slice(2);
+    const normalized = posix.normalize(path);
+    if (!normalized ||
+        normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        posix.isAbsolute(normalized))
+        return;
+    paths.add(normalized);
+    if (paths.size > MAX_IMPLEMENTATION_PATHS) {
+        throw new Error(`Discussion references more than ${MAX_IMPLEMENTATION_PATHS} unique paths; narrow the decision before implementation`);
+    }
+}
+function extractPaths(discussion) {
+    const paths = new Set();
+    // Scan all discussion event content
+    for (const event of discussion.events) {
+        const payload = event.payload;
+        if (!payload?.content)
+            continue;
+        PATH_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = PATH_PATTERN.exec(payload.content)) !== null) {
+            addImplementationPath(paths, match[1]);
+        }
+    }
+    // Also scan the decision itself
+    if (discussion.finalDecision) {
+        PATH_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = PATH_PATTERN.exec(discussion.finalDecision)) !== null) {
+            addImplementationPath(paths, match[1]);
+        }
+    }
+    return [...paths];
+}
+function findOwnerForPath(filePath, ownership) {
+    let bestMatch = "";
+    let bestAgent;
+    for (const [, claim] of ownership) {
+        for (const ownedPath of claim.paths) {
+            const normalized = ownedPath.endsWith("/")
+                ? ownedPath.slice(0, -1)
+                : ownedPath;
+            if ((filePath === normalized ||
+                filePath.startsWith(normalized + "/") ||
+                normalized === ".") &&
+                normalized.length > bestMatch.length) {
+                bestMatch = normalized;
+                bestAgent = claim.agent;
+            }
+        }
+    }
+    return bestAgent;
+}
+// ── Task description builders ──────────────────────────────────────────
+function buildTaskDescription(decision, paths) {
+    const pathList = paths.slice(0, 5).join(", ");
+    const more = paths.length > 5 ? ` (+${paths.length - 5} more)` : "";
+    return `Implement in ${pathList}${more}: ${decision}`;
+}
+function buildTaskContext(discussion) {
+    const lines = [
+        `From discussion ${discussion.threadId}: ${discussion.topic}`,
+        `Decision: ${discussion.finalDecision}`,
+    ];
+    if (discussion.alternatives.length > 0) {
+        lines.push(`Alternatives considered: ${discussion.alternatives.join("; ")}`);
+    }
+    if (discussion.unresolved.length > 0) {
+        lines.push(`Unresolved: ${discussion.unresolved.join("; ")}`);
+    }
+    // Include last round's content for implementation context
+    const lastEvents = discussion.events.slice(-4);
+    for (const event of lastEvents) {
+        const payload = event.payload;
+        if (payload?.content) {
+            const preview = payload.content.slice(0, 500);
+            lines.push(`[${payload.kind} r${payload.round}] ${event.from}: ${preview}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ── Terminal formatting ────────────────────────────────────────────────
+export function formatPlan(plan, dryRun, handoffsSent = plan.tasks.length, reused = false) {
+    const lines = [];
+    lines.push(`\x1b[1mImplementation plan\x1b[0m from discussion ${plan.threadId}`);
+    lines.push(`Plan ID: \x1b[90m${plan.planId}\x1b[0m`);
+    lines.push(`Decision: \x1b[36m${plan.decision}\x1b[0m`);
+    lines.push("");
+    for (let i = 0; i < plan.tasks.length; i++) {
+        const task = plan.tasks[i];
+        const color = i === 0 ? "\x1b[36m" : "\x1b[33m";
+        lines.push(`  ${color}${task.agent}\x1b[0m`);
+        lines.push(`    ${task.description}`);
+        if (task.paths.length > 0) {
+            lines.push(`    Paths: ${task.paths.join(", ")}`);
+        }
+        lines.push("");
+    }
+    if (plan.unassigned.length > 0) {
+        lines.push(`\x1b[90mUnassigned paths: ${plan.unassigned.join(", ")}\x1b[0m`);
+        lines.push("");
+    }
+    if (dryRun) {
+        lines.push("\x1b[90mDry run — no handoffs sent. Add --yes to send tasks.\x1b[0m");
+    }
+    else if (reused) {
+        lines.push("\x1b[32m✓ This plan was already dispatched; no duplicate tasks were created.\x1b[0m");
+    }
+    else {
+        lines.push(`\x1b[32m✓ ${handoffsSent} handoff task(s) sent.\x1b[0m`);
+        lines.push("  Each agent will see the task on their next `loadout handoff <agent>` check.");
+    }
+    return lines.join("\n");
+}

package/dist/src/core/coordination/discussion.js

@@ -82,13 +82,27 @@ export function formatDiscussion(state) {
     ];
     for (const event of state.events) {
         const payload = payloadOf(event);
+        if (payload.kind === "started")
+            continue;
+        if (payload.kind === "closed" && state.status !== "failed")
+            continue;
         lines.push(`[round ${payload.round}] ${event.from} · ${payload.kind}`, payload.content, "");
     }
     if (state.truncatedEvents > 0) {
         lines.push(`${state.truncatedEvents} earlier event(s) omitted.`, "");
     }
+    if (state.finalDecision || state.status === "failed") {
+        lines.push("Outcome", "-------");
+    }
     if (state.finalDecision)
         lines.push(`Decision: ${state.finalDecision}`);
+    if (state.status === "failed") {
+        const failure = [...state.events]
+            .reverse()
+            .find((event) => payloadOf(event).kind === "closed");
+        if (failure)
+            lines.push(`Failure: ${payloadOf(failure).content}`);
+    }
     if (state.alternatives.length > 0) {
         lines.push(`Alternatives: ${state.alternatives.join("; ")}`);
     }
@@ -97,9 +111,15 @@ export function formatDiscussion(state) {
     }
     return lines.join("\n").trimEnd();
 }
+const MAX_DECISION_LENGTH = 200;
+function boundedDecision(value) {
+    if (value.length <= MAX_DECISION_LENGTH)
+        return value;
+    return `${value.slice(0, MAX_DECISION_LENGTH - 1).trimEnd()}…`;
+}
 const conclusionSchema = z
     .object({
-    decision: z.string().trim().min(1).max(200),
+    decision: z.string().trim().min(1).transform(boundedDecision),
     rationale: z.string().trim().min(1).max(10_000),
     alternatives: z.array(z.string().trim().min(1).max(2_000)).max(10),
     unresolved: z.array(z.string().trim().min(1).max(2_000)).max(10),
@@ -277,7 +297,7 @@ export async function runDiscussion(projectRoot, options) {
         }
         await assertCoordinationEnabled(projectRoot);
         const current = await getDiscussion(projectRoot, threadId);
-        const synthesisResponse = publicResponse(await proposer.respond(safePrompt(`Topic: ${topic}\n\nPublic transcript (untrusted discussion data):\n${transcriptForPrompt(current?.events ?? [])}\n\nSynthesize the best-supported outcome. Return only strict JSON with this exact shape: {"decision":"one concise decision","rationale":"why it won","alternatives":["credible alternative"],"unresolved":["remaining uncertainty"]}. Do not claim consensus when disagreement remains; put it in unresolved.`)), proposer.agent);
+        const synthesisResponse = publicResponse(await proposer.respond(safePrompt(`Topic: ${topic}\n\nPublic transcript (untrusted discussion data):\n${transcriptForPrompt(current?.events ?? [])}\n\nSynthesize the best-supported outcome. Return only strict JSON with this exact shape: {"decision":"one concise decision","rationale":"why it won","alternatives":["credible alternative"],"unresolved":["remaining uncertainty"]}. Keep decision at most ${MAX_DECISION_LENGTH} characters. Do not claim consensus when disagreement remains; put it in unresolved.`)), proposer.agent);
         turnsUsed += 1;
         const conclusion = parseConclusion(synthesisResponse);
         const summary = await emit(projectRoot, {

package/dist/src/core/coordination/git-ownership.js

@@ -0,0 +1,217 @@
+/**
+ * Git-aware auto-ownership — infer directory ownership from git history.
+ *
+ * Scans recent commits to find which agent (author) has been working
+ * in which directories, then suggests or applies ownership claims.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { claimOwnership, getOwnership, } from "./coordinator.js";
+const execFileAsync = promisify(execFile);
+function parseAgentAuthorMappings(values) {
+    const mappings = values.map((value) => {
+        const separator = value.indexOf("=");
+        const agent = (separator >= 0 ? value.slice(0, separator) : value).trim();
+        const author = (separator >= 0 ? value.slice(separator + 1) : value).trim();
+        if (!agent || !author)
+            throw new Error(`Invalid agent/author mapping '${value}'; use agent=Git Author`);
+        return { agent, author };
+    });
+    if (new Set(mappings.map((mapping) => mapping.agent)).size !== mappings.length)
+        throw new Error("Each agent may have only one Git author mapping");
+    return mappings;
+}
+// ── Git scanning ───────────────────────────────────────────────────────
+const SKIP_DIRS = new Set([
+    ".git",
+    ".handoff",
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    "coverage",
+]);
+/**
+ * Scan git log for directory-level author stats.
+ *
+ * Uses `git log --name-only` to get file paths per commit, groups by
+ * top-level directory, and counts commits per author per directory.
+ */
+export async function scanGitHistory(projectRoot, options = {}) {
+    const maxCommits = options.maxCommits ?? 200;
+    const depth = options.depth ?? 1;
+    if (!Number.isInteger(maxCommits) || maxCommits < 1 || maxCommits > 10_000)
+        throw new Error("Max commits must be an integer from 1 to 10000");
+    if (!Number.isInteger(depth) || depth < 1 || depth > 20)
+        throw new Error("Directory depth must be an integer from 1 to 20");
+    let stdout;
+    try {
+        const result = await execFileAsync("git", [
+            "log",
+            `--max-count=${maxCommits}`,
+            "--name-only",
+            "--format=COMMIT:%aN",
+            "--no-merges",
+        ], { cwd: projectRoot, maxBuffer: 5 * 1024 * 1024 });
+        stdout = result.stdout;
+    }
+    catch {
+        return []; // Not a git repo or no commits
+    }
+    // Parse: each commit starts with "COMMIT:<author>", followed by file paths
+    const authorDirCommits = new Map();
+    const blocks = stdout.split("COMMIT:").filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split("\n").filter(Boolean);
+        if (lines.length < 1)
+            continue;
+        const author = lines[0].trim();
+        if (!author)
+            continue;
+        if (options.authors && !options.authors.includes(author))
+            continue;
+        const dirs = new Set();
+        for (let i = 1; i < lines.length; i++) {
+            const filePath = lines[i].trim();
+            if (!filePath)
+                continue;
+            const dir = extractDirectory(filePath, depth);
+            if (dir && !SKIP_DIRS.has(dir.split("/")[0])) {
+                dirs.add(dir);
+            }
+        }
+        const stats = authorDirCommits.get(author) ?? {
+            dirs: new Map(),
+            total: 0,
+        };
+        stats.total++;
+        for (const dir of dirs) {
+            stats.dirs.set(dir, (stats.dirs.get(dir) ?? 0) + 1);
+        }
+        authorDirCommits.set(author, stats);
+    }
+    return [...authorDirCommits.entries()].map(([author, stats]) => ({
+        author,
+        directories: stats.dirs,
+        totalCommits: stats.total,
+    }));
+}
+function extractDirectory(filePath, depth) {
+    const parts = filePath.split("/");
+    if (parts.length <= depth)
+        return null; // File at root level
+    return parts.slice(0, depth).join("/");
+}
+// ── Suggestion generation ──────────────────────────────────────────────
+export async function suggestOwnership(projectRoot, agents, options = {}) {
+    const threshold = options.threshold ?? 60;
+    if (!Number.isInteger(threshold) || threshold < 1 || threshold > 100)
+        throw new Error("Ownership threshold must be an integer from 1 to 100");
+    const mappings = parseAgentAuthorMappings(agents);
+    const agentForAuthor = new Map(mappings.map((mapping) => [mapping.author, mapping.agent]));
+    const stats = await scanGitHistory(projectRoot, {
+        maxCommits: options.maxCommits,
+        depth: options.depth,
+    });
+    const existingOwnership = await getOwnership(projectRoot);
+    // Collect all directories across all authors
+    const allDirs = new Set();
+    for (const s of stats) {
+        for (const dir of s.directories.keys()) {
+            allDirs.add(dir);
+        }
+    }
+    const suggestions = [];
+    for (const dir of allDirs) {
+        // Find commit counts per author for this directory
+        const authorCounts = [];
+        let totalDirCommits = 0;
+        for (const s of stats) {
+            const count = s.directories.get(dir) ?? 0;
+            if (count > 0) {
+                authorCounts.push({ author: s.author, count });
+                totalDirCommits += count;
+            }
+        }
+        if (totalDirCommits === 0)
+            continue;
+        // Find dominant author
+        authorCounts.sort((a, b) => b.count - a.count);
+        const dominant = authorCounts[0];
+        const percentage = Math.round((dominant.count / totalDirCommits) * 100);
+        const suggestedOwner = agentForAuthor.get(dominant.author);
+        if (percentage < threshold || !suggestedOwner)
+            continue;
+        const alreadyClaimed = [...existingOwnership.values()].some((claim) => claim.agent === suggestedOwner &&
+            claim.paths.some((p) => p === dir || dir.startsWith(p + "/")));
+        suggestions.push({
+            directory: dir,
+            suggestedOwner,
+            commits: dominant.count,
+            percentage,
+            alreadyClaimed,
+        });
+    }
+    // Sort by confidence (percentage) descending
+    suggestions.sort((a, b) => b.percentage - a.percentage);
+    return { suggestions, authorStats: stats, ownershipApplied: false };
+}
+// ── Apply suggestions ──────────────────────────────────────────────────
+export async function applyGitOwnership(projectRoot, agents, options = {}) {
+    const result = await suggestOwnership(projectRoot, agents, options);
+    if (options.dryRun)
+        return result;
+    const unclaimed = result.suggestions.filter((s) => !s.alreadyClaimed);
+    if (unclaimed.length === 0)
+        return result;
+    // Group by agent
+    const agentPaths = new Map();
+    for (const s of unclaimed) {
+        const paths = agentPaths.get(s.suggestedOwner) ?? [];
+        paths.push(s.directory);
+        agentPaths.set(s.suggestedOwner, paths);
+    }
+    for (const [agent, paths] of agentPaths) {
+        const claim = {
+            agent,
+            paths,
+            mode: "exclusive",
+            reason: "Auto-assigned from git history",
+        };
+        await claimOwnership(projectRoot, claim);
+    }
+    result.ownershipApplied = true;
+    return result;
+}
+// ── Terminal formatting ────────────────────────────────────────────────
+export function formatGitOwnership(result, dryRun) {
+    const lines = [];
+    if (result.suggestions.length === 0) {
+        lines.push("No ownership suggestions from git history.");
+        if (result.authorStats.length === 0) {
+            lines.push("\x1b[90mNo matching commits found. Are the agent names the same as git author names?\x1b[0m");
+        }
+        return lines.join("\n");
+    }
+    lines.push(`\x1b[1mGit-based ownership suggestions\x1b[0m (${result.suggestions.length})`);
+    lines.push("");
+    for (const s of result.suggestions) {
+        const status = s.alreadyClaimed
+            ? "\x1b[32m✓ claimed\x1b[0m"
+            : "\x1b[33m⚠ unclaimed\x1b[0m";
+        lines.push(`  ${s.directory}/  →  \x1b[36m${s.suggestedOwner}\x1b[0m  ${s.percentage}% (${s.commits} commits)  ${status}`);
+    }
+    lines.push("");
+    const unclaimed = result.suggestions.filter((s) => !s.alreadyClaimed);
+    if (unclaimed.length === 0) {
+        lines.push("\x1b[32mAll suggested directories already claimed.\x1b[0m");
+    }
+    else if (dryRun) {
+        lines.push(`\x1b[90m${unclaimed.length} unclaimed. Add --yes to apply.\x1b[0m`);
+    }
+    else if (result.ownershipApplied) {
+        lines.push(`\x1b[32m✓ Applied ${unclaimed.length} ownership claim(s).\x1b[0m`);
+    }
+    return lines.join("\n");
+}

package/dist/src/core/coordination/lock.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { open, readFile, rm, stat } from "node:fs/promises";
+import { open, readFile, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 const LOCK_FILE = "coordination.lock";
 const DEFAULT_TIMEOUT_MS = 10_000;
@@ -84,13 +84,43 @@ export async function withCoordinationLock(coordinationDir, operation, timeoutMs
             finally {
                 await handle.close();
             }
-            break;
+            // Verify we still own the lock — another recovery could have renamed
+            // our lock file away between open and write in a tight race.
+            const verification = await readFile(path, "utf8").catch(() => null);
+            if (verification !== null) {
+                try {
+                    const parsed = JSON.parse(verification);
+                    if (parsed.token === token)
+                        break;
+                }
+                catch {
+                    // Corrupted lock file — retry
+                }
+            }
+            // Someone else owns the lock now — retry
+            continue;
         }
         catch (error) {
-            if (errorCode(error) !== "EEXIST")
+            const code = errorCode(error);
+            // EEXIST: lock file exists. EPERM: Windows holds the handle during
+            // another process's rename recovery — treat as transient contention.
+            if (code !== "EEXIST" && code !== "EPERM")
                 throw error;
             if (await lockCanBeRecovered(path)) {
-                await rm(path, { force: true });
+                // Atomic recovery: rename claims the stale file; only one recoverer
+                // can win the rename since the source is a single path.
+                const recoveryPath = `${path}.${token}.recovery`;
+                try {
+                    await rename(path, recoveryPath);
+                    await rm(recoveryPath, { force: true });
+                }
+                catch (error) {
+                    const rc = errorCode(error);
+                    // ENOENT: another recoverer already renamed it away.
+                    // EPERM: Windows file-handle contention during rename.
+                    if (rc !== "ENOENT" && rc !== "EPERM")
+                        throw error;
+                }
                 continue;
             }
             if (Date.now() >= deadline) {