@zq-silk/yui 0.14.0 → 0.14.2

package/dist/repository/taskWorkspacePreparer.js

@@ -1,4 +1,4 @@
-import { lstat, mkdir, readlink, readdir, rmdir, symlink, unlink } from "node:fs/promises";
+import { lstat, mkdir, readlink, readdir, rm, rmdir, symlink, unlink } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { retireTaskRoleSessionsForWorkspace } from "../executor/agentExecutor.js";
@@ -7,14 +7,15 @@ import { updateRole } from "../role/role.js";
 import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { attachReviewRoundWorkspace, recordReviewWorkspaceDisposition } from "../review/reviewRound.js";
 import { StorageConflictError } from "../storage/taskStore.js";
-import { activateTask, bindTaskWorkspaceIdentity } from "../task/task.js";
+import { activateTask, bindTaskProjectCommits, bindTaskWorkspaceIdentity, synchronizeTaskProjectCommits } from "../task/task.js";
+import { validateDraftTaskForActivation } from "../task/draftPlan.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createCandidateGitSnapshot, createDirectTaskMainSnapshot, workItemExecutionGroupById, recordWorkItemWorkspaceDisposition } from "../workItem/workItem.js";
 import { createManagedWorkspace, isTaskOwnedWorkspace, managedWorkspaceKey, managedWorktreeName, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { NodeGitWorkspace, worktreeIdentity } from "./gitWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
-import { generateTaskWorkspaceIdentity, taskMainBranch, taskWorkspaceRefSegment, taskWorkspaceRefSegmentFromIdentity, validateTaskWorkspaceIdentity } from "./taskWorkspaceIdentity.js";
+import { generateTaskWorkspaceIdentity, taskWorkspaceRefSegment, validateTaskWorkspaceIdentity } from "./taskWorkspaceIdentity.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { captureTaskBaseProvenance, recordTaskBaseProvenanceEvents } from "./taskBaseFreshness.js";
 const MAIN_WORKTREE = "main";
@@ -120,6 +121,7 @@ export class FileTaskWorkspacePreparer {
                         changed: false
                     };
                 }
