@zq-silk/yui 0.6.0 → 0.6.2

package/dist/commands/taskCompletionGate.js

@@ -27,6 +27,13 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
         || git.mergeRemoteIntoWorktree === undefined) {
         throw usageError(`Task ${task.id} cannot verify remote baselines: managed Git workspace support is unavailable.`);
     }
+    // A completed Task-final Review that exactly covers the current frozen heads
+    // is the final review evidence.  Do not reconcile the remote after a clean
+    // review, as merging a moved remote would change the reviewed head and
+    // invalidate the review.
+    if (await hasCompletedTaskFinalReviewForCurrentCandidate(store, task, workspace, git)) {
+        return [];
+    }
     const plans = [];
     for (const binding of task.projectBindings) {
         const project = store.getProject(binding.projectId);
@@ -41,6 +48,13 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
         }
         const currentCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
         const previousIntegration = latestCommittedIntegration(store, task.id, project.id);
+        // A completed Task-final Review for the exact current head freezes the
+        // Task baseline: the delivery has been reviewed and approved, so the
+        // completion gate must not merge remote changes that would invalidate
+        // the review evidence.
+        if (hasFrozenTaskBaseline(store, task.id, project.id, currentCommit)) {
+            continue;
+        }
         // Let the existing exact-head Task-final gate report local post-
         // Integration drift before attempting any network operation.  This keeps
         // completion read-only for an already-invalid candidate and preserves its
@@ -70,6 +84,13 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
     const reconciled = [];
     for (const plan of plans) {
         const attempt = store.transaction((tx) => {
+            // Re-check the frozen baseline inside the transaction: a Task-final
+            // Review may have completed during the async remote fetch, freezing
+            // the head after the initial check.  Creating a new Integration here
+            // would move the reviewed head and invalidate the review evidence.
+            if (hasFrozenTaskBaseline(tx, task.id, plan.project.id, plan.currentCommit)) {
+                return null;
+            }
             const created = createIntegrationAttempt({
                 id: tx.nextIntegrationAttemptId(task.id),
                 taskId: task.id,
@@ -82,11 +103,25 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
             tx.saveIntegrationAttempt(task.id, created);
             return created;
         });
+        if (attempt === null)
+            continue;
         const baseline = {
             remoteUrl: plan.project.remoteUrl,
             branch: plan.remote.branch
         };
-        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment).integrate(task.id, attempt.id, { remoteBaseline: baseline });
+        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment, undefined, options.jobPort).integrate(task.id, attempt.id, { remoteBaseline: baseline });
+        // rr6/f3: A moved remote with non-empty checks spawns a DurableJob. This
+        // is a pending completion outcome, not a failure: name the exact
+        // Integration and Job and the exact continuation command (mirroring the
+        // `task integration` checks-running message) so the caller can resume the
+        // same remote-reconciliation attempt instead of being blocked by the
+        // preflight's active-job/unresolved-Integration gates.
+        if (result.status === "checks-running") {
+            throw usageError(`Remote baseline reconciliation for ${task.id}/${plan.project.id} is running checks as `
+                + `Integration ${result.attempt.id} (DurableJob ${result.job.id}); run `
+                + `'yui task integration continue ${task.id}/${result.attempt.id}' when the job finishes, `
+                + `then retry task complete.`);
+        }
         if (result.status !== "committed" || result.attempt.candidateCommit === undefined) {
             const detail = result.attempt.checks?.find(({ outcome }) => outcome === "failed")?.details
                 ?? result.attempt.conflict?.summary
@@ -123,9 +158,51 @@ function requireTaskWorkspace(store, task) {
     }
     return workspace;
 }
+/**
+ * Check whether the latest Task-final ReviewRound is completed and its
+ * immutable candidate exactly matches the current actual heads for every
+ * Project in the Task.  When this holds, the reviewed head is the final
+ * head and remote reconciliation must not change it.
+ */
+async function hasCompletedTaskFinalReviewForCurrentCandidate(store, task, workspace, git) {
+    const rounds = store.listReviewRounds(task.id)
+        .filter((round) => (round.scope ?? "work-item") === "task")
+        .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
+    const latest = rounds.at(-1);
+    if (latest === undefined || latest.status !== "completed")
+        return false;
+    if (latest.taskCandidate === undefined)
+        return false;
+    const candidateProjects = new Map(latest.taskCandidate.projects.map((entry) => [entry.projectId, entry.commit]));
+    for (const binding of task.projectBindings) {
+        const reviewedCommit = candidateProjects.get(binding.projectId);
+        if (reviewedCommit === undefined)
+            return false;
+        const entry = workspaceProjectEntry(workspace, binding.projectId);
+        if (entry === undefined || entry.access !== "write")
+            return false;
+        const actualHead = (await git.inspect(entry.path, "HEAD")).baseCommit;
+        if (actualHead !== reviewedCommit)
+            return false;
+    }
+    return true;
+}
 function latestCommittedIntegration(store, taskId, projectId) {
     return store.listIntegrationAttempts(taskId)
         .filter((attempt) => attempt.projectId === projectId && attempt.status === "committed")
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
         .at(-1);
 }
+/**
+ * A Task baseline is frozen when a completed (clean) Task-final ReviewRound
+ * reviewed the exact current head for the given Project.  Once frozen, the
+ * completion gate skips remote baseline reconciliation to prevent merging
+ * unreviewed remote changes into the approved delivery.
+ */
+function hasFrozenTaskBaseline(store, taskId, projectId, currentCommit) {
+    return store.listReviewRounds(taskId)
+        .some((round) => ((round.scope ?? "work-item") === "task"
+        && round.status === "completed"
+        && round.taskCandidate !== undefined
+        && round.taskCandidate.projects.some((entry) => (entry.projectId === projectId && entry.commit === currentCommit))));
+}

package/dist/commands/taskContextCommand.js

@@ -3,6 +3,7 @@ import { taskMessageAuthorLabel } from "../message/message.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+import { projectNextAction } from "../task/nextAction.js";
 import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
@@ -31,6 +32,14 @@ export function runTaskContextCommand(args, store) {
             throw new Error(`Task execution projection disappeared: ${task.id}.`);
         }
         const roleSessionSets = reader.listRoleSessionSets(task.id);
+        const agentRuns = chronological(reader.listAgentRuns(task.id));
+        const reviewRounds = chronological(reader.listReviewRounds(task.id));
+        const changeSets = chronological(reader.listChangeSets(task.id));
+        const integrations = chronological(reader.listIntegrationAttempts(task.id));
+        const nextActionFacts = reader.readNextActionFacts(task.id);
+        if (nextActionFacts === null) {
+            throw new Error(`Task next-action facts disappeared: ${task.id}.`);
+        }
         return {
             task,
             execution,
@@ -44,17 +53,18 @@ export function runTaskContextCommand(args, store) {
             roleSessionSets,
             roleSessionRecoveries: roles.map((role) => (inspectTaskRoleSessionRecovery(task.id, role.name, reader))),
             workItems,
-            agentRuns: chronological(reader.listAgentRuns(task.id)),
-            reviewRounds: chronological(reader.listReviewRounds(task.id)),
-            changeSets: chronological(reader.listChangeSets(task.id)),
-            integrations: chronological(reader.listIntegrationAttempts(task.id)),
+            agentRuns,
+            reviewRounds,
+            changeSets,
+            integrations,
             messages: reader.listMessages(task.id),
             openInputRequests: inputRequests.filter((request) => request.status === "open"),
             resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
-            events: reader.listEvents(task.id)
+            events: reader.listEvents(task.id),
+            nextAction: projectNextAction(nextActionFacts)
         };
     });
