@zq-silk/yui 0.6.0 → 0.6.2

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
@@ -20,15 +21,29 @@ import { nativeAgentEnvironmentNames } from "./agent/launchEnvironment.js";
 import { runAgentCommand } from "./commands/agentCommands.js";
 import { runGlobalRoleCommand } from "./commands/globalRoleCommands.js";
 import { runConfigCommand } from "./commands/configCommands.js";
-import { parseControllerCleanupOptions, parseControllerStatusOptions, renderControllerResourceStatus, runInteractiveControllerCleanup } from "./commands/controllerCommands.js";
+import { parseControllerCleanupOptions, parseControllerStatusOptions, parseControllerRuntimeSnapshot, renderControllerResourceStatus, renderRuntimeIdentitySection, summarizeDurablePhysicalMismatch, runInteractiveControllerCleanup } from "./commands/controllerCommands.js";
+import { parseExecutionAuditOptions, runExecutionAuditCommand } from "./commands/executionAuditCommands.js";
+import { parseSessionReconcileOptions, runSessionReconcileCommand } from "./commands/sessionCommands.js";
+import { SessionOwnerReconciliation } from "./controller/sessionOwnerReconciliation.js";
 import { runJobCommand } from "./commands/jobCommands.js";
+import { runDurableJobCommand } from "./commands/durableJobCommands.js";
+import { runTelemetryCommand } from "./commands/telemetryCommands.js";
+import { runResourcesCommand } from "./commands/resourcesCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
 import { runProfileCommand } from "./commands/profileCommands.js";
 import { dispatchPreparedReviewRound, failPendingReviewRound, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, validateTaskArchiveRequest } from "./commands/taskCommands.js";
 import { taskActor } from "./commands/taskActor.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
+import { runTaskChangeSetCommand } from "./commands/taskChangeSetCommands.js";
+import { runTaskOverlapCommand } from "./commands/taskOverlapCommands.js";
+import { createControllerIntegrationJobPort } from "./controller/jobClient.js";
 import { runTaskWorkspaceCommand } from "./commands/taskWorkspaceCommands.js";
+import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
+import { createUpdatePorts } from "./cli/updatePorts.js";
+import { createReleaseWorkflowPorts } from "./release/releaseWorkflowPorts.js";
+import { readRuntimeIdentity } from "./release/runtimeRelease.js";
+import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
 import { reconcileTaskRemoteBaselines } from "./commands/taskCompletionGate.js";
 import { FileCompletionManager, resolveCliIdentity } from "./completion/fileCompletionManager.js";
 import { assertFileTaskControllerStorageCompatible, ensureFileTaskController, FileTaskWorkflowRuntime, refreshRunningFileTaskControllerConfiguration, refreshRunningFileTaskControllerEnvironment, restartFileTaskController, stopFileTaskController } from "./controller/clientRuntime.js";
@@ -37,6 +52,7 @@ import { FileSchedulerStoreAdapter } from "./controller/fileSchedulerStoreAdapte
 import { cleanControllerResource } from "./controller/resourceCleanupLinux.js";
 import { scanControllerResourceInventory } from "./controller/resourceInventoryLinux.js";
 import { runSessionNotifyCommand } from "./controller/sessionNotify.js";
+import { openSchedulerTelemetry } from "./telemetry/telemetryWiring.js";
 import { runClaudeLifecycleHookCommand } from "./controller/claudeLifecycleHook.js";
 import { runCodexLifecycleHookCommand } from "./controller/codexLifecycleHook.js";
 import { buildDoctorReport, renderDoctor, runDoctorCommand } from "./doctor/doctor.js";
@@ -45,6 +61,7 @@ import { FileRoleLaunchPlanner } from "./executor/fileRoleLaunchPlanner.js";
 import { TaskWorkspaceCoordinator, WorkspaceCleanupBlockedError } from "./repository/taskWorkspaceCoordinator.js";
 import { FileTaskWorkspacePreparer, ReviewRoundWorkspaceEvidenceError } 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";
 import { openCompatibleFileTaskStore, validateCompatibleFileTaskStore } from "./storage/compatibleTaskStore.js";
 import { resolveTaskRecordReference } from "./task/taskRecordReference.js";
