@zq-silk/yui 0.14.1 → 0.14.2

package/dist/cli.js

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { renderCommandHelp } from "./cli/helpRenderer.js";
 import { describeCommandTree, findCommandNode } from "./cli/commandCatalog.js";
 import { routeInvocation } from "./cli/invocationRouter.js";
@@ -35,8 +36,12 @@ import { runTelemetryCommand } from "./commands/telemetryCommands.js";
 import { runResourcesCommand } from "./commands/resourcesCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
-import { runProfileCommand } from "./commands/profileCommands.js";
-import { dispatchPreparedReviewRound, failPendingReviewRound, preserveReviewRoundWorkspace, parseTaskCompletionRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, resolvedExecutionStageRetryGroup, validateTaskArchiveRequest } from "./commands/taskCommands.js";
+import { previewProfileAgentConfigurationMutation, runProfileCommand } from "./commands/profileCommands.js";
+import { assertWorkItemDependenciesCompletedForCommand, dispatchPreparedReviewRound, failPendingReviewRound, preserveReviewRoundWorkspace, parseTaskCompletionRequest, previewTaskRoleAgentConfigurationMutation, preflightTaskCompletion, runTaskCommand, planReplicatedWorkItemLanes, validateTaskArchiveRequest } from "./commands/taskCommands.js";
+import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./commands/taskRemoteDeliveryCommand.js";
+import { runTaskPublicationVerifyCommand } from "./commands/taskPublicationVerifyCommand.js";
+import { createGitHubCliPublicationVerifier } from "./external/githubPublicationVerifier.js";
+import { createGitLabCliPublicationVerifier } from "./external/gitlabPublicationVerifier.js";
 import { taskActor } from "./commands/taskActor.js";
 import { parseTaskExecutionStartRequest, parseTaskExecutionStopRequest, finalizeStoppedTaskExecution, startTaskExecutionCommand, stopTaskExecutionCommand } from "./commands/taskExecutionCommands.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
@@ -78,21 +83,23 @@ import { runSetupCommand, validateSetupInvocation } from "./setup/setupCommand.j
 import { NodeCommandExecutor } from "./tmux/commandExecutor.js";
 import { TmuxManager } from "./tmux/tmuxManager.js";
 import { WorkItemChangeSetManager } from "./workspace/workItemChangeSetManager.js";
+import { workspaceProjectEntry } from "./worktree/managedWorkspace.js";
 import { parseWebCommandOptions, startYuiWebServer } from "./web/webServer.js";
-import { AgentConfigurationCatalogService } from "./executor/agentConfigurationCatalog.js";
+import { AgentConfigurationCatalogService, validateAgentLaunchConfiguration } from "./executor/agentConfigurationCatalog.js";
+import { resolveAgentProfileView } from "./profile/agentProfileRuntime.js";
 import { TmuxWebTerminalService } from "./web/tmuxWebTerminal.js";
 import { listOperatorSessions, operatorSessionRef } from "./operator/operatorSessionHistory.js";
 import { YUI_VERSION, yuiVersionIdentity } from "./version.js";
 import { SqliteSchemaMigrationError } from "./storage/sqliteSchema.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertCompatibleControlPlanePreflight, assertExactControlPlanePreflight, assertExactTaskRuntimeEnvironment, assertExactTaskRuntimeState, exactControlPlaneDigest, extractExactControlArgument, createExactControlPlaneDescriptor, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