+                validateDraftTaskForActivation(this.store, task);
                 const { release, current } = this.#acquireTaskProjectMaintenanceLocks(task);
                 try {
                     return await this.#prepareTaskWorkspaceLocked(current.id, true);
@@ -190,6 +192,8 @@ export class FileTaskWorkspacePreparer {
         if (!activate && task.status !== "active") {
             throw new Error(`Task is not open for workspace preparation: ${task.id}.`);
         }
+        if (activate)
+            validateDraftTaskForActivation(this.store, task);
         const existing = this.store.getTaskWorkspace(task.id);
         if (activate && (task.workspaceIdentity !== undefined
             || task.cwd !== undefined
@@ -226,6 +230,8 @@ export class FileTaskWorkspacePreparer {
                         || latest.projectBindings.length !== 0) {
                         throw new Error(`Task changed while preparing its Gitless workspace: ${task.id}.`);
                     }
+                    if (activate)
+                        validateDraftTaskForActivation(tx, latest);
                     const current = tx.getTaskWorkspace(task.id);
                     // `createManagedWorkspace` stamps a fresh updatedAt on every call.
                     // Gitless preparation is idempotent, so compare only stable identity
@@ -285,13 +291,12 @@ export class FileTaskWorkspacePreparer {
         const taskSegment = taskWorkspaceRefSegment(workspaceIdentity === undefined ? task : { ...task, workspaceIdentity });
         const root = this.#taskWorkspaceRoot(task.id);
         const prepared = [];
-        const defaultProjects = remoteDefaultProjects(this.store, task.id);
+        const createdClonePaths = new Set();
         const baselines = new Map();
         try {
-            // Resolve every first-use baseline before creating any managed worktree.
-            // A later Project failure therefore cannot leave an earlier Project's
-            // workspace behind, and the Task can only be pinned after all evidence
-            // has been gathered successfully.
+            // Resolve every remote baseline before creating any Task clone. A later
+            // Project failure therefore cannot leave an earlier Project adopted,
+            // and activation remains one all-or-nothing boundary.
             for (const binding of task.projectBindings) {
                 const project = requireProject(this.store, binding.projectId);
                 const previous = existing?.entries.find(({ projectId }) => projectId === project.id);
@@ -302,37 +307,20 @@ export class FileTaskWorkspacePreparer {
                     });
                     continue;
                 }
-                const useRemoteDefault = defaultProjects.has(project.id)
-                    && project.remoteUrl !== undefined
-                    && !looksLikeCommit(binding.baseRef);
-                if (useRemoteDefault) {
-                    const resolver = this.git.resolveRemoteBaseline;
-                    if (typeof resolver !== "function") {
-                        throw new Error(`Git workspace cannot resolve the remote baseline for Project: ${project.id}.`);
-                    }
-                    const remote = await resolver.call(this.git, {
-                        repositoryPath: project.path,
-                        remoteUrl: project.remoteUrl,
-                        // The binding captured the configured development ref at Task
-                        // creation; use that snapshot even if the Project catalog was
-                        // edited before this first workspace preparation.
-                        developmentRef: binding.baseRef
-                    });
-                    baselines.set(project.id, {
-                        baseRef: remote.commit,
-                        recordedBaseRef: remote.commit,
-                        expectedCommit: remote.commit,
-                        pinTask: true,
-                        remoteBaseline: remote
-                    });
-                    continue;
+                if (project.remoteUrl === undefined) {
+                    throw new Error(`Task activation requires a configured remoteUrl for Project: ${project.id}.`);
                 }
-                // Validate local and explicit refs in the same preflight phase.  This
-                // preserves the fail-closed boundary before any worktree is created.
-                await this.git.inspect(project.path, binding.baseRef);
+                const remote = await this.git.resolveRemoteHead({
+                    remoteUrl: project.remoteUrl,
+                    // The binding captures the configured development branch at Draft
+                    // creation. Project checkout state is intentionally irrelevant.
+                    branch: binding.baseRef
+                });
                 baselines.set(project.id, {
-                    baseRef: binding.baseRef,
-                    recordedBaseRef: binding.baseRef
+                    baseRef: remote.commit,
+                    recordedBaseRef: binding.baseRef,
+                    expectedCommit: remote.commit,
+                    remoteBaseline: remote
                 });
             }
             for (const binding of task.projectBindings) {
@@ -342,15 +330,25 @@ export class FileTaskWorkspacePreparer {
                 if (baseline === undefined) {
                     throw new Error(`Task Project baseline was not resolved: ${project.id}.`);
                 }
-                const physical = await this.git.ensureWorktree({
-                    repositoryPath: project.path,
-                    container: this.#projectContainer(project.name),
-                    taskSegment,
-                    roleName: MAIN_WORKTREE,
-                    baseRef: previous?.baseCommit ?? baseline.baseRef
-                });
+                const identity = worktreeIdentity(taskSegment, MAIN_WORKTREE);
+                const destination = join(this.#projectContainer(project.name), identity.directory);
+                const physical = previous === undefined
+                    ? await this.git.clone({
+                        remoteUrl: project.remoteUrl,
+                        destination,
+                        branch: baseline.remoteBaseline.branch,
+                        localBranch: identity.branch
+                    })
+                    : await this.git.inspect(previous.path, "HEAD");
+                if (previous === undefined)
+                    createdClonePaths.add(physical.root);
+                const physicalBranch = await this.git.headRef(physical.root);
+                if (physical.root !== (previous?.path ?? destination)
+                    || physicalBranch !== (previous?.branch ?? identity.branch)) {
+                    throw new Error(`Task main clone identity changed: ${task.id}/${project.id}.`);
+                }
                 if (previous !== undefined
-                    && !await this.git.isAncestor(physical.path, previous.baseCommit, physical.baseCommit)) {
+                    && !await this.git.isAncestor(previous.path, previous.baseCommit, physical.baseCommit)) {
                     throw new Error(formatWorkspacePreflightError({
                         kind: "physical-drift",
                         reason: `Task main physical HEAD left its recorded lineage: ${task.id}/${project.id}.`,
@@ -363,7 +361,7 @@ export class FileTaskWorkspacePreparer {
                 }
                 if (baseline.expectedCommit !== undefined
                     && physical.baseCommit !== baseline.expectedCommit) {
-                    throw new Error(`Task Project workspace did not start at the fetched remote baseline: ${project.id}.`);
+                    throw new Error(`Task Project clone did not start at the fetched remote baseline: ${project.id}.`);
                 }
                 const provenance = await captureTaskBaseProvenance({
                     git: this.git,
@@ -379,11 +377,12 @@ export class FileTaskWorkspacePreparer {
                         projectId: project.id,
                         directory: binding.directory,
                         access: "write",
-                        path: physical.path,
-                        branch: physical.branch,
+                        path: physical.root,
+                        branch: previous?.branch ?? identity.branch,
                         baseRef: previous?.baseRef ?? baseline.recordedBaseRef,
                         baseCommit: previous?.baseCommit ?? physical.baseCommit
                     },
+                    currentCommit: physical.baseCommit,
                     provenance
                 });
             }
@@ -402,6 +401,8 @@ export class FileTaskWorkspacePreparer {
                 if (!isDeepStrictEqual(latest.projectBindings, task.projectBindings)) {
                     throw new Error(`Task Projects changed while preparing its workspace: ${task.id}.`);
                 }
+                if (activate)
+                    validateDraftTaskForActivation(tx, latest);
                 // Revalidate the Project catalog path after acquiring the fence: a
                 // concurrent migration must not leave a persisted worktree whose Git
                 // common dir is the old external checkout. A changed path rides the
@@ -432,16 +433,20 @@ export class FileTaskWorkspacePreparer {
                     : existing === null || !sameManagedWorkspace(current, existing)) {
                     throw new StorageConflictError(`Task workspace changed while preparing its workspace: ${task.id}.`);
                 }
-                const pinnedBindings = latest.projectBindings.map((binding) => {
-                    const baseline = baselines.get(binding.projectId);
-                    return baseline?.pinTask === true
-                        ? { ...binding, baseRef: baseline.baseRef }
-                        : binding;
-                });
                 const timestamp = this.now();
-                let persistedTask = isDeepStrictEqual(pinnedBindings, latest.projectBindings)
-                    ? latest
-                    : { ...latest, projectBindings: pinnedBindings, updatedAt: timestamp.toISOString() };
+                let persistedTask = latest;
+                if (activate) {
+                    persistedTask = bindTaskProjectCommits(persistedTask, prepared.map(({ entry }) => ({
+                        projectId: entry.projectId,
+                        commit: entry.baseCommit
+                    })), timestamp);
+                }
+                else {
+                    persistedTask = synchronizeTaskProjectCommits(persistedTask, prepared.map(({ entry, currentCommit }) => ({
+                        projectId: entry.projectId,
+                        commit: currentCommit
+                    })), timestamp);
+                }
                 if (workspaceIdentity !== undefined) {
                     // The identity is persisted only now that every managed ref was
                     // created successfully. A concurrent prepare that bound the same
@@ -457,8 +462,11 @@ export class FileTaskWorkspacePreparer {
                     tx.saveTask(persistedTask);
                 }
                 tx.saveManagedWorkspace(preserveWorkspaceCreatedAt(workspace, current));
-                if (current === null) {
-                    recordTaskBaseProvenanceEvents(tx, task.id, prepared.map(({ provenance }) => provenance), timestamp);
+                const adoptedProvenance = prepared
+                    .filter(({ entry }) => (current?.entries.every(({ projectId }) => projectId !== entry.projectId) ?? true))
+                    .map(({ provenance }) => provenance);
+                if (adoptedProvenance.length > 0) {
+                    recordTaskBaseProvenanceEvents(tx, task.id, adoptedProvenance, timestamp);
                 }
                 for (const role of tx.listRoles(task.id)) {
                     // The Role field is only a cwd/snapshot hint. Preserve it while a
@@ -517,6 +525,15 @@ export class FileTaskWorkspacePreparer {
             // branches too, so a retry mints a clean identity without half-created
             // refs behind. Adopted (already catalogued) worktrees are never touched.
             await this.#discardUnadoptedEntries(task, taskSegment, prepared, MAIN_WORKTREE, true);
+            const recorded = new Set(prepared.map(({ entry }) => entry.path));
+            for (const path of createdClonePaths) {
+                if (recorded.has(path))
+                    continue;
+                const removal = await this.git.removeStrandedWorktree(path);
+                if (removal === "dirty") {
+                    throw new Error(`Unadopted Task clone is dirty and was retained at ${path}; inspect it and retry.`);
+                }
+            }
             if (activate)
                 await removeWorkspaceView(root);
             throw error;
@@ -558,25 +575,11 @@ export class FileTaskWorkspacePreparer {
      */
     async #mintTaskWorkspaceIdentity(task) {
         const home = this.store.getHomeIdentity();
-        for (let attempt = 0; attempt < 16; attempt += 1) {
-            const identity = generateTaskWorkspaceIdentity({
-                home,
-                taskId: task.id,
-                now: this.now()
-            });
-            const mainBranch = taskMainBranch(taskWorkspaceRefSegmentFromIdentity(identity));
-            let conflict = false;
-            for (const binding of task.projectBindings) {
-                const project = requireProject(this.store, binding.projectId);
-                if (await this.git.refExists(project.path, mainBranch)) {
-                    conflict = true;
-                    break;
-                }
-            }
-            if (!conflict)
-                return identity;
-        }
-        throw new Error(`Could not mint a unique Task workspace identity for ${task.id}.`);
+        return generateTaskWorkspaceIdentity({
+            home,
+            taskId: task.id,
+            now: this.now()
+        });
     }
     async snapshotCandidateWorkspace(workspace) {
         if (workspace.owner.type === "review-round") {
@@ -635,34 +638,52 @@ export class FileTaskWorkspacePreparer {
         }
         return { schemaVersion: 1, projects };
     }
+    /** Freeze one clean committed source head set before any replicated Lane is minted. */
+    async snapshotExecutionLaneInputHeads(workspace, projectIds) {
+        if (workspace.owner.type !== "task" && workspace.owner.type !== "work-item") {
+            throw new Error("Execution Lane input must come from Task main or a WorkItem workspace.");
+        }
+        const stored = this.store.getManagedWorkspace(workspace.owner);
+        if (stored === null || !isDeepStrictEqual(stored, workspace)) {
+            throw new Error("Execution Lane input workspace is not the durable owner.");
+        }
+        return this.#snapshotWorkspaceHeads(workspace, projectIds, "Execution Lane input");
+    }
     async snapshotDirectTaskMain(workspace, projectIds) {
         if (workspace.owner.type !== "task") {
             throw new Error("Only Task main can become a direct Candidate source.");
         }
+        const projects = await this.#snapshotWorkspaceHeads(workspace, projectIds, "Direct Candidate");
+        return createDirectTaskMainSnapshot(workspace, projectIds, projects);
+    }
+    async #snapshotWorkspaceHeads(workspace, projectIds, boundary) {
         const selected = new Set(projectIds);
+        if (selected.size !== projectIds.length) {
+            throw new Error(`${boundary} Project scope is duplicated.`);
+        }
         const entries = workspace.entries.filter(({ projectId }) => selected.has(projectId));
         if (entries.length !== selected.size) {
-            throw new Error("Direct Candidate Project scope does not match Task main.");
+            throw new Error(`${boundary} Project scope does not match its managed workspace.`);
         }
         const projects = [];
         for (const entry of entries) {
             if (entry.access !== "write") {
-                throw new Error(`Direct Candidate Project is not writable: ${entry.projectId}.`);
+                throw new Error(`${boundary} Project is not writable: ${entry.projectId}.`);
             }
             if (!await this.git.isClean(entry.path)) {
-                throw new Error(`Direct Candidate Task main must be clean and committed: ${entry.projectId}.`);
+                throw new Error(`${boundary} workspace must be clean and committed: ${entry.projectId}.`);
             }
             const branch = await this.git.headRef(entry.path);
             if (branch !== entry.branch) {
-                throw new Error(`Direct Candidate Task main left its managed branch: ${entry.projectId}/${branch}.`);
+                throw new Error(`${boundary} workspace left its managed branch: ${entry.projectId}/${branch}.`);
             }
             const headCommit = (await this.git.inspect(entry.path, "HEAD")).baseCommit;
             if (!await this.git.isAncestor(entry.path, entry.baseCommit, headCommit)) {
-                throw new Error(`Direct Candidate Task main does not descend from its recorded base: ${entry.projectId}.`);
+                throw new Error(`${boundary} workspace does not descend from its recorded base: ${entry.projectId}.`);
             }
             projects.push({ projectId: entry.projectId, headCommit });
         }
-        return createDirectTaskMainSnapshot(workspace, projectIds, projects);
+        return projects;
     }
     async prepareWorkItemWorkspace(taskId, workItemId) {
         const item = requireWorkItem(this.store, taskId, workItemId);
@@ -722,9 +743,9 @@ export class FileTaskWorkspacePreparer {
                         : requestedBaseRef ?? head.baseCommit;
                     const requestedBase = previous?.access === "write" || requestedBaseRef === undefined
                         ? null
-                        : await this.git.inspect(project.path, requestedBaseRef);
+                        : await this.git.inspect(mainEntry.path, requestedBaseRef);
                     const physical = await this.git.ensureWorktree({
-                        repositoryPath: project.path,
+                        repositoryPath: mainEntry.path,
                         container: this.#projectContainer(project.name),
                         taskSegment,
                         roleName: item.id,
@@ -761,7 +782,7 @@ export class FileTaskWorkspacePreparer {
                         if (requestedBaseRef !== undefined && requestedBaseRef !== previous.baseRef) {
                             throw new Error(`Existing WorkItem Project base ref changed: ${item.id}/${project.id}.`);
                         }
-                        if (!await this.git.isAncestor(project.path, previous.baseCommit, physical.baseCommit)) {
+                        if (!await this.git.isAncestor(mainEntry.path, previous.baseCommit, physical.baseCommit)) {
                             throw new Error(`Existing WorkItem Project HEAD does not descend from its frozen base: `
                                 + `${item.id}/${project.id}.`);
                         }
@@ -842,8 +863,13 @@ export class FileTaskWorkspacePreparer {
             : { release: () => { }, current: heldFence.current };
         try {
             const lineage = executionLaneLineage(this.store, lockedTask, executionGroupId, executionLaneId, hint);
+            const item = lineage.purpose === "execution"
+                ? this.store.getWorkItem(taskId, lineage.workItemId)
+                : null;
             const source = lineage.purpose === "execution"
-                ? this.store.getWorkItemWorkspace(taskId, lineage.workItemId)
+                ? item?.assignee === LEADER_ROLE
+                    ? this.store.getTaskWorkspace(taskId)
+                    : this.store.getWorkItemWorkspace(taskId, lineage.workItemId)
                 : this.store.getReviewRoundWorkspace(taskId, lineage.reviewRoundId);
             if (source === null) {
                 throw new Error(`Execution Lane source workspace is not ready: ${executionLaneId}.`);
@@ -866,6 +892,16 @@ export class FileTaskWorkspacePreparer {
                     purpose: "review",
                     reviewRoundId: lineage.reviewRoundId
                 };
+            const writable = new Set(lineage.purpose === "execution"
+                ? item?.writeProjectIds ?? []
+                : lockedTask.projectBindings.map(({ projectId }) => projectId));
+            const inputHeadByProject = new Map((hint?.inputHeads ?? []).map(({ projectId, headCommit }) => [projectId, headCommit]));
+            if (hint?.inputHeads !== undefined
+                && (inputHeadByProject.size !== hint.inputHeads.length
+                    || inputHeadByProject.size !== writable.size
+                    || [...writable].some((projectId) => !inputHeadByProject.has(projectId)))) {
+                throw new Error(`Execution Lane input heads do not match writable scope: ${executionLaneId}.`);
+            }
             const existing = this.store.getManagedWorkspace(owner);
             if (existing !== null) {
                 if (existing.owner.type !== "execution-lane" || existing.root !== this.#executionLaneWorkspaceRoot(taskId, executionGroupId, executionLaneId)) {
@@ -874,9 +910,13 @@ export class FileTaskWorkspacePreparer {
                 await ensureWorkspaceView(existing.root, existing.entries);
                 this.#registerWorkspace(existing);
                 for (const entry of existing.entries.filter(({ access }) => access === "write")) {
+                    const inputHead = inputHeadByProject.get(entry.projectId);
+                    if (hint?.inputHeads !== undefined && inputHead !== entry.baseCommit) {
+                        throw new Error(`Execution Lane input head changed: ${executionLaneId}/${entry.projectId}.`);
+                    }
                     const project = requireProject(this.store, entry.projectId);
                     const physical = await this.git.ensureWorktree({
-                        repositoryPath: project.path,
+                        repositoryPath: this.#taskRepositoryPath(taskId, project.id),
                         container: this.#projectContainer(project.name),
                         taskSegment,
                         roleName: managedWorktreeName(owner),
@@ -888,12 +928,6 @@ export class FileTaskWorkspacePreparer {
                 }
                 return existing;
             }
-            const item = lineage.purpose === "execution"
-                ? this.store.getWorkItem(taskId, lineage.workItemId)
-                : null;
-            const writable = new Set(lineage.purpose === "execution"
-                ? item?.writeProjectIds ?? []
-                : lockedTask.projectBindings.map(({ projectId }) => projectId));
             const prepared = [];
             try {
                 for (const binding of lockedTask.projectBindings) {
@@ -903,13 +937,17 @@ export class FileTaskWorkspacePreparer {
                         prepared.push({ project, entry: { ...sourceEntry, access: "read" } });
                         continue;
                     }
+                    const inputHead = inputHeadByProject.get(project.id) ?? sourceEntry.baseCommit;
                     const physical = await this.git.ensureWorktree({
-                        repositoryPath: project.path,
+                        repositoryPath: this.#taskRepositoryPath(taskId, project.id),
                         container: this.#projectContainer(project.name),
                         taskSegment,
                         roleName: managedWorktreeName(owner),
-                        baseRef: sourceEntry.baseCommit
+                        baseRef: inputHead
                     });
+                    if (physical.baseCommit !== inputHead) {
+                        throw new Error(`Execution Lane physical input head changed: ${executionLaneId}/${project.id}.`);
+                    }
                     prepared.push({
                         project,
                         entry: {
@@ -917,8 +955,8 @@ export class FileTaskWorkspacePreparer {
                             access: "write",
                             path: physical.path,
                             branch: physical.branch,
-                            baseRef: sourceEntry.baseCommit,
-                            baseCommit: sourceEntry.baseCommit
+                            baseRef: inputHead,
+                            baseCommit: inputHead
                         }
                     });
                 }
@@ -969,168 +1007,6 @@ export class FileTaskWorkspacePreparer {
             }
         }
     }
-    /** Merge every selected lane's committed output into the WorkItem owner. */
-    async materializeExecutionGroupCandidate(taskId, workItemId, executionGroupId, selectedLaneIds) {
-        const item = requireWorkItem(this.store, taskId, workItemId);
-        const task = requireTask(this.store, taskId);
-        const group = workItemExecutionGroupById(item, executionGroupId);
-        if (group === undefined || group.id !== executionGroupId) {
-            throw new Error(`ExecutionGroup is not attached to Work Item: ${executionGroupId}.`);
-        }
-        const workspace = this.store.getWorkItemWorkspace(taskId, workItemId);
-        const selected = (selectedLaneIds.length === 0
-            ? group.lanes.filter((lane) => lane.status === "completed")
-            : group.lanes.filter((lane) => selectedLaneIds.includes(lane.id)));
-        if (selected.some((lane) => lane.status !== "completed")) {
-            throw new Error(`ExecutionGroup has a selected Lane without terminal output: ${executionGroupId}.`);
-        }
-        if (selected.length === 0)
-            throw new Error(`ExecutionGroup has no selected Lane outputs: ${executionGroupId}.`);
-        // A Gitless Task has no WorkItem workspace to materialize.  Its selected
-        // Lane reports still form a valid non-Git Candidate; no fake workspace or
-        // commit snapshot is introduced.
-        if (workspace === null) {
-            if (task.projectBindings.length === 0
-                && selected.every((lane) => lane.result?.gitSnapshot === undefined)) {
-                return { restoreTargets: [] };
-            }
-            throw new Error(`Work Item workspace is not ready for Candidate materialization: ${workItemId}.`);
-        }
-        if (workspace.owner.type !== "work-item") {
-            throw new Error(`Work Item workspace owner is invalid for Candidate materialization: ${workItemId}.`);
-        }
-        const pendingMerges = new Map();
-        const restoreTargets = [];
-        const writableProjectIds = workspace.entries
-            .filter(({ access }) => access === "write")
-            .map(({ projectId }) => projectId);
-        if (writableProjectIds.length === 0) {
-            for (const lane of selected) {
-                if (lane.result?.gitSnapshot !== undefined) {
-                    throw new Error(`Read-only Lane must not carry a Git snapshot: ${lane.id}.`);
-                }
-            }
-            return {
-                workspace,
-                // A read-only WorkItem has no Lane Git output, but its frozen
-                // WorkItem workspace is still the legitimate Candidate review
-                // context. Keep that Candidate snapshot separate from Lane output.
-                snapshot: await this.snapshotCandidateWorkspace(workspace),
-                restoreTargets: []
-            };
-        }
-        for (const lane of selected) {
-            const laneSnapshot = lane.result?.gitSnapshot;
-            if (laneSnapshot === undefined) {
-                throw new Error(`Selected Lane has no frozen Git snapshot: ${lane.id}.`);
-            }
-            const snapshotProjectIds = laneSnapshot.projects.map(({ projectId }) => projectId).sort();
-            if (!isDeepStrictEqual(snapshotProjectIds, [...writableProjectIds].sort())) {
-                throw new Error(`Selected Lane Git snapshot Project scope changed: ${lane.id}.`);
-            }
-            const laneWorkspace = this.store.getManagedWorkspace({
-                type: "execution-lane",
-                taskId,
-                executionGroupId,
-                executionLaneId: lane.id,
-                purpose: "execution",
-                workItemId
-            });
-            if (laneWorkspace === null) {
-                // fixed(1) retains the WorkItem owner as its single normal-path workspace.
-                if (group.lanes.length === 1) {
-                    for (const target of workspace.entries.filter(({ access }) => access === "write")) {
-                        const frozen = laneSnapshot.projects.find(({ projectId }) => projectId === target.projectId);
-                        if (frozen === undefined)
-                            throw new Error(`Selected Lane snapshot omits Project: ${lane.id}/${target.projectId}.`);
-                        if (await this.git.headRef(target.path) !== frozen.branch || !await this.git.isClean(target.path)) {
-                            throw new Error(`Single-Lane workspace is not clean on its managed branch: ${lane.id}/${target.projectId}.`);
-                        }
-                        const targetHead = (await this.git.inspect(target.path, "HEAD")).baseCommit;
-                        if (targetHead !== frozen.headCommit) {
-                            throw new Error(`Single-Lane workspace changed before resolution: ${lane.id}/${target.projectId}.`);
-                        }
-                    }
-                    continue;
-                }
-                throw new Error(`Selected Execution Lane workspace is not adopted: ${lane.id}.`);
-            }
-            for (const target of workspace.entries.filter(({ access }) => access === "write")) {
-                const source = laneWorkspace.entries.find(({ projectId }) => projectId === target.projectId);
-                if (source === undefined)
-                    throw new Error(`Selected Lane omits Project: ${lane.id}/${target.projectId}.`);
-                const frozen = laneSnapshot.projects.find(({ projectId }) => projectId === target.projectId);
-                if (frozen === undefined)
-                    throw new Error(`Selected Lane snapshot omits Project: ${lane.id}/${target.projectId}.`);
-                if (await this.git.headRef(source.path) !== frozen.branch || frozen.branch !== source.branch) {
-                    throw new Error(`Selected Lane left its managed branch: ${lane.id}/${target.projectId}.`);
-                }
-                if (!await this.git.isClean(source.path)) {
-                    throw new Error(`Selected Lane has uncommitted output: ${lane.id}/${target.projectId}.`);
-                }
-                const sourceHead = (await this.git.inspect(source.path, "HEAD")).baseCommit;
-                if (sourceHead !== frozen.headCommit) {
-                    throw new Error(`Selected Lane advanced before resolution: ${lane.id}/${target.projectId}.`);
-                }
-                const targetHead = (await this.git.inspect(target.path, "HEAD")).baseCommit;
-                if (sourceHead !== targetHead && !await this.git.isAncestor(target.path, sourceHead, targetHead)) {
-                    const pending = pendingMerges.get(target.path) ?? [];
-                    pending.push(frozen.headCommit);
-                    pendingMerges.set(target.path, pending);
-                    if (!restoreTargets.some(({ path }) => path === target.path)) {
-                        restoreTargets.push({ path: target.path, head: targetHead });
-                    }
-                }
-            }
-        }
-        try {
-            for (const [targetPath, sourceRefs] of pendingMerges) {
-                await this.git.mergeWorktree({ targetPath, sourceRefs });
-                const target = restoreTargets.find(({ path }) => path === targetPath);
-                if (target !== undefined) {
-                    target.mergedHead = (await this.git.inspect(targetPath, "HEAD")).baseCommit;
-                }
-            }
-            return {
-                workspace,
-                snapshot: await this.snapshotCandidateWorkspace(workspace),
-                restoreTargets: restoreTargets
-                    .filter((target) => (target.mergedHead !== undefined && target.mergedHead !== target.head))
-            };
-        }
-        catch (error) {
-            for (const target of [...restoreTargets].reverse()) {
-                if (target.mergedHead === undefined)
-                    continue;
-                try {
-                    await this.git.resetWorktree({
-                        targetPath: target.path,
-                        expectedHead: target.mergedHead,
-                        restoreHead: target.head
-                    });
-                }
-                catch (restoreError) {
-                    throw new Error(`Candidate materialization failed and Git compensation could not restore ${target.path}.`, { cause: restoreError });
-                }
-            }
-            throw error;
-        }
-    }
-    async restoreExecutionGroupCandidateMaterialization(materialization) {
-        for (const target of [...materialization.restoreTargets].reverse()) {
-            const current = (await this.git.inspect(target.path, "HEAD")).baseCommit;
-            if (current === target.head)
-                continue;
-            if (current !== target.mergedHead) {
-                throw new Error(`Candidate materialization compensation found unexpected Git head: ${target.path}.`);
-            }
-            await this.git.resetWorktree({
-                targetPath: target.path,
-                expectedHead: target.mergedHead,
-                restoreHead: target.head
-            });
-        }
-    }
     async cleanupExecutionLaneWorkspace(taskId, executionGroupId, executionLaneId) {
         const task = requireTask(this.store, taskId);
         const lineage = executionLaneLineage(this.store, task, executionGroupId, executionLaneId);
@@ -1141,8 +1017,9 @@ export class FileTaskWorkspacePreparer {
             ? (item === null ? undefined : workItemExecutionGroupById(item, executionGroupId))
             : this.store.getReviewRound(taskId, lineage.reviewRoundId)?.executionGroup;
         const lane = group?.lanes.find(({ id }) => id === executionLaneId);
+        const terminal = lane !== undefined && lane.disposition !== "open";
         if (group === undefined
-            || lane === undefined || !["completed", "failed", "skipped"].includes(lane.status)) {
+            || lane === undefined || !terminal) {
             throw new Error(`Execution Lane is not terminally resolved: ${taskId}/${executionLaneId}.`);
         }
         const workspace = this.store.listManagedWorkspaces(taskId).find(({ owner }) => (owner.type === "execution-lane"
@@ -1150,14 +1027,14 @@ export class FileTaskWorkspacePreparer {
             && owner.executionLaneId === executionLaneId));
         if (workspace === undefined)
             return "missing";
-        const state = await this.#inspectEntries(this.#taskSegment(task), managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
+        const state = await this.#inspectEntries(task.id, this.#taskSegment(task), managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
         if (state === "dirty")
             return "dirty";
         let removed = false;
         for (const entry of workspace.entries.filter(({ access }) => access === "write")) {
             const project = requireProject(this.store, entry.projectId);
             const result = await this.git.removeWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment: this.#taskSegment(task),
                 roleName: managedWorktreeName(workspace.owner),
@@ -1184,7 +1061,7 @@ export class FileTaskWorkspacePreparer {
         const writable = workspace.entries.filter(({ access }) => access === "write");
         let state;
         try {
-            state = await this.#inspectEntries(taskSegment, managedWorktreeName(workspace.owner), writable);
+            state = await this.#inspectEntries(task.id, taskSegment, managedWorktreeName(workspace.owner), writable);
         }
         catch (error) {
             // A `project migrate` between preparation and compensation switches the
@@ -1210,7 +1087,7 @@ export class FileTaskWorkspacePreparer {
         for (const entry of writable) {
             const project = requireProject(this.store, entry.projectId);
             const result = await this.git.removeWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment,
                 roleName: managedWorktreeName(workspace.owner),
@@ -1226,10 +1103,13 @@ export class FileTaskWorkspacePreparer {
     async cleanupExecutionLaneWorkspacesForWorkItem(taskId, workItemId) {
         let result = "missing";
         const item = this.store.getWorkItem(taskId, workItemId);
-        for (const group of item?.executionGroups ?? [])
+        const groups = item?.executionGroups ?? [];
+        for (const group of groups)
             for (const lane of group.lanes) {
                 const owner = this.store.listManagedWorkspaces(taskId).find(({ owner }) => (owner.type === "execution-lane" && owner.purpose === "execution"
-                    && owner.workItemId === workItemId && owner.executionLaneId === lane.id));
+                    && owner.workItemId === workItemId
+                    && owner.executionGroupId === group.id
+                    && owner.executionLaneId === lane.id));
                 if (owner !== undefined) {
                     if (owner.owner.type !== "execution-lane")
                         continue;
@@ -1245,7 +1125,13 @@ export class FileTaskWorkspacePreparer {
     async cleanupExecutionLaneWorkspacesForReviewRound(taskId, reviewRoundId) {
         let result = "missing";
         const round = this.store.getReviewRound(taskId, reviewRoundId);
-        for (const lane of round?.executionGroup?.lanes ?? []) {
+        const lanes = round === null
+            ? []
+            : [
+                ...(round.executionGroup?.lanes ?? []),
+                ...(round.executionGroup?.lanes ?? [])
+            ];
+        for (const lane of lanes) {
             const owner = this.store.listManagedWorkspaces(taskId).find(({ owner }) => (owner.type === "execution-lane" && owner.purpose === "review"
                 && owner.reviewRoundId === reviewRoundId && owner.executionLaneId === lane.id));
             if (owner !== undefined) {
@@ -1266,7 +1152,7 @@ export class FileTaskWorkspacePreparer {
         if (workspace === null)
             return "missing";
         assertWorkItemOwnsWorkspace(item, workspace);
-        return this.#inspectEntries(item.taskId, managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
+        return this.#inspectEntries(item.taskId, this.#taskSegment(requireTask(this.store, item.taskId)), managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
     }
     /** Prepare a fresh, reviewer-writable workspace from the candidate's
      * frozen Develop snapshot.  This record is owned by the ReviewRound; it is
@@ -1398,7 +1284,8 @@ export class FileTaskWorkspacePreparer {
                     if (physical.root !== entry.path) {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace managed path mismatch for ${round.id}/${entry.projectId}.`);
                     }
-                    const projectRoot = await this.git.inspect(project.path, "HEAD");
+                    const taskRepository = this.#taskRepositoryPath(task.id, project.id);
+                    const projectRoot = await this.git.inspect(taskRepository, "HEAD");
                     if (physical.gitDirectory !== projectRoot.gitDirectory) {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace managed Project mismatch for ${round.id}/${entry.projectId}.`);
                     }
@@ -1417,7 +1304,7 @@ export class FileTaskWorkspacePreparer {
                     }
                     let descendsFromBase;
                     try {
-                        descendsFromBase = await this.git.isAncestor(project.path, entry.baseCommit, physical.baseCommit);
+                        descendsFromBase = await this.git.isAncestor(taskRepository, entry.baseCommit, physical.baseCommit);
                     }
                     catch (error) {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace ancestry cannot be verified for `
@@ -1458,7 +1345,7 @@ export class FileTaskWorkspacePreparer {
                 for (const source of sources) {
                     const project = requireProject(this.store, source.projectId);
                     const physical = await this.git.ensureWorktree({
-                        repositoryPath: project.path,
+                        repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                         container: this.#projectContainer(project.name),
                         taskSegment,
                         roleName: this.#reviewWorktreeName(round),
@@ -1480,7 +1367,7 @@ export class FileTaskWorkspacePreparer {
                         }
                         let descendsFromBase;
                         try {
-                            descendsFromBase = await this.git.isAncestor(project.path, source.baseCommit, physical.baseCommit);
+                            descendsFromBase = await this.git.isAncestor(this.#taskRepositoryPath(task.id, project.id), source.baseCommit, physical.baseCommit);
                         }
                         catch (error) {
                             throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace ancestry cannot be verified for `
@@ -1716,75 +1603,7 @@ export class FileTaskWorkspacePreparer {
         if (round.workspace !== undefined && !isDeepStrictEqual(round.workspace, workspace)) {
             throw new Error(`ReviewRound workspace record diverged: ${round.id}.`);
         }
-        return this.#inspectEntries(this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries);
-    }
-    async snapshotReviewRoundResult(taskId, reviewRoundId) {
-        const round = this.store.getReviewRound(taskId, reviewRoundId);
-        if (round === null)
-            throw new Error(`ReviewRound not found: ${taskId}/${reviewRoundId}.`);
-        const workspace = this.store.getReviewRoundWorkspace(taskId, reviewRoundId);
-        if (round.status !== "running" || workspace === null) {
-            throw new Error(`ReviewRound is not running in a managed workspace: ${reviewRoundId}.`);
-        }
-        assertReviewRoundOwnsWorkspace(round.id, workspace);
-        if (round.workspace === undefined || !isDeepStrictEqual(round.workspace, workspace)) {
-            throw new Error(`ReviewRound workspace record diverged: ${round.id}.`);
-        }
-        return this.#snapshotReviewWorkspaceEntries(round.id, workspace, round.reviewBaseCommit);
-    }
-    /**
-     * Snapshot the exact workspace recorded on one Reviewer Turn. Panel Lanes
-     * own separate durable workspaces; the ReviewRound's shared workspace is
-     * not a valid substitute for a Lane's branch/head evidence.
-     */
-    async snapshotReviewRunResult(taskId, run) {
-        if (run.taskId !== taskId || run.purpose !== "review" || run.reviewRoundId === undefined) {
-            throw new Error(`Turn is not an exact ReviewRound Turn: ${run.id}.`);
-        }
-        if (run.workspace === undefined) {
-            throw new Error(`Review Turn has no managed workspace: ${run.id}.`);
-        }
-        const round = this.store.getReviewRound(taskId, run.reviewRoundId);
-        if (round === null || round.status !== "running") {
-            throw new Error(`ReviewRound is not running for Review Turn: ${run.id}.`);
-        }
-        const stored = this.store.getManagedWorkspace(run.workspace.owner);
-        if (stored === null || !isDeepStrictEqual(stored, run.workspace)) {
-            throw new Error(`Review Turn workspace is not the durable owner: ${run.id}.`);
-        }
-        if (run.workspace.owner.type === "review-round") {
-            if (run.workspace.owner.taskId !== taskId
-                || run.workspace.owner.reviewRoundId !== round.id
-                || round.workspace === undefined
-                || !isDeepStrictEqual(round.workspace, run.workspace)) {
-                throw new Error(`Review Turn workspace owner does not match its ReviewRound: ${run.id}.`);
-            }
-            return this.#snapshotReviewWorkspaceEntries(round.id, run.workspace, round.reviewBaseCommit);
-        }
-        if (run.workspace.owner.type !== "execution-lane"
-            || run.workspace.owner.taskId !== taskId
-            || run.workspace.owner.purpose !== "review"
-            || run.workspace.owner.reviewRoundId !== round.id
-            || run.workspace.owner.executionGroupId !== run.executionGroupId
-            || run.workspace.owner.executionLaneId !== run.executionLaneId) {
-            throw new Error(`Review Turn workspace owner does not match its Lane lineage: ${run.id}.`);
-        }
-        const lane = round.executionGroup?.lanes.find(({ id }) => id === run.executionLaneId);
-        const writableProjectIds = run.workspace.entries
-            .filter(({ access }) => access === "write")
-            .map(({ projectId }) => projectId)
-            .sort();
-        if (lane === undefined
-            || lane.turnId !== run.id
-            || lane.roleName !== run.roleName
-            || lane.reviewRoundId !== round.id
-            || lane.workspace?.root !== run.workspace.root
-            || !isDeepStrictEqual([...lane.workspace.writableProjectIds].sort(), writableProjectIds)
-            || run.workspace.entries.length === 0
-            || run.workspace.entries.some(({ access }) => access !== "write")) {
-            throw new Error(`Review Turn Lane workspace lineage is not exact: ${run.id}.`);
-        }
-        return this.#snapshotReviewWorkspaceEntries(round.id, run.workspace, round.reviewBaseCommit);
+        return this.#inspectEntries(task.id, this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries);
     }
     async inspectExecutionLaneWorkspace(taskId, executionGroupId, executionLaneId) {
         const task = requireTask(this.store, taskId);
@@ -1793,7 +1612,7 @@ export class FileTaskWorkspacePreparer {
             && owner.executionLaneId === executionLaneId));
         if (workspace === undefined)
             return "missing";
-        return this.#inspectEntries(this.#taskSegment(task), managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
+        return this.#inspectEntries(task.id, this.#taskSegment(task), managedWorktreeName(workspace.owner), workspace.entries.filter(({ access }) => access === "write"));
     }
     async cleanupReviewRoundWorkspace(taskId, reviewRoundId) {
         const task = requireTask(this.store, taskId);
@@ -1818,13 +1637,16 @@ export class FileTaskWorkspacePreparer {
         for (const lane of round.executionGroup?.lanes ?? []) {
             assertWorkspaceSessionsRetirable(this.store, task.id, lane.roleName, this.now());
         }
-        if (await this.#inspectEntries(this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries) === "dirty")
+        for (const lane of round.executionGroup?.lanes ?? []) {
+            assertWorkspaceSessionsRetirable(this.store, task.id, lane.roleName, this.now());
+        }
+        if (await this.#inspectEntries(task.id, this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries) === "dirty")
             return "dirty";
         let removed = false;
         for (const entry of workspace.entries) {
             const project = requireProject(this.store, entry.projectId);
             const result = await this.git.removeWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment: this.#taskSegment(task),
                 roleName: this.#reviewWorktreeName(round),
@@ -1884,13 +1706,13 @@ export class FileTaskWorkspacePreparer {
                 assertWorkspaceSessionsRetirable(this.store, task.id, lane.roleName, this.now());
             }
         const writable = workspace.entries.filter(({ access }) => access === "write");
-        if (await this.#inspectEntries(this.#taskSegment(task), managedWorktreeName(workspace.owner), writable) === "dirty")
+        if (await this.#inspectEntries(task.id, this.#taskSegment(task), managedWorktreeName(workspace.owner), writable) === "dirty")
             return "dirty";
         let removed = false;
         for (const entry of writable) {
             const project = requireProject(this.store, entry.projectId);
             const result = await this.git.removeWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment: this.#taskSegment(task),
                 roleName: managedWorktreeName(workspace.owner),
@@ -1916,6 +1738,61 @@ export class FileTaskWorkspacePreparer {
         }
         return removed ? "removed" : "missing";
     }
+    async inspectIntegrationWorkspace(taskId, integrationId) {
+        const workspace = this.store.getIntegrationWorkspace(taskId, integrationId);
+        if (workspace === null)
+            return "missing";
+        if (workspace.owner.type !== "integration-attempt"
+            || workspace.owner.integrationAttemptId !== integrationId) {
+            throw new Error(`Integration workspace ownership is invalid: ${taskId}/${integrationId}.`);
+        }
+        let found = false;
+        for (const entry of workspace.entries.filter(({ access }) => access === "write")) {
+            try {
+                if (!await this.git.isClean(entry.path))
+                    return "dirty";
+                found = true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("No such file"))
+                    continue;
+                throw error;
+            }
+        }
+        return found ? "clean" : "missing";
+    }
+    async cleanupIntegrationWorkspace(taskId, integrationId) {
+        const task = requireTask(this.store, taskId);
+        const attempt = this.store.getIntegrationAttempt(task.id, integrationId);
+        if (attempt === null) {
+            throw new Error(`IntegrationAttempt not found: ${task.id}/${integrationId}.`);
+        }
+        if (attempt.status === "running"
+            || attempt.status === "blocked"
+            || attempt.status === "validating") {
+            throw new Error(`IntegrationAttempt must be terminal before cleanup: ${attempt.id}.`);
+        }
+        const workspace = this.store.getIntegrationWorkspace(task.id, attempt.id);
+        const project = requireProject(this.store, attempt.projectId);
+        const result = await this.git.removeIntegrationWorktree({
+            repositoryPath: this.#taskRepositoryPath(task.id, project.id),
+            container: this.#projectContainer(project.name),
+            taskSegment: this.#taskSegment(task),
+            integrationId: attempt.id,
+            discardChanges: attempt.status === "failed"
+        });
+        if (result !== "dirty") {
+            if (workspace !== null)
+                this.#resourceRegistrar().markWorkspaceDeleted(workspace);
+            await rm(join(this.home, "artifacts", "integration-checks", task.id, attempt.id), { recursive: true, force: true });
+            this.store.removeManagedWorkspace({
+                type: "integration-attempt",
+                taskId: task.id,
+                integrationAttemptId: attempt.id
+            });
+        }
+        return result;
+    }
     async inspectTaskMainWorkspace(taskId) {
         const task = requireTask(this.store, taskId);
         const main = this.store.getTaskWorkspace(task.id);
@@ -1924,7 +1801,7 @@ export class FileTaskWorkspacePreparer {
         if (main.owner.type !== "task") {
             throw new Error(`Task main workspace ownership is invalid: ${task.id}.`);
         }
-        return this.#inspectEntries(this.#taskSegment(task), MAIN_WORKTREE, main.entries);
+        return this.#inspectEntries(task.id, this.#taskSegment(task), MAIN_WORKTREE, main.entries);
     }
     async cleanupTaskForArchive(taskId) {
         const task = requireTask(this.store, taskId);
@@ -1942,7 +1819,7 @@ export class FileTaskWorkspacePreparer {
         const main = this.store.getTaskWorkspace(task.id);
         if (main !== null) {
             assertTaskArchiveState(requireTask(this.store, task.id), task);
-            if (await this.#inspectEntries(this.#taskSegment(task), MAIN_WORKTREE, main.entries) === "dirty") {
+            if (await this.#inspectEntries(task.id, this.#taskSegment(task), MAIN_WORKTREE, main.entries) === "dirty") {
                 return {
                     taskId,
                     status: "retained-dirty",
@@ -1951,13 +1828,7 @@ export class FileTaskWorkspacePreparer {
             }
             for (const entry of main.entries) {
                 assertTaskArchiveState(requireTask(this.store, task.id), task);
-                const project = requireProject(this.store, entry.projectId);
-                const result = await this.git.removeWorktree({
-                    repositoryPath: project.path,
-                    container: this.#projectContainer(project.name),
-                    taskSegment: this.#taskSegment(task),
-                    roleName: MAIN_WORKTREE
-                });
+                const result = await this.git.removeStrandedWorktree(entry.path);
                 if (result === "dirty") {
                     throw new Error(`Task workspace changed after cleanup preflight: ${task.id}.`);
                 }
@@ -1971,14 +1842,14 @@ export class FileTaskWorkspacePreparer {
         this.#clearTaskWorkspace(task, this.#fallbackWorkspace());
         return { taskId, status: "removed" };
     }
-    async #inspectEntries(taskSegment, roleName, entries) {
+    async #inspectEntries(taskId, taskSegment, roleName, entries) {
         if (entries.length === 0)
             return "missing";
         let found = false;
         for (const entry of entries) {
             const project = requireProject(this.store, entry.projectId);
             const state = await this.git.inspectWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(taskId, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment,
                 roleName
@@ -1989,39 +1860,6 @@ export class FileTaskWorkspacePreparer {
         }
         return found ? "clean" : "missing";
     }
-    async #snapshotReviewWorkspaceEntries(reviewRoundId, workspace, reviewBaseCommit) {
-        const changed = [];
-        let dirty = false;
-        for (const entry of workspace.entries) {
-            if (await this.git.headRef(entry.path) !== entry.branch) {
-                throw new Error(`Review Project workspace left its managed branch: ${reviewRoundId}/${entry.projectId}.`);
-            }
-            const head = (await this.git.inspect(entry.path, "HEAD")).baseCommit;
-            const project = requireProject(this.store, entry.projectId);
-            if (!await this.git.isAncestor(project.path, entry.baseCommit, head)) {
-                throw new Error(`Review workspace HEAD does not descend from its frozen base for `
-                    + `${reviewRoundId}/${entry.projectId}: expected ancestor ${entry.baseCommit}, `
-                    + `physical HEAD ${head}.`);
-            }
-            if (head !== entry.baseCommit)
-                changed.push(head);
-            if (!await this.git.isClean(entry.path))
-                dirty = true;
-        }
-        if (changed.length > 1) {
-            throw new Error(`Review workspace has diagnostic commits in multiple Projects; preserve it for Leader routing: ${reviewRoundId}.`);
-        }
-        // A dirty worktree has uncommitted diagnostics: no single commit captures
-        // the tree the checks ran on, so no evidenceCommit can attest it and the
-        // queue must re-run the gate.  A clean worktree attests that checks ran on
-        // the recorded tree: the frozen base when the reviewer made no commits, or
-        // the reviewer's single diagnostic commit otherwise.
-        if (dirty)
-            return {};
-        return changed.length === 0
-            ? { evidenceCommit: reviewBaseCommit }
-            : { evidenceCommit: changed[0] };
-    }
     #projectContainer(projectName) {
         return join(resolveWorktreeRoot(this.home, this.store.getConfig().defaultWorkspace), safePathSegment(projectName));
     }
@@ -2057,8 +1895,16 @@ export class FileTaskWorkspacePreparer {
     async #discardUnadoptedEntries(task, taskSegment, prepared, roleName, deleteBranch = false, adoptedPaths = new Set(this.store.listManagedWorkspaces(task.id)
         .flatMap((workspace) => workspace.entries.map(({ path }) => path)))) {
         for (const { project, entry } of prepared.filter(({ entry }) => entry.access === "write" && !adoptedPaths.has(entry.path))) {
+            if (roleName === MAIN_WORKTREE) {
+                const removal = await this.git.removeStrandedWorktree(entry.path);
+                if (removal === "dirty") {
+                    throw new Error(`Unadopted Task clone is dirty and was retained at ${entry.path}; inspect it and retry.`);
+                }
+                this.#resourceRegistrar().markPathsDeleted([entry.path]);
+                continue;
+            }
             const removal = await this.git.removeWorktree({
-                repositoryPath: project.path,
+                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
                 container: this.#projectContainer(project.name),
                 taskSegment,
                 roleName,
@@ -2070,6 +1916,17 @@ export class FileTaskWorkspacePreparer {
             this.#resourceRegistrar().markPathsDeleted([entry.path]);
         }
     }
+    #taskRepositoryPath(taskId, projectId) {
+        const workspace = this.store.getTaskWorkspace(taskId);
+        if (workspace === null || workspace.owner.type !== "task") {
+            throw new Error(`Task main workspace is unavailable: ${taskId}.`);
+        }
+        const entry = workspace.entries.find((candidate) => candidate.projectId === projectId);
+        if (entry === undefined) {
+            throw new Error(`Task main Project workspace is unavailable: ${taskId}/${projectId}.`);
+        }
+        return entry.path;
+    }
     #recordWorkspaceRemoval(task, workspace, fallback, workItem) {
         this.store.transaction((tx) => {
             if (workspace.owner.type === "task") {
@@ -2272,7 +2129,7 @@ function canCorrectActiveWorkItemRoleWorkspaceHint(store, taskId, role, item, wo
         || session === undefined
         || session.agentId !== role.activeAgentId
         || session.adapterId !== run.effective.adapterId
-        || session.launchId === undefined
+        || session.runtimeGenerationId === undefined
         || session.nativeSessionId === undefined
         || !["ready", "running"].includes(session.status)
         || !isDeepStrictEqual(session.effective, run.effective)
@@ -2290,7 +2147,7 @@ function canCorrectActiveWorkItemRoleWorkspaceHint(store, taskId, role, item, wo
         && lifecycle !== undefined
         && isRuntimeLaunchReservation(lifecycle)) {
         const executionRef = lifecycle.executionRef;
-        if (!isRuntimeLaunchReservation(lifecycle, session.launchId)
+        if (!isRuntimeLaunchReservation(lifecycle, session.runtimeGenerationId)
             || executionRef?.type !== "turn"
             || executionRef.taskId !== taskId
             || executionRef.id !== run.id)
@@ -2367,22 +2224,6 @@ function safePathSegment(value) {
 function sameCommit(left, right) {
     return left.toLowerCase() === right.toLowerCase();
 }
-function remoteDefaultProjects(store, taskId) {
-    const projectIds = new Set();
-    for (const event of store.listEvents(taskId)) {
-        if (event.type === "task.created") {
-            for (const projectId of (event.payload.defaultProjectIds ?? "").split(",")) {
-                const normalized = projectId.trim();
-                if (normalized.length > 0)
-                    projectIds.add(normalized);
-            }
-        }
-    }
-    return projectIds;
-}
-function looksLikeCommit(value) {
-    return /^[a-f0-9]{40}(?:[a-f0-9]{24})?$/iu.test(value);
-}
 export function resolveWorktreeRoot(home, workspace) {
     return join(resolveWorkspaceRoot(home, workspace), "worktree");
 }