@@ -82,7 +99,7 @@ void main().catch((error) => {
     process.exitCode = 5;
 });
 export async function main() {
-    const taskFinalReviewContract = await preflightManagedTaskControlPlane();
+    const { contract: taskFinalReviewContract, verifiedStore } = await preflightManagedTaskControlPlane();
     if (args.length === 0) {
         emit(renderCommandHelp((await import("./cli/commandCatalog.js")).ROOT_COMMAND, VERSION));
         return;
@@ -113,6 +130,37 @@ export async function main() {
         return;
     }
     const home = resolveYuiHome(process.env);
+    if (args[0] === "release") {
+        const subcommand = args[1];
+        if (subcommand === "install" && args.length === 3) {
+            const result = runReleaseInstall(home, args[2]);
+            emit(renderReleaseInstallResult(result), false, result);
+            if (result.outcome === "aborted")
+                process.exitCode = 5;
+            return;
+        }
+        if (subcommand === "list" && args.length === 2) {
+            const result = runReleaseList(home);
+            emit(renderReleaseList(result), false, result);
+            return;
+        }
+        if (subcommand === "activate" && (args.length === 2 || args.length === 3)) {
+            const releaseId = args.length === 3
+                ? args[2]
+                : runReleaseList(home).active ?? undefined;
+            if (releaseId === undefined) {
+                throw usageError("Release activate usage: yui release activate <release-id> "
+                    + "(or activate the active release when exactly one is installed).");
+            }
+            const result = await runReleaseActivate(home, releaseId);
+            emit(renderReleaseActivateResult(result), false, result);
+            if (result.outcome === "aborted" || result.outcome === "dual-owner") {
+                process.exitCode = 5;
+            }
+            return;
+        }
+        throw usageError("Release usage: yui release install <source-dir> | list | activate [release-id].");
+    }
     if (args[0] === "completion") {
         await completionCommand(home, invocation.node);
         return;
@@ -154,6 +202,17 @@ export async function main() {
         emit(renderDoctor(report.checks, report.review));
         return;
     }
+    if (args[0] === "execution") {
+        // Issue 11 read-only audit: opens the Home read-only, never writes state,
+        // never wakes a Leader.
+        if (args[1] !== "audit") {
+            throw usageError("Execution usage: yui execution audit [--task <id>] [--since <iso>] [--until <iso>].");
+        }
+        const options = parseExecutionAuditOptions(args.slice(2));
+        const result = runExecutionAuditCommand(home, options);
+        emit(result.output, false, result.report);
+        return;
+    }
     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.
@@ -179,12 +238,50 @@ export async function main() {
         }
         throw usageError("Internal lifecycle callback usage is invalid.");
     }
+    if (args[0] === "session") {
+        if (args[1] !== "reconcile") {
+            throw usageError("Session usage: yui session reconcile [--report] [--cleanup].");
+        }
+        const options = parseSessionReconcileOptions(args.slice(2));
+        const store = openCompatibleFileTaskStore(home);
+        const tmux = new TmuxManager(process.env.YUI_TMUX_BIN ?? "tmux", new NodeCommandExecutor(), { yuiHome: home });
+        const reconciliation = new SessionOwnerReconciliation({
+            home,
+            store,
+            environment: process.env,
+            tmux
+        });
+        const result = await runSessionReconcileCommand({
+            reconciliation,
+            options,
+            environment: process.env
+        });
+        process.exitCode = result.exitCode;
+        emit(result.output, false, result.data);
+        return;
+    }
     if (args[0] === "controller") {
         const method = args[1];
         if (method === "identity" && args.length === 2) {
-            // Internal lifecycle seam used by update/upgrade. The Controller socket
-            // authenticates this exact launch identity; public `controller status`
-            // intentionally redacts argv in its resource inventory.
+            // Issue 02: the stable, read-only runtime identity receipt. It survives
+            // a Controller stop and answers build ID, package digest, backend, and
+            // worker state without a socket round-trip. When no receipt exists yet
+            // (a Controller that predates this feature), fall back to the
+            // authenticated socket identity so the command stays useful during
+            // rollout step 1.
+            let receipt = null;
+            try {
+                receipt = readRuntimeIdentity(home);
+            }
+            catch {
+                // A corrupt or stale receipt (for example one written by an older
+                // Controller that predates the launch-identity fields) falls back to
+                // the live socket identity, which always carries the exact argv.
+            }
+            if (receipt !== null) {
+                emit("", false, receipt);
+                return;
+            }
             try {
                 const identity = await callController(home, "controller.identity", {});
                 emit("", false, identity);
@@ -218,6 +315,39 @@ export async function main() {
                 scope: options.scope,
                 environment: process.env
             });
+            if (resolveStatusIdentityEnabled(process.env)) {
+                // Issue 11 read-only identity/metrics section. Every fact is observed;
+                // missing producers render `unsupported` and storage contradictions
+                // fail closed with exit code 5.
+                const cliEntry = fileURLToPath(import.meta.url);
+                const packageRoot = resolve(cliEntry, "..", "..");
+                const build = collectRuntimeBuildIdentity(createProductionRuntimeIdentityPorts(packageRoot, cliEntry, process.env));
+                const storage = collectStorageIdentity(home);
+                const droppedEvents = countDroppedInboxEvents(home);
+                let runtime;
+                try {
+                    const result = await callController(home, "controller.status", {}, { timeoutMs: 2_000 });
+                    runtime = parseControllerRuntimeSnapshot(result, droppedEvents);
+                }
+                catch {
+                    runtime = { source: "unsupported", droppedEvents };
+                }
+                const mismatch = summarizeDurablePhysicalMismatch(snapshot);
+                const identitySection = renderRuntimeIdentitySection({
+                    build,
+                    storage,
+                    runtime,
+                    mismatch,
+                    inventoryRssBytes: snapshot.summary.rssBytes
+                });
+                emit(`${renderControllerResourceStatus(snapshot, options.verbose)}\n\n${identitySection}`, false, { ...snapshot, identity: { build, storage, runtime, mismatch } });
+                // Exit 5 only on hard contradictions (fail). A needs-repair state
+                // (pseudo-layout-7) is degraded but still readable via the file store,
+                // so it exits 0 with a DEGRADED health line and a precise repair action.
+                if (evaluateStorageHealth(storage).status === "fail")
+                    process.exitCode = 5;
+                return;
+            }
             emit(renderControllerResourceStatus(snapshot, options.verbose), false, snapshot);
             return;
         }
@@ -270,8 +400,22 @@ export async function main() {
         emit(renderControllerResult(controllerMethod, result), false, controllerMethod === "restart" ? result : undefined);
         return;
     }
+    if (args[0] === "resources") {
+        await assertFileTaskControllerStorageCompatible(home);
+        const resourcesStore = openCompatibleFileTaskStore(home);
+        const result = await runResourcesCommand(args.slice(1), resourcesStore);
+        emit(result.output, false, result.data);
+        return;
+    }
     await assertFileTaskControllerStorageCompatible(home);
-    const store = openCompatibleFileTaskStore(home);
+    // Reuse the store the exact runtime preflight already opened and read for
+    // this same Home. Opening a second store would parse the unchanged large
+    // state a second time; the per-instance fingerprint cache still invalidates
+    // on an external writer, and the storage lock + revision CAS are unchanged.
+    const store = verifiedStore !== undefined
+        && resolve(verifiedStore.rootDirectory()) === resolve(home)
+        ? verifiedStore
+        : openCompatibleFileTaskStore(home);
     const catalogs = new AgentConfigurationCatalogService(home, {
         environment: process.env
     });
@@ -287,7 +431,7 @@ export async function main() {
         terminalInput: process.stdin,
         onWarning: (message) => process.stderr.write(`Warning: ${message}\n`)
     });
-    const schedulerStore = new FileSchedulerStoreAdapter(store);
+    const schedulerStore = new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, process.env));
     const planner = new FileRoleLaunchPlanner(home, store, { environment: process.env });
     const workspacePreparer = new FileTaskWorkspacePreparer(home, store);
     const runtime = new FileTaskWorkflowRuntime(home, store, schedulerStore, planner, tmux, workspacePreparer, {
@@ -443,7 +587,37 @@ export async function main() {
     }
     if (resolved[0] === "task") {
         if (resolved[1] === "integration") {
-            const result = await runTaskIntegrationCommand(resolved.slice(2), store, home, { environment: process.env });
+            const result = await runTaskIntegrationCommand(resolved.slice(2), store, home, {
+                environment: process.env,
+                jobPort: createControllerIntegrationJobPort(home, { environment: process.env, store })
+            });
+            emit(result.output, false, result.data);
+            return;
+        }
+        if (resolved[1] === "change-set") {
+            const result = await runTaskChangeSetCommand(resolved.slice(2), store);
+            emit(result.output, false, result.data);
+            return;
+        }
+        if (resolved[1] === "overlap") {
+            const result = await runTaskOverlapCommand(resolved.slice(2), store);
+            emit(result.output, false, result.data);
+            return;
+        }
+        if (resolved[1] === "workflow"
+            && (resolved[2] === "run" || resolved[2] === "resume")) {
+            const result = await runWorkflowCommandAsync(resolved.slice(2), store, {
+                environment: process.env,
+                yuiHome: home,
+                ports: createReleaseWorkflowPorts({
+                    home,
+                    updatePorts: createUpdatePorts(process.env),
+                    projectStore: store
+                })
+            });
+            if (result.kind !== "output") {
+                throw new Error(`Task workflow ${resolved[2]} returned an invalid control result.`);
+            }
             emit(result.output, false, result.data);
             return;
         }
@@ -669,7 +843,12 @@ export async function main() {
                 // transaction once its exact Lane ids exist.
             }
         }
-        let executionLaneWorkspaces = await prepareExecutionLaneWorkspacesForCommand(resolved, store, workspacePreparer, process.env);
+        let executionLaneWorkspaces;
+        // Held only for a new Group's dispatch: the per-Project maintenance fence
+        // spans Lane preparation and the adoption transaction, and projectPaths is
+        // the under-fence snapshot the adoption CAS revalidates.
+        let laneDispatchRelease;
+        let laneDispatchProjectPaths;
         let workItemIntegrationProof;
         if (resolved[1] === "work" && resolved[2] === "accept") {
             const workItemId = resolved[3];
@@ -695,12 +874,18 @@ export async function main() {
                     : { taskFinalReviewContract })
             });
             if (!completion.completed && !completion.activeTaskReview) {
-                await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env });
+                await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env, jobPort: createControllerIntegrationJobPort(home, { environment: process.env, store }) });
             }
         }
         let candidateMaterialization;
         let candidateMaterializationCommitted = false;
         try {
+            const preparedLanes = await prepareExecutionLaneWorkspacesForCommand(resolved, store, workspacePreparer, process.env);
+            if (preparedLanes !== undefined) {
+                executionLaneWorkspaces = preparedLanes.workspaces;
+                laneDispatchRelease = preparedLanes.release;
+                laneDispatchProjectPaths = preparedLanes.projectPaths;
+            }
             candidateMaterialization = await candidateMaterializationForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
             const candidateGitSnapshot = candidateMaterialization === undefined
                 ? await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract)
