@zq-silk/yui 0.6.13 → 0.6.14

package/dist/cli.js

@@ -16,6 +16,7 @@ import { resolveOperatorWizardArguments } from "./cli/operatorWizard.js";
 import { runUpdateCommand } from "./cli/updateCommand.js";
 import { runUpgradeCommand } from "./cli/upgradeCommand.js";
 import { formatTimestamp } from "./output/timePresentation.js";
+import { resolveTmuxBin } from "./config/yuiConfig.js";
 import { renderAgentConfigurationCatalog } from "./output/agentConfigurationPresentation.js";
 import { nativeAgentEnvironmentNames } from "./agent/launchEnvironment.js";
 import { runAgentCommand } from "./commands/agentCommands.js";
@@ -45,6 +46,8 @@ 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 { runTaskBaseStatusCommand } from "./commands/taskBaseCommands.js";
+import { assertTaskBaseFreshnessForCompletion, inspectTaskBaseFreshness } from "./repository/taskBaseFreshness.js";
 import { FileCompletionManager, resolveCliIdentity } from "./completion/fileCompletionManager.js";
 import { assertFileTaskControllerStorageCompatible, ensureFileTaskController, FileTaskWorkflowRuntime, refreshRunningFileTaskControllerConfiguration, refreshRunningFileTaskControllerEnvironment, restartFileTaskController, stopFileTaskController } from "./controller/clientRuntime.js";
 import { callController, ControllerClientError } from "./core/controllerClient.js";
@@ -77,6 +80,9 @@ import { YUI_VERSION, yuiVersionIdentity } from "./version.js";
 import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactControlPlanePreflight, assertExactTaskRuntimeEnvironment, assertExactTaskRuntimeState, exactControlPlaneDigest, extractExactControlArgument, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
 import { builtinAgentDriverRegistry } from "./runtime/builtinAgentDrivers.js";
 import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./review/taskFinalReviewContract.js";
+import { assessDeltaRecheck } from "./review/deltaRecheck.js";
+import { deltaRecheckEnabled } from "./review/reviewConfig.js";
+import { NodeGitWorkspace } from "./repository/gitWorkspace.js";
 import { currentWorkItemExecutionGroup, workItemExecutionGroupById } from "./workItem/workItem.js";
 const VERSION = YUI_VERSION;
 const exactControlInvocation = extractExactControlArgument(process.argv.slice(2));