-    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, messages, openInputRequests, resolvedInputRequests, events } = data;
+    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
@@ -67,6 +77,23 @@ export function runTaskContextCommand(args, store) {
         `Task context: ${task.id}`,
         `Title: ${compactText(task.title)}`,
         `Status: ${task.status}`,
+        "Next action:",
+        `  ${nextAction.kind}: ${nextAction.reason}`,
+        ...(nextAction.refs.length === 0
+            ? []
+            : [`  Refs: ${nextAction.refs.map(({ kind, id }) => `${kind} ${id}`).join(", ")}`]),
+        ...(nextAction.recommendedCommand === undefined
+            ? []
+            : [`  Recommended: ${nextAction.recommendedCommand}`]),
+        ...(nextAction.judgmentRequired === undefined
+            ? []
+            : [`  Judgment: ${nextAction.judgmentRequired}`]),
+        ...(nextAction.alternatives === undefined || nextAction.alternatives.length === 0
+            ? []
+            : [
+                "  Alternatives:",
+                ...nextAction.alternatives.map((alternative) => `    ${alternative.kind}: ${alternative.reason}`)
+            ]),
         ...(task.description === undefined ? [] : [`Description: ${compactText(task.description)}`]),
         ...(task.priority === undefined ? [] : [`Priority: ${task.priority}`]),
         ...(task.tags === undefined ? [] : [`Tags: ${task.tags.join(", ")}`]),

package/dist/commands/taskInputCommands.js

@@ -261,7 +261,7 @@ function assertInputCancelOrigin(store, request, environment) {
     }
     return "leader";
 }