@@ -726,6 +911,7 @@ export async function main() {
                     ? {}
                     : { candidateWorkspace: candidateMaterialization.workspace ?? null }),
                 ...(executionLaneWorkspaces === undefined ? {} : { executionLaneWorkspaces }),
+                ...(laneDispatchProjectPaths === undefined ? {} : { laneDispatchProjectPaths }),
                 ...(directTaskMainSnapshot === undefined ? {} : { directTaskMainSnapshot }),
                 ...(actualTaskReviewCandidate === undefined
                     ? {}
@@ -734,6 +920,13 @@ export async function main() {
                 ...(laneSnapshotPreflight === undefined ? {} : { executionLaneGitSnapshot: laneSnapshotPreflight }),
                 ...(taskRetirementProof === undefined ? {} : { taskRetirementProof })
             });
+            // The dispatch transaction has now adopted (or rejected) the prepared
+            // Lane workspaces. Release the held fence so later output/review
+            // handling can take the per-Project fence itself.
+            if (laneDispatchRelease !== undefined) {
+                laneDispatchRelease();
+                laneDispatchRelease = undefined;
+            }
             // The command transaction has now durably submitted the Candidate. Any
             // later output/review handling must not roll back its Git snapshot.
             candidateMaterializationCommitted = candidateMaterialization !== undefined;
