@zq-silk/yui 0.11.2 → 0.12.0

package/ARCHITECTURE.md

@@ -19,6 +19,16 @@ units. For a feature, the Leader judges whether the whole result is small
 enough to own in the same way or large enough to need independently owned
 delivery units.
 
+Operator updates have one durable path. Domain and runtime transitions first
+append an immutable TaskEvent; user-owned questions append an InputRequest.
+Only those record references enter the global Operator mailbox. The Controller
+batches pending references into one receipt-backed synthetic user message for
+the existing interactive Operator and defers the complete batch while that
+Operator is busy or unavailable. The message carries CLI read pointers rather
+than copied Task or Provider narrative. No lower layer calls the Operator, no
+mutable notification projection duplicates the event history, and no Goal or
+polling protocol is required to follow work.
+
 `WorkItem` means one substantial, independently acceptable requirement with a
 clear owner. Create multiple WorkItems only when multiple Workers can own and
 advance those requirements independently, normally in parallel. Internal
@@ -128,10 +138,14 @@ late results until explicitly reopened.
 
 Stable Project checkouts are read-only references. Task identity follows one
 bounded outcome rather than Project count. A Task binds zero or more Projects,
-records an independent base ref for each binding, and owns one workspace root
-containing a managed main worktree for each binding. The
-`<workspace>/tasks/<task>/main` root is a logical multi-Project container, not a
-Git repository. Each Project child (for example
+records an independent base ref for each binding, and adopts one workspace root
+only when it becomes active. A Draft owns planning state and Project bindings,
+not a writable Workspace. Activation prepares physical worktrees first and then
+commits status, workspace identity, cwd, and durable Workspace ownership in one
+TaskStore transaction; failure discards unadopted resources and leaves the Task
+Draft. The active Workspace contains a managed main worktree for each binding.
+The `<workspace>/tasks/<task>/main` root is a logical multi-Project container,
+not a Git repository. Each Project child (for example
 `<workspace>/tasks/<task>/main/yui`) is the supported Git cwd and points to
 `<workspace>/worktree/<project>/<task>/main`; Git commands run in that child.
 For a single-Project workspace, the native Agent starts in that Project's
@@ -142,6 +156,11 @@ additional-directory mechanism. The active Leader may append a Project when the
 same outcome expands; replacing an existing binding is not a scope-repair
 mechanism.
 
+Before a Role launch, Yui verifies that every physical Project HEAD still
+descends from its Workspace's recorded base. Normal committed progress is
+allowed; a reset or repoint outside that lineage is reported as
+`physical-drift` and fails closed before Provider launch.
+
 A WorkItem can read the full Task workspace but has an explicit Project write
 scope. Isolation creates a second root with independent worktrees for writable
 Projects and Task-main context for the rest. The managed dispatch and

package/README.md

@@ -274,6 +274,12 @@ yui task context <task-id>
 yui task activate <task-id>
 ```
 
+A Draft stores planning state and Project bindings only; it does not adopt a
+writable managed Workspace. `task activate` prepares every bound Project first,
+then commits the Task's `active` status and Task-owned Workspace together. A
+preparation or consistency failure leaves the Task Draft and reports the
+workspace diagnosis instead of exposing a partially adopted execution root.
+
 Task type describes intent rather than selecting an execution protocol.
 Software Projects use `bugfix` or `feature`: a bugfix is Leader-owned; if it
 grows into independently owned delivery requirements, reclassify it as a
@@ -294,6 +300,49 @@ files as dirty, preserves ignored files, and refuses missing remotes or refs and
 When the configured branch is `HEAD`, refresh resolves the remote's symbolic default branch for that
 operation and requires the checkout to be on that branch; detached or mismatched checkouts fail.
 
+### Project lifecycle
+
+Divergence and end-of-life are explicit, Operator-authority operations with fail-closed gates.
+Every destructive command refuses a managed Task Session (run it from an Operator or user
+terminal), an active Task binding, a dirty checkout, and an unreachable or unverified remote.
+
+```sh
+yui project diagnose app
+yui project reset app
+yui project reset app --discard-local
+yui project replace app --discard-local
+yui project retire app --reason "superseded by app-ng"
+yui project delete app --confirm app
+yui project delete app --checkout --confirm app
+```
+
+`project reset` handles the divergence `project refresh` refuses. Without `--discard-local` it is
+a dry run: it fetches and verifies the remote baseline, and when the checkout has diverged it
+refuses while listing the exact local commits that would be discarded. With `--discard-local` it
+hard-resets the clean checkout to the verified remote commit (a plain fast-forward when the
+checkout is merely behind). `project replace` goes further for Home-managed checkouts: it clones
+the remote into a staging directory, verifies both branches, copies the Yui-local refs
+(`refs/heads/yui/`, `refs/yui/archive/`) so historical evidence keeps resolving, then swaps the
+checkout on disk while the catalog record keeps its path. Replace refuses linked worktrees (Task
+or Integration workspaces) and dirty checkouts, and requires `--discard-local`. The swap is
+recoverable: the previous checkout is parked at a backup path and restored on any failure, a
+catalog refusal rolls the swap back, and a crash mid-swap is healed on the next run (a crash
+before the swap leaves only a removable staging clone).
+
+`project retire` is the auditable soft deprecation: it records who retired the Project, when, and
+why, while retaining the catalog record, checkout, and every historical
+Task/Run/Review/Integration/Publication reference. A retired Project cannot be refreshed,
+updated, migrated, reset, replaced, maintained through Knowledge writes (add/retire/propose/
+accept/reject), or bound to new Tasks, WorkItems, or Integrations; Knowledge reads (`list`,
+`show`, `proposals list/show`) stay open so the evidence stays auditable.
+`project delete` is the separate hard-removal decision: it requires a retired Project, an exact
+`--confirm <project-id>` acknowledgment, and fails closed while any Task record references the
+Project. `--checkout` additionally removes the Home-managed checkout (external checkouts are
+user-owned and must be removed manually): it first refuses linked worktrees and dirty checkouts,
+then moves the checkout to a tombstone before removing the catalog record, restoring it on any
+failure so the catalog and checkout never disagree unrecoverably. `project show` and
+`project list` display the lifecycle status and retirement record.
+
 Use `task context` as the first detailed read of an existing Task. It combines the Task, Brief, active Decisions, recent Milestones, Roles, current and recent WorkItems with their Runs, recent Messages, open and resolved InputRequests, and recent Events. Terminal output keeps histories and long text compact; `yui --json task context <task-id>` returns the complete records in the top-level `data` field.
 
 Leader wakeups stay deliberately small: the wake envelope carries only the
@@ -347,14 +396,16 @@ acceptance so the Leader can accept it directly or run
 Leader-managed candidates awaiting a decision instead of marking them done.
 `final` does not create WorkItem ReviewRounds or decide Task topology. The
 Leader explicitly requests a Task-scoped Review, unless an immutable Task
-contract requires one. The Round freezes Task main directly, so even a
-Leader-owned Task with no WorkItem can be reviewed. A changed frozen head needs
-a new semantic Round; the same compatible Reviewer Session may continue in its
+contract requires one. The Round snapshots the exact Task-main Project heads
+directly, so even a Leader-owned Task with no WorkItem can be reviewed without
+locking the mutable Task workspace. A changed frozen head needs a new semantic
+Round; the same Reviewer Session continues in its
 stable workspace, while every Run remains bound to its exact Round and head.
 The Reviewer follows Project Policy/Knowledge and reports reachable, material,
 actionable findings across the complete Task.
-A ReviewRound freezes the Candidate's exact Git commit and creates a fresh,
-ReviewRound-owned writable worktree on a unique branch. Its AgentRun may edit,
+A ReviewRound freezes the Candidate's exact Git commit and updates the
+Reviewer Role's stable writable workspace to that head while recording exact
+Round-owned workspace evidence. Its AgentRun may edit,
 test, and optionally commit diagnostic evidence there, but never changes the
 Candidate or Worker workspace and never creates another WorkItem, Candidate,
 ChangeSet, or recursive review. The result wakes the Leader, who decides whether
@@ -362,6 +413,17 @@ to route evidence to the original Worker, accept, reject and redispatch that
 Worker in its existing Session, review again, or request user input.
 A failed review remains visible evidence and wakes the Leader, but does not
 take that decision away from the Leader.
+Task context and next-action expose direct Review facts: every frozen Project
+commit, its relation to the current candidate, the active Run, and the Reviewer
+workspace. A request that fails after Round creation retains the ReviewRound
+and reports its exact reason; the Leader opens that Round and decides whether
+to retry, inspect or clean the workspace, use another Reviewer, or continue
+other work.
+An active Task-final Review freezes only its own candidate; it does not prevent
+the Leader from processing new input or advancing a later candidate. Delta
+Recheck is always available when Yui can prove an accepted contiguous baseline
+and exact diff. Yui does not select a mode from generic size thresholds;
+`requires-full-review` returns to the Leader without creating another Round.
 Candidate history, every ReviewRound, and the Leader decision remain grouped
 under the original WorkItem. A rejected result creates a new Candidate on the
 next dispatch while reusing the original execution Role, Session, and
@@ -551,11 +613,14 @@ Every stage is a new immutable ExecutionGroup. Its ContextSnapshot and selected
 parent Lane results are durable references; `retry` repeats a stage within its
 attempt budget, while `retry` at Resolve begins the next bounded round.
 
-Each new stage also freezes one Resource Broker contract: token, tool-call and
-wall-clock budgets; quorum and deadline; a straggler window; and the minimum
-marginal value for more Lane spend. Omitted values reuse the existing context
-budget and runtime-health windows; stage retries share the original cumulative
-spend and absolute deadline. Execution, Lane retry, and Reviewer-panel
+Each new stage also freezes one Resource Broker contract: behavioral tool-call
+and wall-clock budgets; a display-only token threshold; quorum and deadline; a
+straggler window; and the minimum marginal value for more Lane spend. Omitted
+values reuse the existing context budget and runtime-health windows; stage
+retries share the original cumulative observations and absolute deadline.
+Observed token totals and the configured token threshold are cost context only:
+they never close spend, block admission, suppress scheduling, or stop a Lane.
+Execution, Lane retry, and Reviewer-panel
 admission all count active Lanes at Home, Task, WorkItem, Group, Provider,
 Agent, and model scopes. Capacity pressure keeps the excess Lane durably
 pending instead of failing the Group. Capacity release or deadline arrival
@@ -570,8 +635,9 @@ The Leader may add `--early-stop <0-100>` to an accepting Group resolution.
 Yui permits it only after quorum and T5's passed Verify/Resolve evidence prove
 sufficiency. It may skip Lanes that never started; active stragglers are
 reported and retained, never killed automatically for cost. If evidence is
-insufficient, budget or deadline exhaustion blocks the stage for Leader
-judgment instead of turning thin evidence into success.
+insufficient, behavioral tool-call/wall-clock budget or deadline exhaustion
+blocks the stage for Leader judgment instead of turning thin evidence into
+success.
 
 New exploration histories also freeze the structured candidate-convergence
 contract. Yui appends the exact stage-local JSON shape to every Lane assignment
@@ -749,7 +815,7 @@ yui task input request <task-id> --question "Which format should be the default?
 
 The recommendation is shown to the user. If no answer arrives, the nearest-deadline timer wakes the Controller to atomically apply that exact choice and queue the fixed Leader session to resume. Free-text and user-required requests never auto-resolve.
 
-`task input list` is the authoritative global open-input Inbox; add a Task ID to scope it, or `--all` to include answered and cancelled requests. The Controller also makes one receipt-backed, best-effort delivery to an already-running Operator process. It never starts or interrupts an Operator for this notification; unavailable process state or a changed pane fence falls back to the durable Inbox and is reconsidered on a later Controller pass. It does not inspect or classify Agent terminal text. Answers may be submitted by the user or Operator. An open request prevents unrelated pending wakes and Task completion or archival. The originating Leader may instead run `yui task input cancel <task-id> <input-id> --reason "..."`; cancellation queues that fixed Leader session to resume.
+`task input list` is the authoritative global open-input Inbox; add a Task ID to scope it, or `--all` to include answered and cancelled requests. Task completion, retirement, Leader attention, stalls, and open input are queued to the global Operator mailbox only as immutable TaskEvent or InputRequest references. The Controller merges one pending mailbox batch into one receipt-backed `[Yui updates]` user message for an existing ready Operator; the Operator reads the referenced records through the CLI and decides what is worth presenting. A running or unavailable Operator is never started or interrupted: the whole batch remains durable and is retried after native turn completion or a later Controller pass. This path is a user message, not a tool call, and it never inspects or classifies Agent terminal text. Answers may be submitted by the user or Operator. An open request prevents unrelated pending wakes and Task completion or archival. The originating Leader may instead run `yui task input cancel <task-id> <input-id> --reason "..."`; cancellation queues that fixed Leader session to resume.
 
 Inspect the result:
 
@@ -1011,6 +1077,7 @@ yui config completion [bash|zsh|fish]
 yui session enter|record|replace|reconcile
 yui session stop --all
 yui project add|clone|refresh|update|discover|list|show|knowledge
+yui project reset|replace|retire|delete
 ```
 
 `yui update` stages the newly published package **side by side** — it never

package/dist/cli/commandCatalog.js

@@ -59,8 +59,7 @@ function durableConfigDomainNode(domain) {
     const values = CONFIG_KEY_VALUES.filter(({ name }) => keys.includes(name));
     const options = domain === "workflow"
         ? [
-            "--soft-tokens", "--hard-tokens", "--role", "--trigger", "--finding-ledger",
-            "--delta-recheck", "--delta-recheck-max-lines", "--delta-recheck-max-files"
+            "--soft-tokens", "--hard-tokens", "--role", "--trigger", "--finding-ledger"
         ]
         : domain === "runtime"
             ? ["--quiet-after-seconds", "--diagnostic-after-seconds", "--stall-after-seconds"]
@@ -86,8 +85,7 @@ function durableConfigDomainNode(domain) {
                 optionValues: domain === "workflow"
                     ? {
                         "--trigger": ["always", "leader", "final"],
-                        "--finding-ledger": ["shadow", "enforce"],
-                        "--delta-recheck": ["enabled", "disabled"]
+                        "--finding-ledger": ["shadow", "enforce"]
                     }
                     : {}
             },
@@ -1260,7 +1258,10 @@ export const ROOT_COMMAND = buildNode({
         {
             name: "project",
             summary: "Manage Projects, stable checkouts, branches, and Yui knowledge.",
-            sections: [{ id: "manage", title: "Commands", entries: ["add", "clone", "refresh", "diagnose", "migrate", "update", "discover", "list", "show", "knowledge"] }],
+            sections: [
+                { id: "manage", title: "Commands", entries: ["add", "clone", "refresh", "diagnose", "migrate", "update", "discover", "list", "show", "knowledge"] },
+                { id: "lifecycle", title: "Lifecycle (Operator authority)", entries: ["reset", "replace", "retire", "delete"] }
+            ],
             children: [
                 {
                     name: "add",
@@ -1291,6 +1292,30 @@ export const ROOT_COMMAND = buildNode({
                     usage: "yui project migrate <project> [--preflight]",
                     options: ["--preflight"]
                 },
+                {
+                    name: "reset",
+                    summary: "Hard-reset a canonical checkout to its verified remote baseline (Operator authority).",
+                    usage: "yui project reset <project> [--discard-local]",
+                    options: ["--discard-local"]
+                },
+                {
+                    name: "replace",
+                    summary: "Re-clone a Home-managed checkout from its remote, preserving Yui refs (Operator authority).",
+                    usage: "yui project replace <project> --discard-local",
+                    options: ["--discard-local"]
+                },
+                {
+                    name: "retire",
+                    summary: "Soft-deprecate a Project; record and evidence are retained (Operator authority).",
+                    usage: "yui project retire <project> --reason <text>",
+                    options: ["--reason"]
+                },
+                {
+                    name: "delete",
+                    summary: "Remove a retired Project's catalog record and optionally its checkout (Operator authority).",
+                    usage: "yui project delete <project> [--checkout] --confirm <project-id>",
+                    options: ["--checkout", "--confirm"]
+                },
                 {
                     name: "update",
                     summary: "Update a bound Project's aliases, remote, or branch refs.",

package/dist/cli.js

@@ -37,7 +37,7 @@ 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, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, parseTaskFinalReviewContractRebindRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, resolvedExecutionStageRetryGroup, validateTaskArchiveRequest } from "./commands/taskCommands.js";
+import { dispatchPreparedReviewRound, failPendingReviewRound, preserveReviewRoundWorkspace, parseTaskCompletionRequest, parseTaskFinalReviewContractRebindRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, resolvedExecutionStageRetryGroup, validateTaskArchiveRequest } from "./commands/taskCommands.js";
 import { taskActor } from "./commands/taskActor.js";
 import { isCurrentGlobalOperator } from "./commands/taskInputCommands.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
@@ -49,6 +49,7 @@ import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { createUpdatePorts } from "./cli/updatePorts.js";
 import { createReleaseWorkflowPorts } from "./release/releaseWorkflowPorts.js";
 import { acquireHandoverLock, readRuntimeIdentity } from "./release/runtimeRelease.js";
+import { assertCliHomeReleaseFence, describeCliHomeInvocation } from "./release/cliHomeReleaseFence.js";
 import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, resolveReleaseActivationDriver, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
 import { reconcileTaskRemoteBaselines, verifyTaskCompletionPublishedTree } from "./commands/taskCompletionGate.js";
 import { runTaskBaseStatusCommand } from "./commands/taskBaseCommands.js";
@@ -68,7 +69,7 @@ import { agentNotFound, CliError, runtimeError, usageError } from "./errors/cliE
 import { FileRoleLaunchPlanner } from "./executor/fileRoleLaunchPlanner.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, runAgentHost, sendAgentHostAuthorityControl } from "./runtime/agentHost.js";
 import { TaskWorkspaceCoordinator, WorkspaceCleanupBlockedError } from "./repository/taskWorkspaceCoordinator.js";
-import { FileTaskWorkspacePreparer, ReviewRoundWorkspaceEvidenceError } from "./repository/taskWorkspacePreparer.js";
+import { FileTaskWorkspacePreparer } from "./repository/taskWorkspacePreparer.js";
 import { inspectStorageSchema } from "./storage/storageSchema.js";
 import { collectRuntimeBuildIdentity, collectStorageIdentity, countDroppedInboxEvents, createProductionRuntimeIdentityPorts, evaluateStorageHealth, resolveStatusIdentityEnabled } from "./observability/runtimeIdentity.js";
 import { resolveYuiHome } from "./storage/taskStore.js";
@@ -83,13 +84,14 @@ import { AgentConfigurationCatalogService } from "./executor/agentConfigurationC
 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 { readSessionBootstrapManifest, refreshManagedSessionCliWrappers } from "./context/sessionBootstrapManifest.js";
 import { builtinAgentDriverRegistry } from "./runtime/builtinAgentDrivers.js";
 import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./review/taskFinalReviewContract.js";
 import { prepareTaskFinalReviewContractRebindProof, resolveRecordedTaskFinalReviewContract } from "./review/taskFinalReviewContractRebind.js";
 import { assessDeltaRecheck } from "./review/deltaRecheck.js";
-import { deltaRecheckEnabled } from "./review/reviewConfig.js";
+import { isAcceptedTaskReviewBaseline } from "./review/reviewAcceptance.js";
 import { NodeGitWorkspace } from "./repository/gitWorkspace.js";
 import { currentWorkItemExecutionGroup, workItemExecutionGroupById } from "./workItem/workItem.js";
 const VERSION = YUI_VERSION;
@@ -107,13 +109,47 @@ void main().catch((error) => {
         process.exitCode = error.exitCode;
         return;
     }
-    const message = error instanceof Error ? error.message : String(error);
+    const message = runtimeFailureMessage(error);
     process.stderr.write(`${jsonOutput
         ? JSON.stringify({ ok: false, code: "RUNTIME_ERROR", message, details: {} })
         : `RUNTIME_ERROR: ${message}`}\n`);
     process.exitCode = 5;
 });
+function runtimeFailureMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!(error instanceof SqliteSchemaMigrationError))
+        return message;
+    try {
+        return `${message}\n${describeCliHomeInvocation({
+            home: resolveYuiHome(process.env),
+            packageRoot: fileURLToPath(new URL("../", import.meta.url)),
+            entryPath: fileURLToPath(import.meta.url)
+        })}`;
+    }
+    catch {
+        return message;
+    }
+}
 export async function main() {
+    const home = resolveYuiHome(process.env);
+    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;
+    const homeFreeInvocation = args.length === 0
+        || (args[0] === "version" && args.length === 1)
+        || routedForFence?.kind === "help"
+        || routedForFence?.kind === "path-error"
+        || routedForFence?.kind === "incomplete";
+    if (managedInvocation || !homeFreeInvocation) {
+        assertCliHomeReleaseFence({
+            home,
+            packageRoot: fileURLToPath(new URL("../", import.meta.url)),
+            entryPath: fileURLToPath(import.meta.url),
+            args
+        });
+    }
     const delegatedDriver = explicitReleaseActivationDriver();
     if (delegatedDriver !== null) {
         const delegated = spawnSync(process.execPath, [delegatedDriver, ...process.argv.slice(2)], {
@@ -160,7 +196,6 @@ export async function main() {
         process.exitCode = runUpdateCommand();
         return;
     }
-    const home = resolveYuiHome(process.env);
     if (args[0] === "release") {
         const subcommand = args[1];
         if (subcommand === "install" && args.length === 3) {
@@ -1123,14 +1158,16 @@ export async function main() {
             const laneSnapshotPreflight = executionLaneGitSnapshot === undefined
                 ? undefined
                 : executionLaneGitSnapshot;
-            // RFC Phase 3: prepare the Task workspace before activation so a
-            // preparation failure keeps the Task in Draft instead of leaving it
-            // Active without a workspace.
-            if (resolved[1] === "activate") {
+            // Physical preparation may precede the durable write, but Task status,
+            // workspace identity/cwd, and ManagedWorkspace ownership are adopted by
+            // one transaction. A failed attempt therefore leaves the Task Draft and
+            // owning no writable workspace.
+            let taskWorkspaceActivation;
+            if (resolved[1] === "activate" && resolved.length === 3) {
                 const taskId = resolved[2];
                 const task = taskId === undefined ? null : store.getTask(taskId);
                 if (task !== null && task.status === "draft") {
-                    await workspacePreparer.prepareTaskWorkspace(task.id);
+                    taskWorkspaceActivation = await workspacePreparer.activateTaskWorkspace(task.id);
                 }
             }
             const result = runTaskCommand(resolved.slice(1), store, {
@@ -1153,6 +1190,7 @@ export async function main() {
                     ? {}
                     : { candidateWorkspace: candidateMaterialization.workspace ?? null }),
                 ...(executionLaneWorkspaces === undefined ? {} : { executionLaneWorkspaces }),
+                ...(taskWorkspaceActivation === undefined ? {} : { taskWorkspaceActivation }),
                 ...(laneDispatchProjectPaths === undefined ? {} : { laneDispatchProjectPaths }),
                 ...(directTaskMainSnapshot === undefined ? {} : { directTaskMainSnapshot }),
                 ...(actualTaskReviewCandidate === undefined
@@ -1219,31 +1257,54 @@ export async function main() {
                             ...(storedRound?.deltaRecheck === undefined
                                 || deltaRecheckPreflight === undefined
                                 ? {}
-                                : { deltaRecheckDiff: deltaRecheckPreflight.diffByProject })
+                                : {
+                                    deltaRecheckDiff: deltaRecheckPreflight.diffByProject
+                                })
                         });
                         reviewOutput = run === null
                             ? `Review ${requestedRound.id} retained pending by Resource Broker\n`
                             : `Review queued as ${requestedRound.id} (${run.id})\n`;
                         reviewData = {
+                            reviewRequest: run === null
+                                ? {
+                                    kind: "busy",
+                                    reviewerRoleName: requestedRound.reviewerRoleName,
+                                    phase: "resource-broker",
+                                    activeReviewRoundId: requestedRound.id,
+                                    retryable: true,
+                                    retryAfterSeconds: 5
+                                }
+                                : {
+                                    kind: "started",
+                                    reviewerRoleName: requestedRound.reviewerRoleName,
+                                    reviewRoundId: requestedRound.id,
+                                    runId: run.id
+                                },
                             reviewRound: store.getReviewRound(requestedRound.taskId, requestedRound.id),
                             ...(run === null ? {} : { reviewRun: run }),
                             workspace
                         };
                     }
                     catch (error) {
-                        const currentRound = store.getReviewRound(requestedRound.taskId, requestedRound.id);
-                        if (requestedRound.resumedPendingFinalReview
-                            && !requestedRound.terminalizedLeaderRun
-                            && (error instanceof ReviewRoundWorkspaceEvidenceError
-                                || error instanceof TaskFinalReviewDispatchDriftError)
-                            && (currentRound?.scope ?? "work-item") === "task") {
-                            throw error;
-                        }
                         const message = error instanceof Error ? error.message : String(error);
                         await workspacePreparer.discardUnadoptedExecutionLaneWorkspaces(executionLaneWorkspaces);
-                        const failed = failPendingReviewRound(requestedRound.taskId, requestedRound.id, message, store, { runtime, environment: process.env, yuiHome: home });
-                        reviewOutput = `Review could not start: ${message}\n`;
-                        reviewData = { reviewRound: failed };
+                        const failed = failPendingReviewRound(requestedRound.taskId, requestedRound.id, message, store, {
+                            runtime,
+                            environment: process.env,
+                            yuiHome: home
+                        });
+                        reviewOutput = `Review could not start: ${message}\n`
+                            + "The failed ReviewRound was retained for Leader routing.\n";
+                        reviewData = {
+                            reviewRequest: {
+                                kind: "unavailable",
+                                reviewerRoleName: requestedRound.reviewerRoleName,
+                                reviewRoundId: failed.id,
+                                reason: message,
+                                retryable: true
+                            },
+                            reviewRound: failed
+                        };
                     }
                 }
                 if (resolved[1] === "project" && resolved[2] === "add") {
@@ -1906,6 +1967,7 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
     if (args[0] !== "task")
         return undefined;
     let taskId;
+    let decisionSupportRead = false;
     if (args[1] === "complete" && args[2] !== undefined) {
         const task = store.getTask(args[2]);
         if (task === null || task.status !== "active" || task.projectBindings.length === 0) {
@@ -1963,9 +2025,21 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
             taskId = reference.taskId;
         }
     }
+    else if ((args[1] === "context" || args[1] === "next-action")
+        && args[2] !== undefined) {
+        taskId = store.getTask(args[2])?.id;
+        decisionSupportRead = true;
+    }
     if (taskId === undefined || store.getTask(taskId)?.status !== "active")
         return undefined;
-    return snapshotActualTaskReviewCandidate(taskId, store, preparer);
+    try {
+        return await snapshotActualTaskReviewCandidate(taskId, store, preparer);
+    }
+    catch (error) {
+        if (decisionSupportRead && error instanceof CliError)
+            return undefined;
+        throw error;
+    }
 }
 async function snapshotActualTaskReviewCandidate(taskId, store, preparer) {
     const task = store.getTask(taskId);
@@ -2002,9 +2076,8 @@ async function snapshotActualTaskReviewCandidate(taskId, store, preparer) {
 /**
  * Issue 07: computes the delta-recheck assessment for `task review request
  * --delta-recheck`.  Runs only for that exact command; every other command
- * returns undefined.  The assessment's deterministic gates (contiguous base,
- * attempt thresholds, evidence-file overlap) fail closed here; the Reviewer
- * still owns the semantic equivalence decision.
+ * returns undefined. Technical evidence boundaries fail closed here; semantic
+ * risk remains a Leader and Project-policy decision.
  */
 async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReviewCandidate) {
     if (args[0] !== "task" || args[1] !== "review" || args[2] !== "request") {
@@ -2018,23 +2091,13 @@ async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReview
     const task = store.getTask(taskId);
     if (task === null || task.status !== "active")
         return undefined;
-    const config = store.getReviewConfig();
-    if (!deltaRecheckEnabled(config)) {
-        throw usageError("Delta-recheck is not enabled for this Project's review policy. "
-            + "Set `yui config workflow set review --role <role> --trigger final --delta-recheck enabled` "
-            + "or request a full Review.");
-    }
-    const reviewConfig = config;
     if (actualTaskReviewCandidate === undefined)
         return undefined;
     // The previous Round is the latest completed Task-final Round that accepted
     // 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) => ((round.scope ?? "work-item") === "task"
-        && round.status === "completed"
-        && (round.deltaRecheck === undefined
-            || round.deltaRecheck.disposition === "equivalent-and-accepted")))
+        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
         .at(-1);
     if (previous === undefined) {
@@ -2052,11 +2115,10 @@ async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReview
         repositoryPaths,
         previousRound: previous,
         candidate: actualTaskReviewCandidate,
-        git: new NodeGitWorkspace(),
-        config: reviewConfig
+        git: new NodeGitWorkspace()
     });
     if (assessment.kind === "ineligible") {
-        throw usageError(`Delta-recheck is not allowed: ${assessment.reason} Request a full Review instead.`);
+        throw usageError(`Delta-recheck is technically unavailable: ${assessment.reason}`);
     }
     return assessment.preflight;
 }
@@ -2115,13 +2177,13 @@ function reviewRoundFromCommandData(data) {
     const value = round;
     return typeof value.id === "string"
         && typeof value.taskId === "string"
+        && typeof value.reviewerRoleName === "string"
         && typeof value.status === "string"
         ? {
             id: value.id,
             taskId: value.taskId,
-            status: value.status,
-            resumedPendingFinalReview: data[RESUMED_PENDING_FINAL_REVIEW] === true,
-            terminalizedLeaderRun: data[TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW] === true
+            reviewerRoleName: value.reviewerRoleName,
+            status: value.status
         }
         : undefined;
 }