@zq-silk/yui 0.11.3 → 0.12.1

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) {
@@ -266,19 +301,44 @@ export async function main() {
     if (args[0] === "upgrade") {
         // Mirror doctor/controller: needs a Home but self-manages the schema check,
         // because upgrade must run against a non-current Home.
-        const result = await runUpgradeCommand(args.slice(1), home, process.env.YUI_UPDATE_EXTERNALLY_QUIESCED === "1"
-            ? { controllerLifecycle: "externally-quiesced" }
-            : {});
-        // Public execute upgrades leave the Home operational even when no
-        // Controller existed before the command. Dry-run and the staged updater's
-        // externally-quiesced preflight must remain read-only/lifecycle-neutral.
-        if (args.length === 1
-            && result.exitCode === 0
-            && process.env.YUI_UPDATE_EXTERNALLY_QUIESCED !== "1") {
-            await ensureFileTaskController(home, { environment: process.env });
+        const externallyQuiesced = process.env.YUI_UPDATE_EXTERNALLY_QUIESCED === "1";
+        const ownsHandover = args.length === 1 && !externallyQuiesced;
+        const externalFenceOwner = externallyQuiesced
+            ? process.env.YUI_UPDATE_HANDOVER_OWNER_PID
+            : undefined;
+        const externalUpgradeFenceOwnerPid = externalFenceOwner === undefined
+            ? undefined
+            : Number(externalFenceOwner);
+        if (externalUpgradeFenceOwnerPid !== undefined
+            && (!Number.isSafeInteger(externalUpgradeFenceOwnerPid)
+                || externalUpgradeFenceOwnerPid < 1)) {
+            throw runtimeError("Update storage-fence owner PID is invalid.");
+        }
+        const handover = ownsHandover ? acquireHandoverLock(home) : undefined;
+        try {
+            const result = await runUpgradeCommand(args.slice(1), home, externallyQuiesced
+                ? {
+                    controllerLifecycle: "externally-quiesced",
+                    ...(externalUpgradeFenceOwnerPid === undefined
+                        ? {}
+                        : { externalUpgradeFenceOwnerPid })
+                }
+                : {});
+            // Public execute upgrades leave the Home operational even when no
+            // Controller existed before the command. Dry-run and the staged updater's
+            // externally-quiesced preflight must remain read-only/lifecycle-neutral.
+            if (ownsHandover && result.exitCode === 0) {
+                await ensureFileTaskController(home, {
+                    environment: process.env,
+                    handoverOwnerPid: process.pid
+                });
+            }
+            process.exitCode = result.exitCode;
+            emit(result.output, false, result.data);
+        }
+        finally {
+            handover?.release();
         }
-        process.exitCode = result.exitCode;
-        emit(result.output, false, result.data);
         return;
     }
     if (args[0] === "internal") {
@@ -486,9 +546,21 @@ export async function main() {
         }
         validateCompatibleFileTaskStore(home);
         const controllerMethod = method;
+        const updateHandoverOwner = process.env.YUI_UPDATE_HANDOVER_OWNER_PID;
+        const updateHandoverOwnerPid = updateHandoverOwner === undefined
+            ? undefined
+            : Number(updateHandoverOwner);
+        if (updateHandoverOwnerPid !== undefined
+            && (!Number.isSafeInteger(updateHandoverOwnerPid) || updateHandoverOwnerPid < 1)) {
+            throw runtimeError("Update Controller handover owner PID is invalid.");
+        }
+        const controllerOptions = {
+            environment: process.env,
+            ...(updateHandoverOwnerPid === undefined ? {} : { handoverOwnerPid: updateHandoverOwnerPid })
+        };
         const result = controllerMethod === "restart"
-            ? await restartFileTaskController(home, { environment: process.env })
-            : await stopFileTaskController(home, { environment: process.env });
+            ? await restartFileTaskController(home, controllerOptions)
+            : await stopFileTaskController(home, controllerOptions);
         // The update lifecycle needs the authenticated replacement PID returned by
         // restart/readiness.  Keep stop's long-standing text envelope, while
         // exposing restart's structured result alongside its human output.
@@ -1123,14 +1195,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 +1227,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 +1294,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 +2004,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 +2062,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 +2113,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 +2128,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 +2152,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 +2214,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";
         }
     },
     {
@@ -469,7 +455,7 @@ const CONFIG_KEY_HANDLERS = [
                 const { runtimeHealth: _removed, ...rest } = config;
                 return rest;
             });
-            return "Runtime health thresholds reset to quiet 300s / diagnostic 600s / stall 1800s\n";
+            return "Runtime health thresholds reset to quiet 300s / diagnostic 900s / stall 1800s\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

@@ -139,7 +139,8 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     }
     if (report.sessions.status === "ok" && report.sessions.data !== undefined) {
         const sessions = report.sessions.data;
-        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Run relation: ${sessions.terminalByRunRelation.postRunYielded} post-run-yielded`
+        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · Conversation switches ${sessions.conversationSwitches}`
+            + ` · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Run relation: ${sessions.terminalByRunRelation.postRunYielded} post-run-yielded`
             + ` · ${sessions.terminalByRunRelation.runFailed} run-failed`
             + ` · ${sessions.terminalByRunRelation.activeRun} active-run`
             + ` · ${sessions.terminalByRunRelation.noRun} no-run`);
@@ -155,7 +156,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 {

package/dist/commands/jobCommands.js

@@ -56,18 +56,14 @@ function collectJobs(store) {
             });
         }
         const failure = store.getLeaderFailure(task.id);
-        const notification = store.getOperatorNotification(task.id);
-        const recoveryNotification = notification?.type === "leader-recovery-failed"
-            ? notification
-            : null;
-        if (failure !== null || recoveryNotification !== null) {
+        if (failure !== null) {
             jobs.push({
                 id: `${RECOVERY_PREFIX}${task.id}`,
                 taskId: task.id,
                 kind: "leader-recovery",
                 status: "failed",
-                detail: failure?.message ?? recoveryNotification?.message ?? "Leader recovery failed.",
-                updatedAt: failure?.lastFailedAt ?? recoveryNotification?.updatedAt ?? task.updatedAt
+                detail: failure.message,
+                updatedAt: failure.lastFailedAt
             });
         }
     }
@@ -93,12 +89,10 @@ function retryJob(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Leader recovery can only be retried for an active Task: ${task.id}.`);
         }
-        if (tx.getLeaderFailure(task.id) === null
-            && tx.getOperatorNotification(task.id)?.type !== "leader-recovery-failed") {
+        if (tx.getLeaderFailure(task.id) === null) {
             throw usageError(`Job not found: ${id}.`);
         }
         tx.clearLeaderFailure(task.id);
-        tx.clearOperatorNotification(task.id);
         enqueueWork(tx, { kind: "role", taskId: task.id, roleName: "leader" }, "recovery-retry", now, [{ type: "task", id: task.id }]);
     });
     const target = { kind: "role", taskId, roleName: "leader" };