@@ -867,6 +1060,10 @@ export async function main() {
             if (!candidateMaterializationCommitted) {
                 await workspacePreparer.discardUnadoptedExecutionLaneWorkspaces(executionLaneWorkspaces);
             }
+            if (laneDispatchRelease !== undefined) {
+                laneDispatchRelease();
+                laneDispatchRelease = undefined;
+            }
             throw error;
         }
     }
@@ -874,6 +1071,24 @@ export async function main() {
         emit(runJobCommand(resolved.slice(1), store, { runtime }));
         return;
     }
+    if (resolved[0] === "job") {
+        emit(await runDurableJobCommand(resolved.slice(1), {
+            home,
+            json: jsonOutput,
+            environment: process.env,
+            store
+        }));
+        return;
+    }
+    if (resolved[0] === "telemetry") {
+        emit(await runTelemetryCommand(resolved.slice(1), {
+            home,
+            json: jsonOutput,
+            environment: process.env,
+            store
+        }));
+        return;
+    }
     throw usageError(`Command is not connected to the restored FileTaskStore framework yet: ${resolved[0]}.`, renderCommandHelp(invocation.node, VERSION));
 }
 async function preflightManagedTaskControlPlane() {
@@ -896,7 +1111,7 @@ async function preflightManagedTaskControlPlane() {
         if (taskFinalReviewInvocation.request !== undefined) {
             throw new Error("Task final-review contract requires a verified exact Task control-plane invocation.");
         }
-        return undefined;
+        return { contract: undefined, verifiedStore: undefined };
     }
     if (process.env.YUI_SESSION_SCOPE !== "task") {
         throw new Error("Exact Task control-plane invocation requires a managed Task runtime.");
@@ -926,23 +1141,27 @@ async function preflightManagedTaskControlPlane() {
     const preallocatedClaudeCallback = args.length === 2
         && args[0] === "internal"
         && args[1] === "claude-hook";
-    assertExactTaskRuntimeState(runtime, openCompatibleFileTaskStore(control.yuiHome), preallocatedClaudeCallback
+    const verifiedStore = openCompatibleFileTaskStore(control.yuiHome);
+    assertExactTaskRuntimeState(runtime, verifiedStore, preallocatedClaudeCallback
         ? { preallocatedNativeSessionReservation: { yuiHome: control.yuiHome } }
         : {});
     const request = taskFinalReviewInvocation.request;
     if (request === undefined)
-        return undefined;
+        return { contract: undefined, verifiedStore };
     if (runtime.roleName !== "leader") {
         throw new Error("Only the exact Task Leader invocation may establish a final-review contract.");
     }
     if (request.taskId !== runtime.taskId) {
         throw new Error(`Task final-review contract Task id mismatch: expected ${runtime.taskId}, found ${request.taskId}.`);
     }
-    return createTaskFinalReviewContract({
-        taskId: runtime.taskId,
-        reviewerRoleName: request.reviewerRoleName,
-        controlPlaneDigest: digest
-    });
+    return {
+        contract: createTaskFinalReviewContract({
+            taskId: runtime.taskId,
+            reviewerRoleName: request.reviewerRoleName,
+            controlPlaneDigest: digest
+        }),
+        verifiedStore
+    };
 }
 function cleanupCliError(error, fallbackResource) {
     if (error instanceof WorkspaceCleanupBlockedError) {
@@ -1145,20 +1364,45 @@ async function prepareExecutionLaneWorkspacesForCommand(args, store, preparer, e
         return undefined;
     const groupId = group?.id ?? `execution-group-${store.peekNextAgentRunId(item.taskId)}`;
     const laneIds = plan.laneIds;
+    // A new Group's Lanes are not yet durable, so their worktrees would be
+    // unadopted between preparation and the dispatch transaction. Hold ONE
+    // per-Project maintenance fence across both, so a project migrate cannot
+    // switch the catalog in that gap and strand a Lane on the external
+    // checkout. An existing Group's Lanes are adopted inside their own fence,
+    // so no outer fence is held.
+    const held = group === undefined
+        ? preparer.acquireTaskProjectMaintenanceLocks(item.taskId)
+        : undefined;
     const map = new Map();
     try {
+        let projectPaths;
+        if (held !== undefined) {
+            const paths = new Map();
+            for (const { projectId } of held.current.projectBindings) {
+                const project = store.getProject(projectId);
+                if (project === null)
+                    throw new Error(`Project not found: ${projectId}.`);
+                paths.set(projectId, project.path);
+            }
+            projectPaths = paths;
+        }
         for (const laneId of laneIds.filter((value) => value.length > 0)) {
             map.set(laneId, await preparer.prepareExecutionLaneWorkspace(item.taskId, groupId, laneId, {
                 purpose: "execution",
                 workItemId: item.id
-            }));
+            }, held === undefined ? undefined : { current: held.current }));
         }
+        return { workspaces: map, release: held?.release, projectPaths };
     }
     catch (error) {
+        // Compensate (discard unadopted Lane worktrees) BEFORE releasing the
+        // fence: a concurrent project migrate must not switch the catalog while
+        // external-backed worktrees are still identifiable for removal.
         await preparer.discardUnadoptedExecutionLaneWorkspaces(map);
+        if (held !== undefined)
+            held.release();
         throw error;
     }
-    return map;
 }
 async function prepareReviewLaneWorkspaces(taskId, reviewRoundId, store, preparer) {
     const round = store.getReviewRound(taskId, reviewRoundId);

package/dist/commands/configCommands.js

@@ -1,14 +1,19 @@
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_RECONCILIATION_INTERVAL_SECONDS, reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
+import { DEFAULT_RECONCILIATION_INTERVAL_SECONDS, reconciliationIntervalMilliseconds, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
-import { REVIEW_TRIGGERS } from "../review/reviewConfig.js";
+import { REVIEW_FINDING_LEDGER_MODES, REVIEW_TRIGGERS } from "../review/reviewConfig.js";
+import { DEFAULT_LEADER_NEXT_ACTION_MODE, LEADER_NEXT_ACTION_MODES, resolveLeaderNextActionMode } from "../config/yuiConfig.js";
 const CONFIG_SET_USAGE = "Config set usage: yui config set "
     + "<--time-zone <IANA timezone> | "
-    + "--reconciliation-interval-seconds <seconds>>.";
+    + "--reconciliation-interval-seconds <seconds> | "
+    + "--resources-gc-mode <report|quarantine> | "
+    + "--resources-gc-auto-quarantine <true|false>>.";
 export function runConfigCommand(args, store) {
     const [command, ...rest] = args;
     if (command === "review")
         return runReviewConfigCommand(rest, store);
+    if (command === "leader-next-action")
+        return runLeaderNextActionConfigCommand(rest, store);
     if (command === "show") {
         if (rest.length !== 0)
             throw usageError("Config show usage: yui config show.");
@@ -19,6 +24,9 @@ export function runConfigCommand(args, store) {
         return [
             `Time zone: ${resolveTimeZone(config.timeZone)}`,
             `Reconciliation interval: ${reconciliationIntervalSeconds} seconds`,
+            `Leader next-action mode: ${resolveLeaderNextActionMode(config.leaderNextActionMode)}`,
+            `Resources GC mode: ${resolveResourcesGcMode(config.resourcesGcMode)}`,
+            `Resources GC auto-quarantine: ${resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine) ? "on" : "off"}`,
             ""
         ].join("\n");
     }
@@ -41,12 +49,65 @@ export function runConfigCommand(args, store) {
             });
             return `Reconciliation interval set to ${reconciliationIntervalSeconds} seconds\n`;
         }
+        if (rest[0] === "--resources-gc-mode") {
+            const resourcesGcMode = validatedConfigValue(() => resolveResourcesGcMode(rest[1]));
+            store.transaction((tx) => {
+                tx.saveConfig({ ...tx.getConfig(), resourcesGcMode });
+            });
+            return `Resources GC mode set to ${resourcesGcMode}\n`;
+        }
+        if (rest[0] === "--resources-gc-auto-quarantine") {
+            const resourcesGcAutoQuarantine = validatedConfigValue(() => resolveResourcesGcAutoQuarantine(rest[1] === "true" ? true : rest[1] === "false" ? false : rest[1]));
+            store.transaction((tx) => {
+                tx.saveConfig({ ...tx.getConfig(), resourcesGcAutoQuarantine });
+            });
+            return `Resources GC auto-quarantine set to ${resourcesGcAutoQuarantine ? "on" : "off"}\n`;
+        }
         throw configSetUsageError();
     }
     throw usageError(command === undefined
         ? "Config command is required."
         : `Unknown command: config ${command}`);
 }
+function runLeaderNextActionConfigCommand(args, store) {
+    const [command, ...rest] = args;
+    if (command === "show") {
+        if (rest.length !== 0) {
+            throw usageError("Config leader-next-action show usage: yui config leader-next-action show.");
+        }
+        return `Leader next-action mode: ${resolveLeaderNextActionMode(store.getConfig().leaderNextActionMode)}\n`;
+    }
+    if (command === "set") {
+        const usage = "Config leader-next-action set usage: "
+            + `yui config leader-next-action set <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
+        if (rest.length !== 1)
+            throw usageError(usage);
+        let mode;
+        try {
+            mode = resolveLeaderNextActionMode(rest[0]);
+        }
+        catch (error) {
+            throw usageError(error instanceof Error ? error.message : String(error), usage);
+        }
+        store.transaction((tx) => {
+            tx.saveConfig({ ...tx.getConfig(), leaderNextActionMode: mode });
+        });
+        return `Leader next-action mode set to ${mode}\n`;
+    }
+    if (command === "clear") {
+        if (rest.length !== 0) {
+            throw usageError("Config leader-next-action clear usage: yui config leader-next-action clear.");
+        }
+        store.transaction((tx) => {
+            const { leaderNextActionMode: _mode, ...config } = tx.getConfig();
+            tx.saveConfig(config);
+        });
+        return `Leader next-action mode reset to ${DEFAULT_LEADER_NEXT_ACTION_MODE}\n`;
+    }
+    throw usageError(command === undefined
+        ? "Config leader-next-action command is required."
+        : `Unknown command: config leader-next-action ${command}`);
+}
 function runReviewConfigCommand(args, store) {
     const [command, ...rest] = args;
     if (command === "show") {
@@ -55,7 +116,7 @@ function runReviewConfigCommand(args, store) {
         const review = store.getConfig().review;
         return review === undefined
             ? "Review: disabled\n"
-            : `Review: ${review.roleName} (${review.trigger})\n`;
+            : `Review: ${review.roleName} (${review.trigger}; finding ledger: ${review.findingLedger ?? "shadow"})\n`;
     }
     if (command === "clear") {
         if (rest.length !== 0)
@@ -68,14 +129,15 @@ function runReviewConfigCommand(args, store) {
     }
     if (command === "set") {
         const usage = "Config review set usage: "
-            + "yui config review set --role <global-role> --trigger <always|leader|final>.";
-        if (rest.length !== 4)
+            + "yui config review set --role <global-role> --trigger <always|leader|final> "
+            + "[--finding-ledger <shadow|enforce>].";
+        if (rest.length !== 4 && rest.length !== 6)
             throw usageError(usage);
         const options = new Map();
         for (let index = 0; index < rest.length; index += 2) {
             const name = rest[index];
             const value = rest[index + 1];
-            if (!["--role", "--trigger"].includes(name)
+            if (!["--role", "--trigger", "--finding-ledger"].includes(name)
                 || value === undefined
                 || options.has(name)) {
                 throw usageError(usage);
@@ -93,13 +155,25 @@ function runReviewConfigCommand(args, store) {
             throw usageError(`Global Role not found: ${roleName}.`);
         }
         const trigger = rawTrigger;
+        const rawLedgerMode = options.get("--finding-ledger")?.trim();
+        let findingLedger;
+        if (rawLedgerMode !== undefined) {
+            if (!REVIEW_FINDING_LEDGER_MODES.includes(rawLedgerMode)) {
+                throw usageError(usage);
+            }
+            findingLedger = rawLedgerMode;
+        }
         store.transaction((tx) => {
             tx.saveConfig({
                 ...tx.getConfig(),
-                review: { roleName, trigger }
+                review: {
+                    roleName,
+                    trigger,
+                    ...(findingLedger === undefined ? {} : { findingLedger })
+                }
             });
         });
-        return `Review set to ${roleName} (${trigger})\n`;
+        return `Review set to ${roleName} (${trigger}; finding ledger: ${findingLedger ?? "shadow"})\n`;
     }
     throw usageError(command === undefined
         ? "Config review command is required."