+import { YUI_CONTROL_PLANE_DESCRIPTOR, assertCompatibleControlPlanePreflight, assertExactControlPlanePreflight, exactControlPlaneDigest, extractExactControlArgument, createExactControlPlaneDescriptor, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
+import { requireManagedTaskCaller } from "./runtime/managedCaller.js";
 import { readSessionBootstrapManifest, refreshManagedSessionCliWrappers } from "./context/sessionBootstrapManifest.js";
-import { builtinAgentDriverRegistry } from "./runtime/builtinAgentDrivers.js";
 import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./review/taskFinalReviewContract.js";
 import { resolveRecordedTaskFinalReviewContract } from "./review/taskFinalReviewContractResolution.js";
 import { assessDeltaRecheck } from "./review/deltaRecheck.js";
-import { isAcceptedTaskReviewBaseline } from "./review/reviewAcceptance.js";
+import { isCompletedTaskReviewEvidence } from "./review/reviewAcceptance.js";
 import { NodeGitWorkspace } from "./repository/gitWorkspace.js";
-import { currentWorkItemExecutionGroup, workItemExecutionGroupById } from "./workItem/workItem.js";
+import { currentWorkItemExecutionGroup } from "./workItem/workItem.js";
 const VERSION = YUI_VERSION;
 const exactControlInvocation = extractExactControlArgument(process.argv.slice(2));
 const taskFinalReviewInvocation = extractTaskFinalReviewRequest(exactControlInvocation.args);
@@ -134,8 +141,7 @@ export async function main() {
     const routedForFence = args.length === 0 ? undefined : routeInvocation(args);
     const managedInvocation = process.env.YUI_SESSION_SCOPE === "task"
         || process.env.YUI_SESSION_SCOPE === "global"
-        || process.env[YUI_CONTROL_PLANE_DESCRIPTOR] !== undefined
-        || process.env[YUI_TASK_RUNTIME_DESCRIPTOR] !== undefined;
+        || process.env[YUI_CONTROL_PLANE_DESCRIPTOR] !== undefined;
     const homeFreeInvocation = args.length === 0
         || (args[0] === "version" && args.length === 1)
         || routedForFence?.kind === "help"
@@ -298,7 +304,6 @@ export async function main() {
         return;
     }
     if (args[0] === "upgrade") {
-        // Admission diagnostic only: never quiesces, repairs, or switches storage.
         const result = await runUpgradeCommand(args.slice(1), home);
         process.exitCode = result.exitCode;
         emit(result.output, false, result.data);
@@ -318,7 +323,7 @@ export async function main() {
         if (args[1] === "agent-host" && args.length === 4) {
             process.exitCode = await runAgentHost({
                 home,
-                launchId: args[2],
+                runtimeGenerationId: args[2],
                 ticket: args[3]
             });
             return;
@@ -553,7 +558,7 @@ export async function main() {
         emit("Cancelled.");
         return;
     }
-    await preflightAgentConfigurationMutation(resolved, store, catalogs);
+    const validateAgentConfiguration = await preflightAgentConfigurationMutation(resolved, store, catalogs);
     const executor = new NodeCommandExecutor();
     const tmux = new TmuxManager(resolveTmuxBin(store.getConfig().tmuxBin), executor, {
         yuiHome: home,
@@ -682,7 +687,7 @@ export async function main() {
             return;
         }
         if (domain === "profile") {
-            const result = runProfileCommand(resolved.slice(2), store);
+            const result = runProfileCommand(resolved.slice(2), store, () => new Date(), validateAgentConfiguration === undefined ? {} : { validateAgentConfiguration });
             emit(result.output, false, result.data);
             return;
         }
@@ -820,6 +825,27 @@ export async function main() {
             emit(result.output, false, result.data);
             return;
         }
+        if (resolved[1] === "publication" && resolved[2] === "verify") {
+            const result = await runTaskPublicationVerifyCommand(resolved.slice(3), store, {
+                verifiers: {
+                    github: createGitHubCliPublicationVerifier({
+                        environmentPath: process.env.PATH
+                    }),
+                    gitlab: createGitLabCliPublicationVerifier({
+                        environmentPath: process.env.PATH
+                    })
+                },
+                candidateForTask: async (taskId) => {
+                    const status = store.getTask(taskId)?.status;
+                    return status === "active" || status === "retired"
+                        ? snapshotActualTaskReviewCandidate(taskId, store, workspacePreparer)
+                        : null;
+                },
+                environment: process.env
+            });
+            emit(result.output, false, result.data);
+            return;
+        }
         if (resolved[1] === "overlap") {
             const result = await runTaskOverlapCommand(resolved.slice(2), store);
             emit(result.output, false, result.data);
@@ -877,6 +903,7 @@ export async function main() {
                 throw usageError("Task work capture usage: yui task work capture <task>/<work>.");
             }
             const reference = cliWorkItemReference(workItemId, process.env);
+            taskActor(process.env, reference.taskId);
             const changeSets = await new WorkItemChangeSetManager(store).capture(reference.taskId, reference.localId, taskFinalReviewContract === undefined
                 ? {}
                 : { taskFinalReviewContract });
@@ -968,12 +995,23 @@ export async function main() {
             });
             return;
         }
+        let archiveRemoteDeliveryProof;
+        let archiveTaskReviewCandidate;
         if (resolved[1] === "archive") {
-            const { taskId, disposition } = validateTaskArchiveRequest(resolved.slice(2), store, { runtime, environment: process.env, yuiHome: home });
+            const { taskId, disposition, forceUnverified } = validateTaskArchiveRequest(resolved.slice(2), store, {
+                runtime,
+                environment: process.env,
+                yuiHome: home
+            });
             const task = store.getTask(taskId);
             if (task === null)
                 throw new Error(`Task disappeared after archive validation: ${taskId}.`);
             if (task.status !== "archived") {
+                if (disposition === "integrated") {
+                    archiveTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env);
+                    archiveRemoteDeliveryProof = createTaskRemoteDeliveryProof(store, task, archiveTaskReviewCandidate ?? null);
+                    assertTaskRemoteDeliveryIntegrated(archiveRemoteDeliveryProof.delivery, { forceUnverified });
+                }
                 const workItemIds = store.listManagedWorkspaces(task.id)
                     .flatMap(({ owner }) => owner.type === "work-item" ? [owner.workItemId] : []);
                 for (const workItemId of workItemIds) {
@@ -1012,6 +1050,7 @@ export async function main() {
                 }
             }
         }
+        assertWorkItemExecutionDependenciesForCommand(resolved, store, process.env);
         if (resolved[1] === "work" && resolved[2] === "dispatch") {
             const workItemId = resolved[3];
             const reference = workItemId === undefined
@@ -1021,11 +1060,19 @@ export async function main() {
                 ? null
                 : store.getWorkItem(reference.taskId, reference.localId);
             const task = item === null ? null : store.getTask(item.taskId);
+            if (item !== null && task !== null) {
+                // Authority and pure Lane-shape checks precede every physical or
+                // durable workspace preparation performed for dispatch.
+                taskActor(process.env, task.id);
+                if (item.assignee !== undefined) {
+                    workItemDispatchLanePlan(resolved, store, item);
+                }
+            }
             // A rejected Candidate starts a new execution iteration. Release every
             // terminal Lane Role runtime before preparing the new Lane workspaces;
             // durable Turns, Groups, Candidates, and workspace owners remain intact.
             if (item?.status === "failed"
-                && currentWorkItemExecutionGroup(item)?.resolution !== undefined) {
+                && currentWorkItemExecutionGroup(item)?.lanes.every(({ disposition }) => disposition !== "open")) {
                 await workspaceCoordinator.cleanupWorkItemRuntime(item.taskId, item.id);
             }
             // Every Task needs an authoritative runtime owner before dispatch. A
@@ -1078,7 +1125,9 @@ export async function main() {
             return;
         }
         if (resolved[1] === "upstream") {
-            const result = await runTaskUpstreamCommand(resolved.slice(2), store);
+            const result = await runTaskUpstreamCommand(resolved.slice(2), store, home, {
+                environment: process.env
+            });
             emit(result.output, false, result.data);
             return;
         }
@@ -1116,19 +1165,24 @@ export async function main() {
                 // Keep completion offline by default. An explicit refresh is the only
                 // path that may fetch and reconcile a moved remote baseline.
                 if (refreshRemote) {
-                    await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env, jobPort: createControllerIntegrationJobPort(home, { environment: process.env }) });
+                    const reconciled = await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env, jobPort: createControllerIntegrationJobPort(home, { environment: process.env }) });
+                    if (reconciled.length > 0) {
+                        const updates = reconciled.map((entry) => (`${entry.projectId}: ${entry.fromCommit} -> ${entry.toCommit} `
+                            + `(Integration ${entry.integrationId})`)).join("; ");
+                        throw usageError(`Remote baseline reconciliation advanced Task ${resolved[2]} (${updates}). `
+                            + "The Task remains active so the Leader can inspect the new authoritative head, "
+                            + "decide how prior Review evidence applies, and retry task complete.");
+                    }
                 }
             }
         }
         let releaseReviewHandoverLock;
         if ((resolved[1] === "review"
-            && ["request", "force-fresh", "retry"].includes(resolved[2] ?? ""))
+            && ["request", "retry"].includes(resolved[2] ?? ""))
             || resolved[1] === "complete") {
             const handoverLock = acquireHandoverLock(home);
             releaseReviewHandoverLock = handoverLock.release;
         }
-        let candidateMaterialization;
-        let candidateMaterializationCommitted = false;
         try {
             const preparedLanes = await prepareExecutionLaneWorkspacesForCommand(resolved, store, workspacePreparer, process.env);
             if (preparedLanes !== undefined) {
@@ -1136,12 +1190,11 @@ export async function main() {
                 laneDispatchRelease = preparedLanes.release;
                 laneDispatchProjectPaths = preparedLanes.projectPaths;
             }
-            candidateMaterialization = await candidateMaterializationForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
-            const candidateGitSnapshot = candidateMaterialization === undefined
-                ? await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract)
-                : candidateMaterialization.snapshot;
+            const candidateGitSnapshot = await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
             const directTaskMainSnapshot = await directTaskMainSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
-            const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env);
+            const actualTaskReviewCandidate = archiveRemoteDeliveryProof === undefined
+                ? await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env)
+                : archiveTaskReviewCandidate;
             const deltaRecheckPreflight = await deltaRecheckPreflightForTaskCommand(resolved.slice(1), store, actualTaskReviewCandidate);
             // Physical preparation may precede the durable write, but Task status,
             // workspace identity/cwd, and ManagedWorkspace ownership are adopted by
@@ -1168,9 +1221,6 @@ export async function main() {
                     : { completionPublishedTreeProof }),
                 ...(workItemIntegrationProof === undefined ? {} : { workItemIntegrationProof }),
                 ...(candidateGitSnapshot === undefined ? {} : { candidateGitSnapshot }),
-                ...(candidateMaterialization === undefined
-                    ? {}
-                    : { candidateWorkspace: candidateMaterialization.workspace ?? null }),
                 ...(executionLaneWorkspaces === undefined ? {} : { executionLaneWorkspaces }),
                 ...(taskWorkspaceActivation === undefined ? {} : { taskWorkspaceActivation }),
                 ...(laneDispatchProjectPaths === undefined ? {} : { laneDispatchProjectPaths }),
@@ -1178,10 +1228,16 @@ export async function main() {
                 ...(actualTaskReviewCandidate === undefined
                     ? {}
                     : { actualTaskReviewCandidate }),
+                ...(archiveRemoteDeliveryProof === undefined
+                    ? {}
+                    : { archiveRemoteDeliveryProof }),
                 ...(deltaRecheckPreflight === undefined
                     ? {}
                     : { deltaRecheckPreflight }),
-                ...(taskRetirementProof === undefined ? {} : { taskRetirementProof })
+                ...(taskRetirementProof === undefined ? {} : { taskRetirementProof }),
+                ...(validateAgentConfiguration === undefined
+                    ? {}
+                    : { validateAgentConfiguration })
             });
             // The dispatch transaction has now adopted (or rejected) the prepared
             // Lane workspaces. Release the held fence so later output/review