@@ -283,7 +289,7 @@ export async function main() {
         }
         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 tmux = new TmuxManager(resolveTmuxBin(store.getConfig().tmuxBin), new NodeCommandExecutor(), { yuiHome: home });
         const reconciliation = new SessionOwnerReconciliation({
             home,
             store,
@@ -488,12 +494,12 @@ export async function main() {
     }
     await preflightAgentConfigurationMutation(resolved, store, catalogs);
     const executor = new NodeCommandExecutor();
-    const tmux = new TmuxManager(process.env.YUI_TMUX_BIN ?? "tmux", executor, {
+    const tmux = new TmuxManager(resolveTmuxBin(store.getConfig().tmuxBin), executor, {
         yuiHome: home,
         terminalInput: process.stdin,
         onWarning: (message) => process.stderr.write(`Warning: ${message}\n`)
     });
-    const schedulerStore = new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, process.env));
+    const schedulerStore = new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, store.getConfig()));
     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, {
@@ -510,7 +516,7 @@ export async function main() {
         const options = parseWebCommandOptions(resolved.slice(1));
         const terminal = new TmuxWebTerminalService({
             yuiHome: home,
-            tmuxBin: process.env.YUI_TMUX_BIN ?? "tmux",
+            tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin),
             tmux,
             prepareGlobalRole: (roleName) => runtime.prepareGlobalRoleEnter(roleName),
             environment: process.env,
@@ -591,18 +597,18 @@ export async function main() {
     }
     if (resolved[0] === "config") {
         const configArgs = resolved.slice(1);
-        const output = runConfigCommand(configArgs, store);
+        const result = runConfigCommand(configArgs, store);
         if (configArgs[0] === "set"
-            && configArgs[1] === "--reconciliation-interval-seconds") {
+            && configArgs[1] === "reconciliation-interval-seconds") {
             const refresh = await refreshRunningFileTaskControllerConfiguration(home, { environment: process.env });
-            emit(withControllerRefreshWarning(output, refresh, "Controller configuration"));
+            emit(withControllerRefreshWarning(result.output, refresh, "Controller configuration"));
             return;
         }
-        emit(output);
+        emit(result.output, false, result.data);
         return;
     }
     if (resolved[0] === "project") {
-        const result = await runProjectCommand(resolved.slice(1), store);
+        const result = await runProjectCommand(resolved.slice(1), store, { environment: process.env });
         emit(result.output, false, result.data);
         return;
     }
@@ -915,9 +921,15 @@ export async function main() {
             }
         }
         let completionSummary;
+        if (resolved[1] === "base" && resolved[2] === "status") {
+            const result = await runTaskBaseStatusCommand(resolved.slice(3), store);
+            emit(result.output, false, result.data);
+            return;
+        }
         if (resolved[1] === "complete" && resolved[2] !== undefined) {
             const completionRequest = parseTaskCompletionRequest(resolved.slice(2));
             completionSummary = completionRequest.summary;
+            const refreshRemote = resolved.includes("--refresh-remote");
             const completion = preflightTaskCompletion(resolved[2], store, {
                 environment: process.env,
                 ...(taskFinalReviewContract === undefined
@@ -925,7 +937,17 @@ export async function main() {
                     : { taskFinalReviewContract })
             });
             if (!completion.completed && !completion.activeTaskReview) {
-                await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env, jobPort: createControllerIntegrationJobPort(home, { environment: process.env, store }) });
+                const freshness = await inspectTaskBaseFreshness(resolved[2], store, {
+                    refresh: refreshRemote
+                });
+                for (const warning of assertTaskBaseFreshnessForCompletion(freshness)) {
+                    process.stderr.write(`Warning: ${warning}\n`);
+                }
+                // Keep completion offline by default. An explicit refresh is the only
+                // path that may fetch and reconcile a moved remote baseline.
+                if (refreshRemote) {
+                    await reconcileTaskRemoteBaselines(resolved[2], store, home, { environment: process.env, jobPort: createControllerIntegrationJobPort(home, { environment: process.env, store }) });
+                }
             }
         }
         let candidateMaterialization;
@@ -943,6 +965,7 @@ export async function main() {
                 : candidateMaterialization.snapshot;
             const directTaskMainSnapshot = await directTaskMainSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
             const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
+            const deltaRecheckPreflight = await deltaRecheckPreflightForTaskCommand(resolved.slice(1), store, actualTaskReviewCandidate);
             const reviewWorkspaceResult = await reviewWorkspaceResultForTaskCommand(resolved, store, workspacePreparer, process.env);
             const executionLaneGitSnapshot = await executionLaneGitSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env);
             const laneSnapshotPreflight = executionLaneGitSnapshot === undefined
@@ -967,6 +990,9 @@ export async function main() {
                 ...(actualTaskReviewCandidate === undefined
                     ? {}
                     : { actualTaskReviewCandidate }),
+                ...(deltaRecheckPreflight === undefined
+                    ? {}
+                    : { deltaRecheckPreflight }),
                 ...(reviewWorkspaceResult === undefined ? {} : { reviewWorkspaceResult }),
                 ...(laneSnapshotPreflight === undefined ? {} : { executionLaneGitSnapshot: laneSnapshotPreflight }),
                 ...(taskRetirementProof === undefined ? {} : { taskRetirementProof })
@@ -1019,7 +1045,11 @@ export async function main() {
                             ...(freshTaskCandidate === undefined
                                 ? {}
                                 : { actualTaskReviewCandidate: freshTaskCandidate }),
-                            ...(executionLaneWorkspaces === undefined ? {} : { executionLaneWorkspaces })
+                            ...(executionLaneWorkspaces === undefined ? {} : { executionLaneWorkspaces }),
+                            ...(storedRound?.deltaRecheck === undefined
+                                || deltaRecheckPreflight === undefined
+                                ? {}
+                                : { deltaRecheckDiff: deltaRecheckPreflight.diffByProject })
                         });
                         reviewOutput = `Review queued as ${requestedRound.id} (${run.id})\n`;
                         reviewData = {
@@ -1628,6 +1658,64 @@ async function snapshotActualTaskReviewCandidate(taskId, store, preparer) {
             + `${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/**
+ * 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.
+ */
+async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReviewCandidate) {
+    if (args[0] !== "task" || args[1] !== "review" || args[2] !== "request") {
+        return undefined;
+    }
+    if (!args.includes("--delta-recheck"))
+        return undefined;
+    const taskId = args[3];
+    if (taskId === undefined)
+        return undefined;
+    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 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")))
+        .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
+        .at(-1);
+    if (previous === undefined) {
+        throw usageError("Delta-recheck requires a previous completed Task-final Review that accepted a head.");
+    }
+    const projectId = actualTaskReviewCandidate.projects[0].projectId;
+    const project = store.getProject(projectId);
+    if (project === null) {
+        throw usageError(`Delta-recheck Project not found: ${projectId}.`);
+    }
+    const assessment = await assessDeltaRecheck({
+        repositoryPath: project.path,
+        previousRound: previous,
+        candidate: actualTaskReviewCandidate,
+        git: new NodeGitWorkspace(),
+        config: reviewConfig
+    });
+    if (assessment.kind === "ineligible") {
+        throw usageError(`Delta-recheck is not allowed: ${assessment.reason} Request a full Review instead.`);
+    }
+    return assessment.preflight;
+}
 async function reviewWorkspaceResultForTaskCommand(args, store, preparer, environment) {
     if (args[0] !== "task" || args[1] !== "run" || args[2] !== "yield"
         || args[3] === undefined)