-function isCurrentGlobalOperator(store, environment) {
+export function isCurrentGlobalOperator(store, environment) {
     if (environment.YUI_SESSION_SCOPE !== "global"
         || environment.YUI_ROLE !== "operator"
         || environment.YUI_TASK_ID !== undefined)

package/dist/commands/taskIntegrationCommands.js

@@ -3,23 +3,27 @@ import { resolveProject } from "../repository/project.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { createIntegrationAttempt, recordResolutionDecision, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
+import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
 import { taskActor } from "./taskActor.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
     const now = options.now ?? (() => new Date());
     const [command, ...rest] = args;
     if (command === "start")
-        return start(rest, store, home, now, options.environment);
+        return start(rest, store, home, now, options);
     if (command === "continue") {
-        return continueIntegration(rest, store, home, now, options.environment);
+        return continueIntegration(rest, store, home, now, options);
     }
     if (command === "resolve") {
         return resolveDecision(rest, store, now, options.environment);
     }
     if (command === "abort")
-        return abortIntegration(rest, store, now(), options.environment);
+        return abortIntegration(rest, store, now(), options);
+    if (command === "supersede")
+        return supersedeIntegrationCommand(rest, store, now(), options.environment);
     if (command === "cleanup") {
         return cleanupIntegration(rest, store, home, options.environment);
     }
@@ -27,6 +31,9 @@ export async function runTaskIntegrationCommand(args, store, home, options = {})
         return list(rest, store);
     if (command === "show")
         return show(rest, store, options.environment);
+    if (command === "queue") {
+        return runTaskIntegrationQueueCommand(rest, store, home, options);
+    }
     throw usageError(command === undefined
         ? "Task Integration command is required."
         : `Unknown command: task integration ${command}`);
@@ -36,9 +43,24 @@ async function cleanupIntegration(args, store, home, environment) {
         throw usageError("Task Integration cleanup usage: yui task integration cleanup <task>/<integration>.");
     }
     const integration = requireIntegration(store, args[0], environment);
-    if (integration.status !== "committed" && integration.status !== "failed") {
+    if (integration.status !== "committed"
+        && integration.status !== "superseded"
+        && integration.status !== "failed") {
         throw usageError(`Integration is not terminal: ${integration.id}/${integration.status}.`);
     }
+    // rr4/finding-5: An Integration Attempt with an active DurableJob cannot be
+    // cleaned up — the runner may still be using its worktree. Block on queued,
+    // running, and unacknowledged unknown-needs-attention jobs owned by it.
+    const activeIntegrationJob = store.listDurableJobs(integration.taskId).find((job) => (job.owner.kind === "integration-attempt"
+        && job.owner.integrationAttemptId === integration.id
+        && (job.status === "queued"
+            || job.status === "running"
+            || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined))));
+    if (activeIntegrationJob !== undefined) {
+        throw usageError(`Integration ${integration.id} has an active DurableJob: `
+            + `${activeIntegrationJob.id}/${activeIntegrationJob.status}. `
+            + "Cancel or acknowledge it before cleanup.");
+    }
     const result = await new GitIntegrationService(home, store).cleanup(integration);
     if (result === "dirty") {
         throw usageError(`Integration worktree contains unresolved or uncommitted changes: ${integration.id}. Inspect it before cleanup.`);
@@ -50,7 +72,7 @@ async function cleanupIntegration(args, store, home, environment) {
         data: { integrationId: integration.id, cleanup: result }
     };
 }
-async function start(args, store, home, now, environment) {
+async function start(args, store, home, now, options) {
     const usage = "Task Integration start usage: yui task integration start <task> [--project <project>] --change-set <id> [--change-set <id> ...] [--target <ref>] [--check <command> ...].";
     const parsed = parseRepeatable(args, new Set(["--change-set", "--check"]), new Set(["--project", "--target"]), usage);
     if (parsed.positionals.length !== 1)
@@ -70,9 +92,15 @@ async function start(args, store, home, now, environment) {
             throw usageError(`ChangeSet not found: ${id}.`);
         return changeSet;
     });
-    const reviewEvidence = new Set(store.listReviewRounds(task.id)
-        .flatMap(({ evidenceCommit }) => evidenceCommit === undefined ? [] : [evidenceCommit]));
-    const reviewSource = changeSets.find(({ headCommit }) => reviewEvidence.has(headCommit));
+    // Only diagnostic evidence commits (a reviewer's own commit on top of the
+    // frozen base) are barred from becoming an Integration source.  A clean
+    // review attests the frozen base itself (evidenceCommit === reviewBaseCommit),
+    // which is the candidate's own head and a legitimate source.
+    const diagnosticEvidence = new Set(store.listReviewRounds(task.id)
+        .flatMap(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit
+        ? [evidenceCommit]
+        : []));
+    const reviewSource = changeSets.find(({ headCommit }) => diagnosticEvidence.has(headCommit));
     if (reviewSource !== undefined) {
         throw usageError(`ReviewRound evidence commit cannot become an Integration source: ${reviewSource.id}.`);
     }
@@ -101,7 +129,16 @@ async function start(args, store, home, now, environment) {
         throw usageError(`Task main worktree is not ready; reconcile the Task first: ${task.id}.`);
     }
     const expectedHead = (await new NodeGitWorkspace().inspect(project.path, targetRef)).baseCommit;
+    // The duplicate/budget preflight runs inside the same transaction as the
+    // attempt insert: on the single-writer SQLite backend the check and the
+    // record creation are atomic, so a concurrent Leader cannot sneak a
+    // duplicate Integration between the guard and the write.
     const integration = store.transaction((tx) => {
+        const guard = runDeliveryGuardPreflight(tx, task.id, {
+            kind: "integration-start",
+            projectId: project.id,
+            changeSetIds
+        }, { environment: options.environment, budget: true });
         const created = createIntegrationAttempt({
             id: tx.nextIntegrationAttemptId(task.id),
             taskId: task.id,
@@ -112,32 +149,38 @@ async function start(args, store, home, now, environment) {
             checkCommands: parsed.many.get("--check") ?? []
         }, now());
         tx.saveIntegrationAttempt(task.id, created);
-        return created;
+        return { attempt: created, guard };
     });
-    return runIntegration(store, home, integration, now, environment);
+    const result = await runIntegration(store, home, integration.attempt, now, options);
+    return {
+        ...result,
+        output: withGuardWarnings(integration.guard, result.output)
+    };
 }
-async function continueIntegration(args, store, home, now, environment) {
+async function continueIntegration(args, store, home, now, options) {
     const usage = "Task Integration continue usage: yui task integration continue <task>/<integration>.";
     const parsed = parseRepeatable(args, new Set(), new Set(), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
-    const integration = requireIntegration(store, parsed.positionals[0], environment);
+    const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
     if (integration.status !== "validating"
+        && integration.status !== "running"
         && (integration.status !== "blocked"
             || integration.resolution?.action !== "manual-resolution")) {
         throw usageError(`Integration is not ready to continue: ${integration.id}/${integration.status}.`);
     }
-    return runIntegration(store, home, integration, now, environment);
+    return runIntegration(store, home, integration, now, options);
 }
-async function runIntegration(store, home, integration, now, environment) {
-    const result = await new GitIntegrationService(home, store, undefined, now, environment)
-        .integrate(integration.taskId, integration.id);
+async function runIntegration(store, home, integration, now, options) {
+    const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id);
     const output = result.status === "committed"
         ? `Integrated ${result.attempt.changeSetIds.join(", ")} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
         : result.status === "blocked"
             ? `Integration ${result.attempt.id} requires a Leader resolution decision in ${result.workspace.path}\n`
-            : `Integration ${result.attempt.id} failed; target ref was not advanced\n`;
+            : result.status === "checks-running"
+                ? `Integration ${result.attempt.id} checks are running as DurableJob ${result.job.id}; run 'yui task integration continue ${result.attempt.taskId}/${result.attempt.id}' when the job finishes\n`
+                : `Integration ${result.attempt.id} failed; target ref was not advanced\n`;
     return { output, data: result };
 }
 function resolveDecision(args, store, now, environment) {
@@ -166,12 +209,12 @@ function resolveDecision(args, store, now, environment) {
         data: { integration: resolved }
     };
 }
-function abortIntegration(args, store, now, environment) {
+async function abortIntegration(args, store, now, options) {
     const usage = "Task Integration abort usage: yui task integration abort <task>/<integration> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
-    const integration = requireIntegration(store, parsed.positionals[0], environment);
+    const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
     if (integration.status !== "running" && integration.status !== "blocked") {
         throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
@@ -179,18 +222,77 @@ function abortIntegration(args, store, now, environment) {
     const reason = parsed.one.get("--reason");
     if (reason === undefined)
         throw usageError(usage);
-    const aborted = updateIntegrationAttempt(integration, {
-        status: "failed",
-        checks: [
-            ...(integration.checks ?? []),
-            { name: "aborted", outcome: "failed", details: reason }
-        ]
-    }, now);
-    store.saveIntegrationAttempt(aborted.taskId, aborted);
-    return {
-        output: `Aborted Integration ${aborted.id}; start a new Integration Attempt to retry\n`,
-        data: { integration: aborted }
-    };
+    if (integration.jobId !== undefined && options.jobPort !== undefined) {
+        await options.jobPort.cancelJob(integration.taskId, integration.jobId);
+    }
+    return store.transaction((tx) => {
+        // Re-read inside the transaction: a concurrent `continue` can advance the
+        // Attempt to validating (and then commit the target) after the initial
+        // read.  Aborting a validating or committed Attempt would leave the
+        // target advanced while the Attempt is failed.
+        const current = tx.getIntegrationAttempt(integration.taskId, integration.id);
+        if (current === null) {
+            throw usageError(`Integration Attempt not found: ${integration.taskId}/${integration.id}.`);
+        }
+        if (current.status !== "running" && current.status !== "blocked") {
+            throw usageError(`Integration cannot be aborted from ${current.status}: ${current.id}.`);
+        }
+        const aborted = updateIntegrationAttempt(current, {
+            status: "failed",
+            checks: [
+                ...(current.checks ?? []),
+                { name: "aborted", outcome: "failed", details: reason }
+            ]
+        }, now);
+        tx.saveIntegrationAttempt(aborted.taskId, aborted);
+        return {
+            output: `Aborted Integration ${aborted.id}; start a new Integration Attempt to retry\n`,
+            data: { integration: aborted }
+        };
+    });
+}
+function supersedeIntegrationCommand(args, store, now, environment) {
+    const usage = "Task Integration supersede usage: yui task integration supersede <task>/<integration> --reason <text>.";
+    const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const integration = requireIntegration(store, parsed.positionals[0], environment);
+    requireActiveIntegrationTask(store, integration);
+    if (integration.status !== "committed") {
+        throw usageError(`Integration cannot be superseded from ${integration.status}: ${integration.id}.`);
+    }
+    const reason = parsed.one.get("--reason");
+    if (reason === undefined)
+        throw usageError(usage);
+    // Only the Task Leader (or Operator/user) may supersede a committed
+    // Integration: it rewrites delivery-baseline evidence and audit history.
+    taskActor(environment, integration.taskId);
+    // A queue-backed committed Attempt cannot be superseded: the queue entry
+    // would remain in its current status while its Attempt becomes "superseded",
+    // leaving contradictory terminal records that never converge. This covers
+    // the crash window where the entry is still "running" or "conflicted" after
+    // the Attempt committed.
+    const queueBacked = store.listIntegrationQueueEntries(integration.taskId)
+        .some((entry) => entry.integrationAttemptId === integration.id);
+    if (queueBacked) {
+        throw usageError(`Integration ${integration.id} is backed by a queue entry; `
+            + "reconcile the queue entry instead of superseding its Attempt.");
+    }
+    return store.transaction((tx) => {
+        const current = tx.getIntegrationAttempt(integration.taskId, integration.id);
+        if (current === null) {
+            throw usageError(`Integration Attempt not found: ${integration.taskId}/${integration.id}.`);
+        }
+        if (current.status !== "committed") {
+            throw usageError(`Integration cannot be superseded from ${current.status}: ${current.id}.`);
+        }
+        const superseded = supersedeIntegration(current, reason, now);
+        tx.saveIntegrationAttempt(superseded.taskId, superseded);
+        return {
+            output: `Superseded Integration ${superseded.id}; the next valid committed Integration is now the delivery baseline\n`,
+            data: { integration: superseded }
+        };
+    });
 }
 function requireActiveIntegrationTask(store, integration) {
     const task = store.getTask(integration.taskId);
@@ -237,6 +339,7 @@ function show(args, store, environment) {
             `Target: ${integration.targetRef}`,
             `Expected head: ${integration.expectedHead}`,
             `Candidate: ${integration.candidateCommit ?? "-"}`,
+            `Job: ${integration.jobId ?? "-"}`,
             `ChangeSets: ${integration.changeSetIds.join(", ")}`,
             `Status: ${integration.status}`,
             `Conflict: ${integration.conflict?.summary ?? "-"}`,
@@ -273,7 +376,7 @@ function requireIntegration(store, value, environment) {
     }
     return attempt;
 }
-function parseRepeatable(args, repeatable, singular, usage) {
+export function parseRepeatable(args, repeatable, singular, usage) {
     const positionals = [];
     const many = new Map();
     const one = new Map();