@@ -1190,9 +1246,6 @@ export async function main() {
                 laneDispatchRelease();
                 laneDispatchRelease = undefined;
             }
-            // The command transaction has now durably submitted the Candidate. Any
-            // later output/review handling must not roll back its Git snapshot.
-            candidateMaterializationCommitted = candidateMaterialization !== undefined;
             if (result.kind === "output") {
                 const requestedRound = reviewRoundFromCommandData(result.data);
                 const persistedRequestedRound = requestedRound === undefined
@@ -1206,7 +1259,9 @@ export async function main() {
                 const reviewDispatchNeeded = requestedRound?.status === "pending"
                     || (requestedRound?.status === "running"
                         && resumesReviewDispatch
-                        && persistedRequestedRound?.executionGroup?.lanes.some((lane) => (lane.status === "pending" && lane.turnId === undefined)) === true);
+                        && persistedRequestedRound?.executionGroup?.lanes.some((lane) => (lane.disposition === "open"
+                            && (lane.currentTurnId === undefined
+                                || store.getTurn(requestedRound.taskId, lane.currentTurnId)?.status === "failed"))) === true);
                 if (reviewDispatchNeeded) {
                     try {
                         const workspace = requestedRound.status === "running"
@@ -1242,17 +1297,15 @@ export async function main() {
                                 })
                         });
                         reviewOutput = run === null
