@zq-silk/yui 0.11.3 → 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
@@ -390,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
@@ -405,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
@@ -594,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
@@ -613,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
@@ -792,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:
 

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"]
                     }
                     : {}
             },

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;
 }

package/dist/commands/configCommands.js

@@ -1,11 +1,11 @@
 import { mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_CONTEXT_HARD_TOKENS, DEFAULT_CONTEXT_SOFT_TOKENS, DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, DEFAULT_PROVIDER_RETRY_MODE, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, PROVIDER_RETRY_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveProviderRetryAdapters, resolveProviderRetryDelaysSeconds, resolveProviderRetryMaxWindowSeconds, resolveProviderRetryMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, DEFAULT_PROVIDER_RETRY_MODE, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, PROVIDER_RETRY_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveProviderRetryAdapters, resolveProviderRetryDelaysSeconds, resolveProviderRetryMaxWindowSeconds, resolveProviderRetryMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { CONFIG_DEFINITIONS, CONFIG_KEYS, configDefinition, configDefinitionsForDomain } from "../config/configCatalog.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES, DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES, REVIEW_FINDING_LEDGER_MODES, REVIEW_DELTA_RECHECK_MODES, REVIEW_TRIGGERS } from "../review/reviewConfig.js";
+import { REVIEW_FINDING_LEDGER_MODES, REVIEW_TRIGGERS } from "../review/reviewConfig.js";
 /**
  * One uniform key model for every durable setting. Each catalog domain uses
  * the same show/set/clear contract; strategy settings such as `review` and
@@ -23,8 +23,7 @@ const RESOURCES_GC_AUTO_QUARANTINE_SET_USAGE = "Resources config set usage: yui
 const LEADER_NEXT_ACTION_SET_USAGE = `Workflow config set usage: yui config workflow set leader-next-action <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
 const CONTEXT_BUDGET_SET_USAGE = "Workflow config set usage: yui config workflow set context-budget [--soft-tokens <n>] [--hard-tokens <n>].";
 const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final> "
-    + "[--finding-ledger <shadow|enforce>] [--delta-recheck <enabled|disabled>] "
-    + "[--delta-recheck-max-lines <n>] [--delta-recheck-max-files <n>].";
+    + "[--finding-ledger <shadow|enforce>].";
 export function runConfigCommand(domain, args, store) {
     const keys = configDefinitionsForDomain(domain).map(({ key }) => key);
     const usage = `${capitalize(domain)} config usage: yui config ${domain} show | yui config ${domain} set <key> <value...> | yui config ${domain} clear <key>.`;
@@ -97,12 +96,7 @@ export function effectiveConfigData(config, domain) {
             : {
                 roleName: config.review.roleName,
                 trigger: config.review.trigger,
-                findingLedger: config.review.findingLedger ?? "shadow",
-                deltaRecheck: config.review.deltaRecheck ?? "disabled",
-                deltaRecheckMaxChangedLines: config.review.deltaRecheckMaxChangedLines
-                    ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES,
-                deltaRecheckMaxChangedFiles: config.review.deltaRecheckMaxChangedFiles
-                    ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES
+                findingLedger: config.review.findingLedger ?? "shadow"
             },
         completionInstallations: config.completionInstallations ?? {}
     };
@@ -175,14 +169,6 @@ function parseReconciliationIntervalSeconds(value) {
 function parseBooleanConfigValue(value) {
     return value === "true" ? true : value === "false" ? false : value;
 }
-function parsePositiveIntegerOption(value, usage) {
-    if (value === undefined)
-        return undefined;
-    if (!/^\d+$/.test(value) || Number(value) < 1) {
-        throw usageError(usage);
-    }
-    return Number(value);
-}
 const CONFIG_KEY_HANDLERS = [
     {
         key: "default-agent",
@@ -313,10 +299,10 @@ const CONFIG_KEY_HANDLERS = [
     },
     {
         key: "context-budget",
-        showLabel: "Context budget",
+        showLabel: "Legacy context budget (inactive)",
         showValue: (config) => {
             const budget = resolveContextBudget(config.contextBudget);
-            return `soft ${budget.softTokens} / hard ${budget.hardTokens} tokens`;
+            return `inactive; legacy soft ${budget.softTokens} / hard ${budget.hardTokens} tokens`;
         },
         set(args, store) {
             if (args.length !== 2 && args.length !== 4)
@@ -343,14 +329,14 @@ const CONFIG_KEY_HANDLERS = [
             };
             const resolved = resolveContextBudget({ ...current, ...next });
             saveConfigKey(store, (config) => ({ ...config, contextBudget: resolved }));
-            return `Context budget set to soft ${resolved.softTokens} / hard ${resolved.hardTokens} tokens\n`;
+            return `Legacy context budget stored as soft ${resolved.softTokens} / hard ${resolved.hardTokens} tokens (inactive)\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
                 const { contextBudget: _removed, ...rest } = config;
                 return rest;
             });
-            return `Context budget reset to soft ${DEFAULT_CONTEXT_SOFT_TOKENS} / hard ${DEFAULT_CONTEXT_HARD_TOKENS} tokens\n`;
+            return "Legacy context budget cleared; Session Token metrics remain read-only\n";
         }
     },
     {
@@ -696,7 +682,7 @@ const CONFIG_KEY_HANDLERS = [
         showValue: (config) => (config.review === undefined
             ? "disabled"
             : `${config.review.roleName} (${config.review.trigger}; finding ledger: ${config.review.findingLedger ?? "shadow"}`
-                + `${config.review.deltaRecheck === "enabled" ? "; delta recheck: enabled" : ""})`),
+                + ")"),
         set(args, store) {
             if (args.length < 4 || args.length % 2 !== 0)
                 throw usageError(REVIEW_SET_USAGE);
@@ -704,8 +690,7 @@ const CONFIG_KEY_HANDLERS = [
             for (let index = 0; index < args.length; index += 2) {
                 const name = args[index];
                 const value = args[index + 1];
-                if (!["--role", "--trigger", "--finding-ledger", "--delta-recheck",
-                    "--delta-recheck-max-lines", "--delta-recheck-max-files"].includes(name)
+                if (!["--role", "--trigger", "--finding-ledger"].includes(name)
                     || value === undefined
                     || options.has(name)) {
                     throw usageError(REVIEW_SET_USAGE);
@@ -731,33 +716,15 @@ const CONFIG_KEY_HANDLERS = [
                 }
                 findingLedger = rawLedgerMode;
             }
-            const rawDeltaRecheck = options.get("--delta-recheck")?.trim();
-            let deltaRecheck;
-            if (rawDeltaRecheck !== undefined) {
-                if (!REVIEW_DELTA_RECHECK_MODES.includes(rawDeltaRecheck)) {
-                    throw usageError(REVIEW_SET_USAGE);
-                }
-                deltaRecheck = rawDeltaRecheck;
-            }
-            const deltaRecheckMaxChangedLines = parsePositiveIntegerOption(options.get("--delta-recheck-max-lines"), REVIEW_SET_USAGE);
-            const deltaRecheckMaxChangedFiles = parsePositiveIntegerOption(options.get("--delta-recheck-max-files"), REVIEW_SET_USAGE);
             saveConfigKey(store, (config) => ({
                 ...config,
                 review: {
                     roleName,
                     trigger,
-                    ...(findingLedger === undefined ? {} : { findingLedger }),
-                    ...(deltaRecheck === undefined ? {} : { deltaRecheck }),
-                    ...(deltaRecheckMaxChangedLines === undefined
-                        ? {}
-                        : { deltaRecheckMaxChangedLines }),
-                    ...(deltaRecheckMaxChangedFiles === undefined
-                        ? {}
-                        : { deltaRecheckMaxChangedFiles })
+                    ...(findingLedger === undefined ? {} : { findingLedger })
                 }
             }));
-            return `Review set to ${roleName} (${trigger}; finding ledger: ${findingLedger ?? "shadow"}; `
-                + `delta recheck: ${deltaRecheck ?? "disabled"})\n`;
+            return `Review set to ${roleName} (${trigger}; finding ledger: ${findingLedger ?? "shadow"})\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {

package/dist/commands/executionAuditCommands.js

@@ -155,7 +155,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 `Delta-rechecks: ${reviews.deltaRechecks.total} total · `
                     + `${reviews.deltaRechecks.equivalentAndAccepted} accepted · `
                     + `${reviews.deltaRechecks.finding} finding · `
-                    + `${reviews.deltaRechecks.requiresFullReview} escalated to full Review`
+                    + `${reviews.deltaRechecks.requiresFullReview} requiring Leader decision`
             ]));
     }
     else {