@yu_robotics/remote-cli 1.6.133 → 1.6.137

package/dist/delegation/DelegatedWorkspaceManager.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DelegatedWorkspaceManager = void 0;
 const crypto_1 = require("crypto");
+const fs_1 = require("fs");
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -18,6 +19,7 @@ function inside(root, child) {
 /** Worktrees isolate checkout files, not process permissions. Artifacts are never expired with task diagnostics. */
 class DelegatedWorkspaceManager {
     directory;
+    static operations = new Map();
     constructor(directory = path_1.default.join(os_1.default.homedir(), '.remote-cli', 'delegation-workspaces')) {
         this.directory = directory;
     }
@@ -68,6 +70,8 @@ class DelegatedWorkspaceManager {
                 const record = await this.read('lanes', id);
                 if (!record || record.blocked || record.pendingTaskId)
                     blocked.add(id);
+                else
+                    this.assertLifecycle(record);
             }
             catch {
                 blocked.add(id);
@@ -76,6 +80,9 @@ class DelegatedWorkspaceManager {
         return blocked;
     }
     async prepare(lane, source, input, taskId) {
+        return this.withLane(lane.id, () => this.prepareLocked(lane, source, input, taskId));
+    }
+    async prepareLocked(lane, source, input, taskId) {
         this.assertId(taskId);
         await this.initialize();
         await this.validateSource(source);
@@ -85,14 +92,22 @@ class DelegatedWorkspaceManager {
         }
         const directory = this.worktreeDirectory(source, lane.id);
         const taskRef = `refs/remote-cli/tasks/${taskId}`;
-        const previous = await this.read('lanes', lane.id);
+        let previous = await this.read('lanes', lane.id);
         if (previous) {
-            await this.validateWorkspace(previous);
-            if (previous.threadId !== lane.threadId || previous.workspaceGeneration !== lane.workspaceGeneration
+            await this.validateWorkspaceRecord(previous);
+            if (previous.laneId !== lane.id || previous.threadId !== lane.threadId || previous.workspaceGeneration !== lane.workspaceGeneration
                 || previous.source.cwd !== source.cwd || previous.blocked || previous.pendingTaskId) {
                 throw new Error('Worker workspace has unresolved artifacts or a changed identity');
             }
+            previous = await this.resolveReclamation(previous);
+        }
+        if (previous && previous.checkoutState !== 'reclaimed') {
+            await this.validateWorkspace(previous);
             await this.assertClean(previous.directory);
+            const indexEntries = (await (0, GitCheckpoint_1.runGit)(previous.directory, ['ls-files', '-v', '-z'])).toString('utf8').split('\0').filter(Boolean);
+            if (indexEntries.some(entry => !entry.startsWith('H '))) {
+                throw new Error('Worker checkout has hidden index state; manual recovery is required');
+            }
             // Never reset unknown files, including ignored files that checkout could overwrite.
             await (0, GitCheckpoint_1.runGit)(directory, ['checkout', '--detach', '--no-overwrite-ignore', input.commit]);
         }
@@ -108,18 +123,30 @@ class DelegatedWorkspaceManager {
             await this.safeDirectory(path_1.default.dirname(directory));
             // Anchor the baseline before creating any checkout, even if setup later fails.
             await (0, GitCheckpoint_1.runGit)(source.root, ['update-ref', this.inputRef(taskId), input.commit]);
-            await (0, GitCheckpoint_1.runGit)(source.root, ['worktree', 'add', '--detach', directory, input.commit]);
+            await this.withRepository(source, async () => {
+                if (await this.registration(source, directory))
+                    throw new Error('Worker path is still registered; manual recovery is required');
+                await (0, GitCheckpoint_1.runGit)(source.root, ['worktree', 'add', '--detach', directory, input.commit]);
+            });
         }
         await (0, GitCheckpoint_1.runGit)(source.root, ['update-ref', this.inputRef(taskId), input.commit]);
         await (0, GitCheckpoint_1.runGit)(source.root, ['update-ref', taskRef, input.commit]);
         const workspace = { laneId: lane.id, threadId: lane.threadId,
             workspaceGeneration: lane.workspaceGeneration, source, directory,
-            cwd: path_1.default.join(directory, source.relativeCwd), taskId, taskRef, input };
+            cwd: path_1.default.join(directory, source.relativeCwd), taskId, taskRef, input, checkoutState: 'present' };
         await this.write('lanes', lane.id, workspace);
         await this.validateWorkspace(workspace);
         return workspace;
     }
     async collect(workspace, successful) {
+        return this.withLane(workspace.laneId, () => this.collectLocked(workspace, successful));
+    }
+    async collectLocked(workspace, successful) {
+        const record = await this.read('lanes', workspace.laneId);
+        if (!record || record.taskId !== workspace.taskId || record.blocked
+            || record.checkoutState && record.checkoutState !== 'present') {
+            throw new Error('Worker workspace task changed before collection');
+        }
         await this.validateWorkspace(workspace);
         const checkpoint = await (0, GitCheckpoint_1.captureCheckpoint)(workspace.directory);
         const output = await (0, GitCheckpoint_1.createCheckpointCommit)(workspace.directory, checkpoint.tree, workspace.input.commit, `Remote CLI worker artifact ${workspace.taskId}`);
@@ -148,20 +175,56 @@ class DelegatedWorkspaceManager {
     async integrate(owner, taskId, action, expectedRevision) {
         this.assertId(taskId);
         const artifact = await this.read('artifacts', taskId);
+        if (!artifact)
+            throw new Error('Worker artifact not found');
+        const result = await this.withLane(artifact.laneId, () => this.integrateLocked(owner, taskId, action, expectedRevision));
+        if (action === 'apply' || action === 'inspect' && result.deliveredAtHead) {
+            await this.reclaim(taskId);
+        }
+        return result;
+    }
+    async integrateLocked(owner, taskId, action, expectedRevision) {
+        this.assertId(taskId);
+        let artifact = await this.read('artifacts', taskId);
         if (!artifact)
             throw new Error('Worker artifact not found');
         await this.validateArtifact(artifact, owner);
         owner.checkActive?.();
-        const view = await this.view(artifact);
-        const current = await (0, GitCheckpoint_1.captureCheckpoint)(artifact.source.root);
-        if (action === 'inspect')
-            return { ...view, revision: current.revision,
-                deliveryDirectory: artifact.source.cwd, integration: 'Explicit apply or retain is required for pending changes.' };
-        if (action !== 'apply' && action !== 'retain')
+        if (action !== 'inspect' && action !== 'apply' && action !== 'retain') {
             throw new Error('Artifact action must be inspect, apply, or retain');
-        if (typeof expectedRevision !== 'string' || expectedRevision !== current.revision) {
+        }
+        const current = await (0, GitCheckpoint_1.captureCheckpoint)(artifact.source.root);
+        if (action !== 'inspect' && (typeof expectedRevision !== 'string' || expectedRevision !== current.revision)) {
             throw new Error('Delivery workspace changed; inspect the artifact again before integrating');
         }
+        if (action !== 'retain') {
+            try {
+                artifact = await this.recognizeHistoricalDelivery(artifact, owner);
+            }
+            catch {
+                console.warn('[Delegation] Historical delivery could not be verified; the artifact was preserved');
+                // The receipt may already be durable even if clearing its marker failed.
+                // Never apply stale pending state over a subsequently reverted delivery.
+                try {
+                    const persisted = await this.read('artifacts', taskId);
+                    if (!persisted)
+                        throw new Error('Worker delivery receipt is missing');
+                    await this.validateArtifact(persisted, owner);
+                    artifact = persisted;
+                }
+                catch {
+                    if (action === 'apply')
+                        throw new Error('Worker delivery state is unavailable; inspect again before applying');
+                }
+            }
+        }
+        owner.checkActive?.();
+        const view = await this.view(artifact);
+        if (action === 'inspect')
+            return { ...view, revision: current.revision,
+                deliveryDirectory: artifact.source.cwd, integration: artifact.deliveredAtHead
+                    ? 'Historically delivered. Later delivery-branch changes do not reopen this artifact.'
+                    : 'Explicit apply or retain is required for pending changes.' };
         if (artifact.disposition !== 'pending')
             return view;
         if (action === 'retain') {
@@ -177,15 +240,357 @@ class DelegatedWorkspaceManager {
         await this.assertSelectedScope(artifact);
         return this.applyArtifact(artifact, current, owner);
     }
+    /** Reconcile only the caller's exited, ready lanes. Admission never removes checkouts. */
+    async reconcileHistoricalDelivery(owner, lanes, reclaim = false) {
+        const delivered = [];
+        for (const lane of lanes) {
+            if (lane.state !== 'ready' || lane.threadId !== owner.threadId || lane.workingDirectory !== owner.cwd
+                || lane.workspaceGeneration !== owner.workspaceGeneration)
+                continue;
+            owner.checkActive?.();
+            try {
+                const view = await this.withLane(lane.id, async () => {
+                    const workspace = await this.read('lanes', lane.id);
+                    if (!workspace || workspace.laneId !== lane.id || workspace.threadId !== owner.threadId
+                        || workspace.source.cwd !== owner.cwd || workspace.workspaceGeneration !== owner.workspaceGeneration
+                        || workspace.blocked || workspace.pendingTaskId !== workspace.taskId)
+                        return undefined;
+                    const artifact = await this.read('artifacts', workspace.taskId);
+                    if (!artifact || artifact.successful !== true || artifact.disposition === 'retained' || artifact.recovery)
+                        return undefined;
+                    const confirmed = await this.recognizeHistoricalDelivery(artifact, owner);
+                    return confirmed.disposition === 'applied' ? this.view(confirmed) : undefined;
+                });
+                if (view) {
+                    delivered.push(view);
+                    if (reclaim) {
+                        owner.checkActive?.();
+                        await this.reclaim(view.taskId);
+                    }
+                }
+            }
+            catch {
+                console.warn('[Delegation] Historical delivery could not be verified; the worker lane was preserved');
+            }
+        }
+        return delivered;
+    }
+    async recognizeHistoricalDelivery(artifact, owner) {
+        if (artifact.successful !== true || artifact.disposition === 'retained' || artifact.recovery)
+            return artifact;
+        const workspace = await this.read('lanes', artifact.laneId);
+        if (!workspace || workspace.taskId !== artifact.taskId || workspace.laneId !== artifact.laneId
+            || workspace.threadId !== owner.threadId || workspace.source.cwd !== owner.cwd
+            || workspace.workspaceGeneration !== owner.workspaceGeneration || workspace.blocked)
+            return artifact;
+        if (artifact.disposition === 'applied' && !workspace.pendingTaskId)
+            return artifact;
+        if (workspace.pendingTaskId !== artifact.taskId || workspace.checkoutState && workspace.checkoutState !== 'present')
+            return artifact;
+        await this.validateWorkspaceRecord(workspace);
+        await this.validateArtifact(artifact, owner);
+        if (workspace.input.commit !== artifact.input.commit || workspace.input.tree !== artifact.input.tree
+            || !GitCheckpoint_1.GIT_OID.test(artifact.originalHead)
+            || await (0, GitCheckpoint_1.gitText)(workspace.source.root, ['rev-parse', workspace.taskRef]) !== artifact.output
+            || await (0, GitCheckpoint_1.gitText)(workspace.source.root, ['rev-parse', `refs/remote-cli/worker-history/${artifact.taskId}`]) !== artifact.originalHead) {
+            throw new Error('Worker delivery references changed');
+        }
+        owner.checkActive?.();
+        if (artifact.disposition === 'applied') {
+            // A crash after the durable receipt must not strand its pending-lane marker.
+            await this.resolveArtifact(artifact, 'applied', artifact.integratedTree);
+            return artifact;
+        }
+        const head = await (0, GitCheckpoint_1.gitText)(artifact.source.root, ['rev-parse', '--verify', 'HEAD']);
+        if (!GitCheckpoint_1.GIT_OID.test(head))
+            throw new Error('Delivery HEAD is unavailable');
+        try {
+            await (0, GitCheckpoint_1.runGit)(artifact.source.root, ['--no-replace-objects', 'merge-base', '--is-ancestor', artifact.output, head]);
+        }
+        catch (error) {
+            if (error instanceof GitCheckpoint_1.GitCommandError && error.code === 1)
+                return artifact;
+            throw error;
+        }
+        if (await (0, GitCheckpoint_1.gitText)(artifact.source.root, ['rev-parse', '--verify', 'HEAD']) !== head) {
+            throw new Error('Delivery HEAD changed during historical verification');
+        }
+        owner.checkActive?.();
+        const confirmed = { ...artifact, disposition: 'applied', deliveredAtHead: head };
+        // Record historical handoff, not current-byte inclusion or an integration tree.
+        await this.resolveArtifact(confirmed, 'applied');
+        return confirmed;
+    }
     async describe(taskId) {
         const artifact = await this.read('artifacts', taskId);
         return artifact ? this.view(artifact) : undefined;
     }
+    /** Closeout needs a fresh, owned receipt, not a cached result or an absent record. */
+    async inspectCloseout(owner, taskId) {
+        const saved = await this.read('artifacts', taskId);
+        if (!saved)
+            throw new Error('Worker artifact is unavailable');
+        return this.withLane(saved.laneId, async () => {
+            const artifact = await this.read('artifacts', taskId);
+            if (!artifact || artifact.taskId !== taskId || artifact.laneId !== saved.laneId
+                || typeof artifact.successful !== 'boolean')
+                throw new Error('Invalid worker artifact receipt');
+            await this.validateArtifact(artifact, owner);
+            owner.checkActive?.();
+            const workspace = await this.read('lanes', artifact.laneId);
+            if (artifact.disposition !== 'retained' && workspace?.taskId === taskId && workspace.blocked) {
+                throw new Error('Worker artifact collection requires recovery');
+            }
+            // Failed workers may have a no-change receipt, but cannot claim an applied patch.
+            if (artifact.disposition === 'applied' && !artifact.successful && artifact.tree !== artifact.input.tree) {
+                throw new Error('Unsuccessful worker changes have no delivery receipt');
+            }
+            const view = await this.view(artifact);
+            owner.checkActive?.();
+            return view;
+        });
+    }
     /** Removing a conversation does not authorize deleting its files or pending artifacts. */
     async preserveLane(laneId) {
+        await this.withLane(laneId, async () => {
+            const workspace = await this.read('lanes', laneId);
+            if (workspace)
+                await this.write('lanes', laneId, { ...workspace, blocked: true });
+        });
+    }
+    /** Called only after worker exit or a durable delivery receipt; never races a cleanup deadline. */
+    async reclaim(taskId) {
+        try {
+            this.assertId(taskId);
+            const artifact = await this.read('artifacts', taskId);
+            if (!artifact)
+                return false;
+            return await this.withLane(artifact.laneId, () => this.reclaimLocked(taskId, artifact.laneId));
+        }
+        catch {
+            // Physical cleanup is optional. Do not turn a delivered result into a failed task.
+            console.warn('[Delegation] Worker checkout retained; automatic reclamation could not be verified');
+            return false;
+        }
+    }
+    async reclaimLocked(taskId, laneId) {
         const workspace = await this.read('lanes', laneId);
-        if (workspace)
-            await this.write('lanes', laneId, { ...workspace, blocked: true });
+        const artifact = await this.read('artifacts', taskId);
+        if (!workspace || workspace.taskId !== taskId || !artifact || workspace.blocked || workspace.pendingTaskId
+            || artifact.successful !== true || artifact.disposition !== 'applied' || artifact.recovery)
+            return false;
+        await this.validateReclamationArtifact(workspace, artifact);
+        if (workspace.checkoutState === 'reclaimed')
+            return false;
+        await this.verifyCheckout(workspace, artifact);
+        const intent = { ...workspace, checkoutState: 'reclaiming',
+            reclamation: { taskId, output: artifact.output, tree: artifact.tree } };
+        await this.write('lanes', laneId, intent);
+        // Full byte verification holds only the lane guard, not other lanes' metadata admission.
+        await this.verifyCheckout(intent, artifact);
+        return this.withRepository(workspace.source, async () => {
+            const latest = await this.read('lanes', laneId);
+            if (!latest || JSON.stringify(latest) !== JSON.stringify(intent))
+                throw new Error('Worker reclamation intent changed');
+            const registered = await this.registration(workspace.source, workspace.directory);
+            if (!registered || registered.locked || registered.head !== artifact.output) {
+                throw new Error('Worker registration changed before removal');
+            }
+            await (0, GitCheckpoint_1.runGit)(workspace.source.root, ['worktree', 'remove', workspace.directory]);
+            if (await this.pathExists(workspace.directory) || await this.registration(workspace.source, workspace.directory)) {
+                throw new Error('Worker checkout removal was not confirmed');
+            }
+            await this.write('lanes', laneId, { ...intent, checkoutState: 'reclaimed' });
+            return true;
+        });
+    }
+    async validateReclamationArtifact(workspace, artifact) {
+        await this.validateWorkspaceRecord(workspace);
+        await this.validateArtifact(artifact, { threadId: workspace.threadId, cwd: workspace.source.cwd,
+            workspaceGeneration: workspace.workspaceGeneration });
+        if (artifact.laneId !== workspace.laneId || artifact.taskId !== workspace.taskId
+            || artifact.input.commit !== workspace.input.commit || artifact.input.tree !== workspace.input.tree
+            || artifact.successful !== true || artifact.disposition !== 'applied' || artifact.recovery
+            || workspace.blocked || workspace.pendingTaskId
+            || !GitCheckpoint_1.GIT_OID.test(artifact.originalHead)
+            || await (0, GitCheckpoint_1.gitText)(workspace.source.root, ['rev-parse', workspace.taskRef]) !== artifact.output
+            || await (0, GitCheckpoint_1.gitText)(workspace.source.root, ['rev-parse', `refs/remote-cli/worker-history/${artifact.taskId}`]) !== artifact.originalHead) {
+            throw new Error('Worker checkout has no matching delivery receipt');
+        }
+        if (workspace.reclamation && (workspace.reclamation.taskId !== artifact.taskId
+            || workspace.reclamation.output !== artifact.output || workspace.reclamation.tree !== artifact.tree)) {
+            throw new Error('Worker reclamation receipt changed');
+        }
+    }
+    async resolveReclamation(workspace) {
+        if (!workspace.checkoutState || workspace.checkoutState === 'present')
+            return workspace;
+        // The caller holds the lane guard. This resolver does not mutate Git worktree metadata.
+        const artifact = await this.read('artifacts', workspace.taskId);
+        if (!artifact)
+            throw new Error('Worker reclamation artifact is missing');
+        await this.validateReclamationArtifact(workspace, artifact);
+        const exists = await this.pathExists(workspace.directory);
+        const registered = await this.registration(workspace.source, workspace.directory);
+        if (!exists && !registered) {
+            const reclaimed = { ...workspace, checkoutState: 'reclaimed' };
+            await this.write('lanes', workspace.laneId, reclaimed);
+            return reclaimed;
+        }
+        if (workspace.checkoutState === 'reclaiming' && exists && registered) {
+            // A fully intact checkout can cancel an interrupted intent. Partial/foreign paths cannot.
+            await this.verifyCheckout(workspace, artifact);
+            const present = { ...workspace, checkoutState: 'present', reclamation: undefined };
+            await this.write('lanes', workspace.laneId, present);
+            return present;
+        }
+        throw new Error('Reclaimed worker path is occupied or partially registered; manual recovery is required');
+    }
+    async verifyCheckout(workspace, artifact) {
+        await this.validateWorkspace(workspace);
+        const registered = await this.registration(workspace.source, workspace.directory);
+        if (!registered || registered.locked || registered.head !== artifact.output
+            || await (0, GitCheckpoint_1.gitText)(workspace.directory, ['branch', '--show-current'])
+            || await (0, GitCheckpoint_1.gitText)(workspace.directory, ['rev-parse', 'HEAD']) !== artifact.output
+            || (await (0, GitCheckpoint_1.runGit)(workspace.directory, ['ls-files', '-u', '-z'])).length) {
+            throw new Error('Worker checkout is locked, unresolved, or no longer at its saved output');
+        }
+        await this.assertClean(workspace.directory);
+        // Git status and a copied index can hide changed bytes behind assume-unchanged,
+        // skip-worktree, or stat-cache flags. Hash actual bytes without filters or index metadata.
+        const files = new Map();
+        const directories = new Set(['']);
+        const tree = await (0, GitCheckpoint_1.runGit)(workspace.source.root, ['ls-tree', '-r', '-z', '--full-tree', artifact.tree]);
+        if (!Buffer.from(tree.toString('utf8')).equals(tree))
+            throw new Error('Non-UTF-8 checkout paths require manual cleanup');
+        for (const entry of tree.toString('utf8').split('\0').filter(Boolean)) {
+            const match = /^(100644|100755|120000) blob ([a-f0-9]{40}|[a-f0-9]{64})\t(.+)$/s.exec(entry);
+            if (!match)
+                throw new Error('Unsupported checkout tree entry');
+            const [, mode, oid, name] = match;
+            if (!inside(workspace.directory, path_1.default.join(workspace.directory, name)) || name.split('/').includes('.git')
+                || files.has(name))
+                throw new Error('Invalid checkout tree path');
+            files.set(name, { mode, oid });
+            let parent = path_1.default.posix.dirname(name);
+            while (parent !== '.') {
+                directories.add(parent);
+                parent = path_1.default.posix.dirname(parent);
+            }
+            if (files.size > GitCheckpoint_1.CHECKPOINT_LIMITS.files)
+                throw new Error('Checkout verification file limit exceeded');
+        }
+        let bytes = 0;
+        let entries = 0;
+        const buffer = Buffer.alloc(64 * 1024);
+        const walk = async (relative) => {
+            const absolute = path_1.default.join(workspace.directory, relative);
+            if (await promises_1.default.realpath(absolute) !== absolute)
+                throw new Error('Checkout directory changed during verification');
+            for (const name of await promises_1.default.readdir(absolute)) {
+                if (++entries > GitCheckpoint_1.CHECKPOINT_LIMITS.files * 2)
+                    throw new Error('Checkout verification entry limit exceeded');
+                const child = relative ? `${relative}/${name}` : name;
+                const file = path_1.default.join(workspace.directory, child);
+                const stat = await promises_1.default.lstat(file);
+                if (child === '.git' && stat.isFile() && !stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory() && directories.has(child)) {
+                    await walk(child);
+                    continue;
+                }
+                const expected = files.get(child);
+                if (!expected || (expected.mode === '120000' ? !stat.isSymbolicLink() : !stat.isFile())) {
+                    throw new Error('Checkout contains unknown, ignored, or unsupported files');
+                }
+                if (process.platform !== 'win32' && expected.mode !== '120000'
+                    && Boolean(stat.mode & 0o111) !== (expected.mode === '100755'))
+                    throw new Error('Checkout file mode changed');
+                bytes += stat.size;
+                if (bytes > GitCheckpoint_1.CHECKPOINT_LIMITS.bytes)
+                    throw new Error('Checkout verification byte limit exceeded');
+                const hash = (0, crypto_1.createHash)(expected.oid.length === 64 ? 'sha256' : 'sha1');
+                hash.update(`blob ${stat.size}\0`);
+                if (stat.isSymbolicLink())
+                    hash.update(await promises_1.default.readlink(file, { encoding: 'buffer' }));
+                else {
+                    const handle = await promises_1.default.open(file, fs_1.constants.O_RDONLY | (fs_1.constants.O_NOFOLLOW ?? 0));
+                    try {
+                        const opened = await handle.stat();
+                        if (!opened.isFile() || opened.dev !== stat.dev || opened.ino !== stat.ino || opened.size !== stat.size) {
+                            throw new Error('Checkout file changed during verification');
+                        }
+                        let read = 0;
+                        while (true) {
+                            const chunk = await handle.read(buffer, 0, buffer.length, null);
+                            if (!chunk.bytesRead)
+                                break;
+                            read += chunk.bytesRead;
+                            if (read > stat.size)
+                                throw new Error('Checkout file grew during verification');
+                            hash.update(buffer.subarray(0, chunk.bytesRead));
+                        }
+                        const after = await handle.stat();
+                        if (read !== stat.size || after.mtimeMs !== stat.mtimeMs || after.ctimeMs !== stat.ctimeMs) {
+                            throw new Error('Checkout file changed during verification');
+                        }
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                }
+                if (hash.digest('hex') !== expected.oid)
+                    throw new Error('Checkout bytes differ from the saved output');
+                files.delete(child);
+            }
+        };
+        await walk('');
+        if (files.size)
+            throw new Error('Saved checkout files are missing');
+    }
+    async registration(source, directory) {
+        let selected = false;
+        let result;
+        // Git 2.34 has no worktree-list -z option. Decode its quoted paths rather than
+        // weakening ownership checks or raising the existing Git requirement.
+        const output = await (0, GitCheckpoint_1.runGit)(source.root, ['-c', 'core.quotePath=false', 'worktree', 'list', '--porcelain']);
+        if (!Buffer.from(output.toString('utf8')).equals(output))
+            throw new Error('Unsupported Git worktree path encoding');
+        for (const field of output.toString('utf8').split('\n')) {
+            if (field.startsWith('worktree ')) {
+                const encoded = field.slice(9);
+                let decoded;
+                try {
+                    decoded = encoded.startsWith('"') ? JSON.parse(encoded) : encoded;
+                }
+                catch {
+                    throw new Error('Unsupported Git worktree path encoding; manual recovery is required');
+                }
+                if (typeof decoded !== 'string')
+                    throw new Error('Invalid Git worktree path');
+                selected = decoded === directory;
+                if (selected)
+                    result = { locked: false };
+            }
+            else if (selected && result) {
+                if (field.startsWith('HEAD '))
+                    result.head = field.slice(5);
+                if (field === 'locked' || field.startsWith('locked '))
+                    result.locked = true;
+            }
+        }
+        return result;
+    }
+    async pathExists(directory) {
+        try {
+            await promises_1.default.lstat(directory);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
     }
     async applyArtifact(artifact, current, owner) {
         // Compatible with Git 2.34: merge in an owned scratch checkout, never in the user's worktree.
@@ -194,7 +599,7 @@ class DelegatedWorkspaceManager {
         let created = false;
         let preserve = false;
         try {
-            await (0, GitCheckpoint_1.runGit)(artifact.source.root, ['worktree', 'add', '--detach', integrationDirectory, wrapper]);
+            await this.withRepository(artifact.source, () => (0, GitCheckpoint_1.runGit)(artifact.source.root, ['worktree', 'add', '--detach', integrationDirectory, wrapper]));
             created = true;
             try {
                 await (0, GitCheckpoint_1.runGit)(integrationDirectory, ['-c', 'user.name=Remote CLI', '-c', 'user.email=remote-cli@example.com',
@@ -244,7 +649,7 @@ class DelegatedWorkspaceManager {
         finally {
             if (created && !preserve) {
                 // This directory contains only captured integration input and a reproducible merge result.
-                await (0, GitCheckpoint_1.runGit)(artifact.source.root, ['worktree', 'remove', '--force', integrationDirectory])
+                await this.withRepository(artifact.source, () => (0, GitCheckpoint_1.runGit)(artifact.source.root, ['worktree', 'remove', '--force', integrationDirectory]))
                     .catch(() => console.warn('[Delegation] Integration scratch worktree retained for manual cleanup'));
             }
             else if (!created) {
@@ -267,6 +672,7 @@ class DelegatedWorkspaceManager {
         return { taskId: artifact.taskId, disposition: artifact.disposition, successful: artifact.successful,
             baseCommit: artifact.input.commit, outputCommit: artifact.output,
             changedFiles: files.slice(0, 60), filesTruncated: files.length > 60,
+            ...(artifact.deliveredAtHead ? { deliveredAtHead: artifact.deliveredAtHead } : {}),
             ...(artifact.recovery ? { recovery: artifact.recovery } : {}) };
     }
     async assertSelectedScope(artifact) {
@@ -282,8 +688,10 @@ class DelegatedWorkspaceManager {
             || artifact.threadId !== owner.threadId || artifact.source.cwd !== owner.cwd
             || artifact.workspaceGeneration !== owner.workspaceGeneration || !GitCheckpoint_1.GIT_OID.test(artifact.output)
             || !GitCheckpoint_1.GIT_OID.test(artifact.tree) || !GitCheckpoint_1.GIT_OID.test(artifact.input.commit) || !GitCheckpoint_1.GIT_OID.test(artifact.input.tree)
-            || !['pending', 'applied', 'retained'].includes(artifact.disposition))
+            || !['pending', 'applied', 'retained'].includes(artifact.disposition)
+            || artifact.deliveredAtHead !== undefined && (!GitCheckpoint_1.GIT_OID.test(artifact.deliveredAtHead) || artifact.disposition !== 'applied')) {
             throw new Error('Invalid or foreign worker artifact');
+        }
         await this.validateSource(artifact.source);
         if (await (0, GitCheckpoint_1.gitText)(artifact.source.root, ['rev-parse', this.outputRef(artifact.taskId)]) !== artifact.output
             || await (0, GitCheckpoint_1.gitText)(artifact.source.root, ['rev-parse', this.inputRef(artifact.taskId)]) !== artifact.input.commit
@@ -299,21 +707,37 @@ class DelegatedWorkspaceManager {
             throw new Error('Source repository identity changed');
     }
     async validateWorkspace(workspace) {
+        await this.validateWorkspaceRecord(workspace);
+        if (workspace.checkoutState === 'reclaimed' || !await this.pathExists(workspace.directory)) {
+            throw new Error('Owned worker checkout is missing; an explicit reclamation receipt is required');
+        }
+        if (await promises_1.default.realpath(workspace.directory) !== workspace.directory
+            || await (0, GitCheckpoint_1.gitText)(workspace.directory, ['rev-parse', '--show-toplevel']) !== workspace.directory
+            || await promises_1.default.realpath(path_1.default.resolve(workspace.directory, await (0, GitCheckpoint_1.gitText)(workspace.directory, ['rev-parse', '--git-common-dir']))) !== workspace.source.commonDirectory) {
+            throw new Error('Owned worker worktree identity changed');
+        }
+        if (!inside(workspace.directory, await promises_1.default.realpath(workspace.cwd)))
+            throw new Error('Worker directory escapes its worktree');
+    }
+    assertLifecycle(workspace) {
+        const state = workspace.checkoutState ?? 'present';
+        if (!['present', 'reclaiming', 'reclaimed'].includes(state)
+            || (state === 'present' ? workspace.reclamation !== undefined : !workspace.reclamation)) {
+            throw new Error('Invalid worker checkout lifecycle');
+        }
+    }
+    async validateWorkspaceRecord(workspace) {
         this.assertId(workspace.laneId);
         this.assertId(workspace.taskId);
+        this.assertLifecycle(workspace);
         if (workspace.taskRef !== `refs/remote-cli/tasks/${workspace.taskId}` || !GitCheckpoint_1.GIT_OID.test(workspace.input.commit)) {
             throw new Error('Owned worker task reference is invalid');
         }
         await this.validateSource(workspace.source);
         if (workspace.directory !== this.worktreeDirectory(workspace.source, workspace.laneId)
-            || workspace.cwd !== path_1.default.join(workspace.directory, workspace.source.relativeCwd)
-            || await promises_1.default.realpath(workspace.directory) !== workspace.directory
-            || await (0, GitCheckpoint_1.gitText)(workspace.directory, ['rev-parse', '--show-toplevel']) !== workspace.directory
-            || await promises_1.default.realpath(path_1.default.resolve(workspace.directory, await (0, GitCheckpoint_1.gitText)(workspace.directory, ['rev-parse', '--git-common-dir']))) !== workspace.source.commonDirectory) {
+            || workspace.cwd !== path_1.default.join(workspace.directory, workspace.source.relativeCwd)) {
             throw new Error('Owned worker worktree identity changed');
         }
-        if (!inside(workspace.directory, await promises_1.default.realpath(workspace.cwd)))
-            throw new Error('Worker directory escapes its worktree');
     }
     async assertClean(directory) {
         if ((await (0, GitCheckpoint_1.runGit)(directory, ['status', '--porcelain=v1', '-z', '--untracked-files=all'])).length) {
@@ -329,6 +753,28 @@ class DelegatedWorkspaceManager {
     outputRef(taskId) { this.assertId(taskId); return `refs/remote-cli/artifacts/${taskId}`; }
     assertId(id) { if (!UUID.test(id))
         throw new Error('Invalid worker workspace ID'); }
+    withLane(laneId, operation) {
+        this.assertId(laneId);
+        return this.serialize(`lane:${path_1.default.resolve(this.directory)}:${laneId}`, operation);
+    }
+    withRepository(source, operation) {
+        return this.serialize(`repository:${source.commonDirectory}`, operation);
+    }
+    async serialize(key, operation) {
+        const previous = DelegatedWorkspaceManager.operations.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        DelegatedWorkspaceManager.operations.set(key, current);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (DelegatedWorkspaceManager.operations.get(key) === current)
+                DelegatedWorkspaceManager.operations.delete(key);
+        }
+    }
     async initialize() {
         await this.safeDirectory(this.directory);
         await Promise.all(['lanes', 'artifacts', 'trees'].map(name => this.safeDirectory(path_1.default.join(this.directory, name))));