-                            ? `Review ${requestedRound.id} retained pending by Resource Broker\n`
+                            ? `Review ${requestedRound.id} remains running\n`
                             : `Review queued as ${requestedRound.id} (${run.id})\n`;
                         reviewData = {
                             reviewRequest: run === null
                                 ? {
-                                    kind: "busy",
+                                    kind: "running",
                                     reviewerRoleName: requestedRound.reviewerRoleName,
-                                    phase: "resource-broker",
                                     activeReviewRoundId: requestedRound.id,
-                                    retryable: true,
-                                    retryAfterSeconds: 5
+                                    retryable: false
                                 }
                                 : {
                                     kind: "started",
@@ -1311,7 +1364,7 @@ export async function main() {
                         agentId: result.agentId,
                         adapterId: result.adapterId,
                         nativeSessionId: result.nativeSessionId,
-                        ...(result.launchId === undefined ? {} : { launchId: result.launchId }),
+                        ...(result.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: result.runtimeGenerationId }),
                         sessionUpdatedAt: result.sessionUpdatedAt
                     });
                 }
@@ -1405,12 +1458,7 @@ export async function main() {
             return;
         }
         catch (error) {
-            if (candidateMaterialization !== undefined && !candidateMaterializationCommitted) {
-                await workspacePreparer.restoreExecutionGroupCandidateMaterialization(candidateMaterialization);
-            }
-            if (!candidateMaterializationCommitted) {
-                await workspacePreparer.discardUnadoptedExecutionLaneWorkspaces(executionLaneWorkspaces);
-            }
+            await workspacePreparer.discardUnadoptedExecutionLaneWorkspaces(executionLaneWorkspaces);
             if (laneDispatchRelease !== undefined) {
                 laneDispatchRelease();
                 laneDispatchRelease = undefined;
@@ -1465,10 +1513,9 @@ async function preflightManagedTaskControlPlane() {
         throw new Error(taskFinalReviewInvocation.error);
     }
     const serializedControl = process.env[YUI_CONTROL_PLANE_DESCRIPTOR];
-    const serializedRuntime = process.env[YUI_TASK_RUNTIME_DESCRIPTOR];
-    const exactAgentRuntime = serializedControl !== undefined || serializedRuntime !== undefined;
+    const exactAgentRuntime = serializedControl !== undefined;
     if (process.env.YUI_SESSION_SCOPE === "task" && !exactAgentRuntime) {
-        throw new Error("Exact control-plane invocation requires both frozen descriptors in a managed Task runtime.");
+        throw new Error("Exact control-plane invocation requires its frozen descriptor in a managed Task runtime.");
     }
     if (!exactAgentRuntime) {
         if (exactControlInvocation.digest !== undefined
@@ -1483,7 +1530,7 @@ async function preflightManagedTaskControlPlane() {
     if (process.env.YUI_SESSION_SCOPE !== "task") {
         throw new Error("Exact Task control-plane invocation requires a managed Task runtime.");
     }
-    if (serializedControl === undefined || serializedRuntime === undefined) {
+    if (serializedControl === undefined) {
         throw new Error("Exact control-plane invocation is required for this managed Task runtime.");
     }
     const control = parseExactControlPlaneDescriptor(serializedControl);
@@ -1522,20 +1569,16 @@ async function preflightManagedTaskControlPlane() {
         commandControl = control;
         digest = frozenDigest;
     }
-    const runtime = assertExactTaskRuntimeEnvironment(serializedRuntime, process.env, frozenDigest, control.yuiHome);
-    const runtimeDriverCallback = args[0] === "internal"
-        && args[1] === "runtime-hook"
-        && process.env.YUI_DRIVER_ID !== undefined
-        ? builtinAgentDriverRegistry().require(process.env.YUI_DRIVER_ID)
-        : undefined;
     const verifiedStore = openCurrentTaskStore(control.yuiHome);
-    // Runtime Hooks have their own event-aware fence, including the valid case
-    // where a Provider terminal arrives after its Yui Turn has completed and a
-    // later wake is pending. Ordinary managed commands still require the exact
-    // current mutable runtime before routing.
-    if (runtimeDriverCallback === undefined) {
-        assertExactTaskRuntimeState(runtime, verifiedStore);
-    }
+    // One authority for "may this process act as this Task Role?". Yui's own
+    // internal callbacks run in the Host process and authenticate through the
+    // exact control-plane digest verified above; an Agent command proves it is
+    // the Role's current runtime with its per-Session caller key. Nothing here
+    // gates on the current Turn: which Turn is active is durable state that the
+    // command needing it reads, never a fact frozen into a process environment.
+    const runtime = internalCallback
+        ? undefined
+        : requireManagedTaskCaller(verifiedStore, process.env);
     const request = taskFinalReviewInvocation.request;
     if (request === undefined) {
         return {
@@ -1544,7 +1587,7 @@ async function preflightManagedTaskControlPlane() {
             verifiedStore
         };
     }
-    if (runtime.roleName !== "leader") {
+    if (runtime === undefined || runtime.roleName !== "leader") {
         throw new Error("Only the exact Task Leader invocation may establish a final-review contract.");
     }
     if (request.taskId !== runtime.taskId) {
@@ -1690,6 +1733,25 @@ function cliTaskRecordReference(value, kind, environment) {
         throw usageError(error instanceof Error ? error.message : String(error));
     }
 }
+function assertWorkItemExecutionDependenciesForCommand(args, store, environment) {
+    let item;
+    if (args[0] === "task" && args[1] === "work" && args[2] === "dispatch"
+        && args[3] !== undefined) {
+        const reference = cliWorkItemReference(args[3], environment);
+        item = store.getWorkItem(reference.taskId, reference.localId) ?? undefined;
+    }
+    else if (args[0] === "task" && args[1] === "turn" && args[2] === "retry"
+        && args[3] !== undefined) {
+        const reference = cliTaskRecordReference(args[3], "turn", environment);
+        const turn = store.getTurn(reference.taskId, reference.localId);
+        item = turn?.purpose === "execution" && turn.workItemId !== undefined
+            ? store.getWorkItem(turn.taskId, turn.workItemId) ?? undefined
+            : undefined;
+    }
+    if (item === undefined)
+        return;
+    assertWorkItemDependenciesCompletedForCommand(store, item);
+}
 async function candidateSnapshotForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
     if (args[0] !== "task")
         return undefined;
@@ -1718,179 +1780,79 @@ async function candidateSnapshotForTaskCommand(args, store, preparer, environmen
         }
         return preparer.snapshotCandidateWorkspace(workspace);
     }
-    if (args[1] === "work" && args[2] === "group" && args[3] === "resolve"
-        && args[4] !== undefined) {
-        // The grouped accept path snapshots only after all selected Lane outputs
-        // have been merged by candidateMaterializationForTaskCommand.
-        return undefined;
-    }
     return undefined;
 }
-async function candidateMaterializationForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
-    if (args[0] !== "task" || args[1] !== "work" || args[2] !== "group"
-        || args[3] !== "resolve" || args[4] === undefined
-        || !args.includes("--decision")
-        || args[args.indexOf("--decision") + 1] !== "accept")
-        return undefined;
-    const reference = cliWorkItemReference(args[4], environment);
-    const item = store.getWorkItem(reference.taskId, reference.localId);
-    const group = item === null || item === undefined
-        ? undefined
-        : currentWorkItemExecutionGroup(item);
-    if (item === null || item === undefined || group === undefined)
-        return undefined;
-    if (group.stage !== undefined && group.stage.stage !== "resolve")
-        return undefined;
-    // Early termination first stops never-started spend. Active stragglers are
-    // deliberately retained, so the command records that stop and leaves the
-    // group unresolved. Do not merge Lane output into the WorkItem Candidate
-    // until those active Lanes settle and the Leader resolves the group again.
-    if (args.includes("--early-stop")
-        && group.lanes.some(({ status }) => status === "running"))
-        return undefined;
-    const selected = args.flatMap((value, index) => value === "--lane" && args[index + 1] !== undefined ? [args[index + 1]] : []);
-    const materializedLaneIds = selected.length === 0
-        ? group.lanes
-            .filter((lane) => lane.status === "completed")
-            .map(({ id }) => id)
-        : selected;
-    if (group.stage?.convergence !== undefined
-        && group.stage.stage === "resolve"
-        && materializedLaneIds.length !== 1) {
-        throw usageError("Candidate convergence Resolve must select exactly one Lane before materialization.");
-    }
-    try {
-        return await preparer.materializeExecutionGroupCandidate(item.taskId, item.id, group.id, materializedLaneIds);
-    }
-    catch (error) {
-        throw usageError(error instanceof Error ? error.message : String(error));
-    }
-}
 async function prepareExecutionLaneWorkspacesForCommand(args, store, preparer, environment) {
-    const isDispatch = args[0] === "task" && args[1] === "work" && args[2] === "dispatch" && args[3] !== undefined;
-    const isRetry = args[0] === "task" && args[1] === "turn" && args[2] === "retry" && args[3] !== undefined;
-    if (!isDispatch && !isRetry)
+    const isDispatch = args[0] === "task"
+        && args[1] === "work"
+        && args[2] === "dispatch"
+        && args[3] !== undefined;
+    if (!isDispatch)
         return undefined;
-    const itemRef = isDispatch
-        ? cliWorkItemReference(args[3], environment)
-        : null;
-    const item = itemRef === null
-        ? (() => {
-            const runRef = cliTaskRecordReference(args[3], "turn", environment);
-            const run = store.getTurn(runRef.taskId, runRef.localId);
-            return run?.workItemId === undefined ? null : store.getWorkItem(run.taskId, run.workItemId);
-        })()
-        : store.getWorkItem(itemRef.taskId, itemRef.localId);
-    if (item === null)
+    const itemRef = cliWorkItemReference(args[3], environment);
+    const item = store.getWorkItem(itemRef.taskId, itemRef.localId);
+    if (item === null || item.assignee === undefined)
         return undefined;
-    const retryRun = isRetry
-        ? store.getTurn(item.taskId, cliTaskRecordReference(args[3], "turn", environment).localId)
-        : null;
-    const currentGroup = currentWorkItemExecutionGroup(item);
-    const group = retryRun?.executionGroupId === undefined
-        ? (isDispatch && currentGroup?.resolution !== undefined ? undefined : currentGroup)
-        : workItemExecutionGroupById(item, retryRun.executionGroupId);
-    const roles = args.flatMap((value, index) => (value === "--lane-role" && args[index + 1] !== undefined
-        ? [args[index + 1]]
-        : []));
-    const requestedStrategy = (() => {
-        const index = args.indexOf("--strategy");
-        const value = index < 0 ? undefined : args[index + 1];
-        if (value === undefined)
-            return undefined;
-        const fixed = /^fixed:([1-9]\d*)$/u.exec(value);
-        if (fixed !== null)
-            return { mode: "fixed", count: Number(fixed[1]) };
-        const adaptive = /^adaptive:([1-9]\d*)$/u.exec(value);
-        if (adaptive !== null)
-            return { mode: "adaptive", max: Number(adaptive[1]) };
-        throw usageError(`Invalid execution strategy: ${value}.`);
-    })();
-    const retryLaneId = isRetry
-        ? store.getTurn(item.taskId, cliTaskRecordReference(args[3], "turn", environment).localId)?.executionLaneId
-        : undefined;
-    const plan = normalizedExecutionLanePlan({
-        assignee: item.assignee ?? "",
-        requestedRoles: roles,
-        requestedStrategy,
-        existingGroup: group === undefined ? undefined : group,
-        resolvedRetryGroup: isDispatch
-            ? resolvedExecutionStageRetryGroup(currentGroup)
-            : undefined,
-        status: item.status,
-        nextGroupId: `execution-group-${store.peekNextTurnId(item.taskId)}`,
-        retryLaneId,
-        phase: isRetry ? "retry" : "dispatch"
-    });
-    const laneRoles = plan.roles;
-    if (!isRetry && laneRoles.length === 0) {
-        throw usageError("At least one --lane-role is required when expanding an ExecutionGroup.");
-    }
-    if (group !== undefined && requestedStrategy !== undefined) {
-        const same = group.strategy.mode === requestedStrategy.mode
-            && (group.strategy.mode === "fixed"
-                ? requestedStrategy.mode === "fixed" && group.strategy.count === requestedStrategy.count
-                : requestedStrategy.mode === "adaptive" && group.strategy.max === requestedStrategy.max);
-        if (!same)
-            throw usageError(`ExecutionGroup strategy is frozen: ${group.id}.`);
-    }
-    const laneCount = plan.requestedCount;
-    const adaptive = plan.strategy.mode === "adaptive";
-    const needsIsolation = adaptive || laneCount > 1 || (group?.lanes.length ?? 0) > 1;
-    if (!needsIsolation)
+    const plan = workItemDispatchLanePlan(args, store, item);
+    if (plan.roles.length === 0)
         return undefined;
-    const groupId = group?.id ?? `execution-group-${store.peekNextTurnId(item.taskId)}`;
-    const laneIds = plan.laneIds;
-    // A new Group's Lanes are not yet durable, so their worktrees would be
-    // unadopted between preparation and the dispatch transaction. Hold ONE
-    // per-Project maintenance fence across both, so a project migrate cannot
-    // switch the catalog in that gap and strand a Lane on the external
-    // checkout. An existing Group's Lanes are adopted inside their own fence,
-    // so no outer fence is held.
-    const held = group === undefined
-        ? preparer.acquireTaskProjectMaintenanceLocks(item.taskId)
-        : undefined;
+    for (const roleName of plan.roles) {
+        if (store.getRole(item.taskId, roleName) === null) {
+            throw usageError(`Task Role not found: ${item.taskId}/${roleName}.`);
+        }
+        if (store.getActiveTurn(item.taskId, roleName) !== null) {
+            throw usageError(`${item.taskId}/${roleName} already has an active turn.`);
+        }
+    }
+    const held = preparer.acquireTaskProjectMaintenanceLocks(item.taskId);
     const map = new Map();
     try {
-        let projectPaths;
-        if (held !== undefined) {
-            const paths = new Map();
-            for (const { projectId } of held.current.projectBindings) {
-                const project = store.getProject(projectId);
-                if (project === null)
-                    throw new Error(`Project not found: ${projectId}.`);
-                paths.set(projectId, project.path);
-            }
-            projectPaths = paths;
+        const projectPaths = new Map();
+        for (const { projectId } of held.current.projectBindings) {
+            const project = store.getProject(projectId);
+            if (project === null)
+                throw new Error(`Project not found: ${projectId}.`);
+            projectPaths.set(projectId, project.path);
         }
-        for (const laneId of laneIds.filter((value) => value.length > 0)) {
-            map.set(laneId, await preparer.prepareExecutionLaneWorkspace(item.taskId, groupId, laneId, {
-                purpose: "execution",
-                workItemId: item.id
-            }, held === undefined ? undefined : { current: held.current }));
+        const source = item.assignee === "leader"
+            ? store.getTaskWorkspace(item.taskId)
+            : store.getWorkItemWorkspace(item.taskId, item.id);
+        if (source === null) {
+            throw usageError(`Execution Lane source workspace is not ready: ${item.id}.`);
         }
-        return { workspaces: map, release: held?.release, projectPaths };
+        const inputHeads = await preparer.snapshotExecutionLaneInputHeads(source, item.writeProjectIds);
+        for (const laneId of plan.laneIds) {
+            map.set(laneId, await preparer.prepareExecutionLaneWorkspace(item.taskId, plan.groupId, laneId, { purpose: "execution", workItemId: item.id, inputHeads }, { current: held.current }));
+        }
+        return { workspaces: map, release: held.release, projectPaths };
     }
     catch (error) {
-        // Compensate (discard unadopted Lane worktrees) BEFORE releasing the
-        // fence: a concurrent project migrate must not switch the catalog while
-        // external-backed worktrees are still identifiable for removal.
         await preparer.discardUnadoptedExecutionLaneWorkspaces(map);
-        if (held !== undefined)
-            held.release();
+        held.release();
         throw error;
     }
 }
+function workItemDispatchLanePlan(args, store, item) {
+    if (item.assignee === undefined) {
+        throw usageError(`Work Item has no Task Role assignee: ${item.id}.`);
+    }
+    const roles = args.flatMap((value, index) => (value === "--lane-role" && args[index + 1] !== undefined
+        ? [args[index + 1]]
+        : []));
+    const groupId = `execution-group-${store.peekNextTurnId(item.taskId)}`;
+    return {
+        groupId,
+        ...planReplicatedWorkItemLanes(item.assignee, roles, groupId)
+    };
+}
 async function prepareReviewLaneWorkspaces(taskId, reviewRoundId, store, preparer) {
     const round = store.getReviewRound(taskId, reviewRoundId);
     const group = round?.executionGroup;
     if (round === null || round === undefined || group === undefined)
         return undefined;
-    if (group.lanes.length < 2 && group.strategy.mode !== "adaptive")
-        return undefined;
     const map = new Map();
     try {
-        for (const lane of group.lanes.filter((candidate) => candidate.status === "pending" || candidate.status === "running")) {
+        for (const lane of group.lanes.filter(({ disposition }) => disposition === "open")) {
             map.set(lane.id, await preparer.prepareExecutionLaneWorkspace(taskId, group.id, lane.id, {
                 purpose: "review",
                 reviewRoundId
@@ -1963,15 +1925,6 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
             taskId = reference.taskId;
         }
     }
-    else if (args[1] === "review"
-        && args[2] === "force-fresh"
-        && args[3] !== undefined) {
-        const reference = cliTaskRecordReference(args[3], "reviewRound", environment);
-        const round = store.getReviewRound(reference.taskId, reference.localId);
-        if (round !== null && (round.scope ?? "work-item") === "task") {
-            taskId = reference.taskId;
-        }
-    }
     else if (args[1] === "work"
         && args[2] === "review"
         && args[3] === "retry"
@@ -1996,12 +1949,21 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
             taskId = reference.taskId;
         }
     }
-    else if ((args[1] === "context" || args[1] === "next-action")
+    else if (args[1] === "archive"
+        && args[2] !== undefined
+        && args.includes("--integrated")) {
+        taskId = store.getTask(args[2])?.id;
+    }
+    else if ((args[1] === "show"
+        || args[1] === "context"
+        || args[1] === "next-action"
+        || args[1] === "remote-delivery")
         && args[2] !== undefined) {
         taskId = store.getTask(args[2])?.id;
         decisionSupportRead = true;
     }
-    if (taskId === undefined || store.getTask(taskId)?.status !== "active")
+    const status = taskId === undefined ? undefined : store.getTask(taskId)?.status;
+    if (taskId === undefined || (status !== "active" && status !== "retired"))
         return undefined;
     try {
         return await snapshotActualTaskReviewCandidate(taskId, store, preparer);
@@ -2019,6 +1981,9 @@ async function snapshotActualTaskReviewCandidate(taskId, store, preparer) {
     if (task.projectBindings.length === 0) {
         throw usageError(`Final Task Review requires a Project-backed Task: ${task.id}.`);
     }
+    // Reconcile the durable currentCommit facts from the authoritative Task
+    // clones before freezing a completion/review candidate.
+    await preparer.prepareTaskWorkspace(task.id);
     const workspace = store.getTaskWorkspace(task.id);
     if (workspace === null
         || workspace.owner.type !== "task"
@@ -2068,19 +2033,23 @@ async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReview
     // a head (a full Review or an equivalent-and-accepted delta).  A
     // non-accepted delta cannot be the base for a new delta.
     const previous = [...store.listReviewRounds(task.id)]
-        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
+        .filter((round) => isCompletedTaskReviewEvidence(store, round))
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
         .at(-1);
     if (previous === undefined) {
         throw usageError("Delta-recheck requires a previous completed Task-final Review that accepted a head.");
     }
     const repositoryPaths = {};
+    const taskWorkspace = store.getTaskWorkspace(task.id);
+    if (taskWorkspace === null || taskWorkspace.owner.type !== "task") {
+        throw usageError(`Task has no authoritative main workspace: ${task.id}.`);
+    }
     for (const candidateProject of actualTaskReviewCandidate.projects) {
-        const project = store.getProject(candidateProject.projectId);
-        if (project === null) {
-            throw usageError(`Delta-recheck Project not found: ${candidateProject.projectId}.`);
+        const entry = workspaceProjectEntry(taskWorkspace, candidateProject.projectId);
+        if (entry === undefined) {
+            throw usageError(`Delta-recheck Task workspace Project not found: ${candidateProject.projectId}.`);
         }
-        repositoryPaths[candidateProject.projectId] = project.path;
+        repositoryPaths[candidateProject.projectId] = entry.path;
     }
     const assessment = await assessDeltaRecheck({
         repositoryPaths,
@@ -2317,6 +2286,51 @@ function selectionPorts(store, catalogs) {
     };
 }
 async function preflightAgentConfigurationMutation(commandArgs, store, catalogs) {
+    const mutation = profileAgentConfigurationMutation(commandArgs, store)
+        ?? taskRoleAgentConfigurationMutation(commandArgs, store);
+    if (mutation === undefined) {
+        await warmLegacyRoleConfigurationMutation(commandArgs, store, catalogs);
+        return undefined;
+    }
+    const agent = store.getConfiguredAgent(mutation.agentId);
+    if (agent === null)
+        throw agentNotFound(mutation.agentId);
+    const resolved = await catalogs.resolve({
+        agent,
+        cwd: mutation.cwd,
+        config: mutation.config
+    });
+    try {
+        validateAgentLaunchConfiguration(resolved.catalog, mutation.config);
+    }
+    catch (error) {
+        throw usageError(error instanceof Error ? error.message : String(error));
+    }
+    return (candidate) => {
+        if (candidate.agentId !== mutation.agentId
+            || resolve(candidate.cwd) !== resolve(mutation.cwd)
+            || !isDeepStrictEqual(candidate.config, mutation.config)) {
+            throw usageError("Agent configuration changed after capability preflight; retry the command.");
+        }
+        try {
+            validateAgentLaunchConfiguration(resolved.catalog, candidate.config);
+        }
+        catch (error) {
+            throw usageError(error instanceof Error ? error.message : String(error));
+        }
+    };
+}
+function profileAgentConfigurationMutation(args, store) {
+    return args[0] === "config" && args[1] === "profile"
+        ? previewProfileAgentConfigurationMutation(args.slice(2), store)
+        : undefined;
+}
+function taskRoleAgentConfigurationMutation(args, store) {
+    return args[0] === "task"
+        ? previewTaskRoleAgentConfigurationMutation(args.slice(1), store)
+        : undefined;
+}
+async function warmLegacyRoleConfigurationMutation(commandArgs, store, catalogs) {
     if (!hasModelOrEffortMutation(commandArgs))
         return;
     const agentId = configurationMutationAgentId(commandArgs, store);
@@ -2380,8 +2394,11 @@ function selectionCall(store, catalogs, method, params) {
             });
         }
         case "config.get": return store.getConfig();
-        case "profile.list": return store.listAgentProfiles();
-        case "profile.show": return store.getAgentProfile(String(params.id ?? ""));
+        case "profile.list": return store.listAgentProfiles().map((profile) => profileSelectionRecord(profile, store));
+        case "profile.show": {
+            const profile = store.getAgentProfile(String(params.id ?? ""));
+            return profile === null ? null : profileSelectionRecord(profile, store);
+        }
         case "role.list": return store.listGlobalRoles();
         case "role.show": return store.getGlobalRole(String(params.name ?? ""));
         case "project.list": return callOptional(reader, "listProjects");
@@ -2391,6 +2408,7 @@ function selectionCall(store, catalogs, method, params) {
         case "task.role.list": return callOptional(reader, "listRoles", [params.taskId]);
         case "task.role.show": return callOptional(reader, "getRole", [params.taskId, params.roleName]);
         case "task.work.list": return callOptional(reader, "listWorkItems", [params.taskId]);
+        case "task.message.list": return callOptional(reader, "listMessages", [params.taskId]);
         case "task.input.list": {
             const taskId = typeof params.taskId === "string" ? params.taskId : undefined;
             const requests = taskId === undefined
@@ -2406,6 +2424,25 @@ function selectionCall(store, catalogs, method, params) {
         default: return [];
     }
 }
+function profileSelectionRecord(profile, store) {
+    const view = resolveAgentProfileView(profile, store);
+    return {
+        ...view.profile,
+        runtimeSource: view.runtime.source,
+        ...(view.runtime.source === "global-worker"
+            ? { workerRevision: view.runtime.workerRevision }
+            : {}),
+        effectiveRuntime: view.runtime,
+        ...(view.runtime.status === "resolved"
+            ? {
+                agentId: view.runtime.binding.agentId,
+                adapterId: view.runtime.binding.adapterId,
+                model: view.runtime.binding.config.model,
+                effort: view.runtime.binding.config.effort
+            }
+            : {})
+    };
+}
 function presentSelectionTimes(value, store) {
     if (!Array.isArray(value))
         return value;