@zq-silk/yui 0.16.1 → 0.16.2

package/dist/commands/taskCommands.js

@@ -1,10 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
-import { createRun, runExecutionObservation, runPurposeAdmitsTaskState, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { createRun, runExecutionObservation, runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
-import { buildRunContextDelta, buildRunContextPack, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
+import { buildRunContextDelta, buildRunContextPack, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { parseTaskCatalogOptions, readTaskCatalog, renderTaskCatalog } from "../context/taskCatalog.js";
 import { listContextMessages } from "../context/taskContext.js";
@@ -16,7 +16,7 @@ import { dispatchReviewSynthesis, selectedReviewSynthesisProducers } from "../ex
 import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
 import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
 import { dispatchWorkItemSynthesis, selectedWorkItemSynthesisProducers } from "../execution/workItemMainRun.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode, taskRoleControlTarget, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, roleSessionControlTarget, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { retireExactActiveRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
@@ -233,16 +233,17 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
         taskId: parsed.positionals[0],
         summary,
         artifactRefs: parsed.multiOptions.get("--artifact-ref") ?? [],
+        refreshRemote: parsed.options.has("--refresh-remote"),
         ...(acceptedPublishedTreePublicationId === undefined
             ? {}
             : { acceptedPublishedTreePublicationId })
     };
 }
 /**
- * Check every read-only completion blocker before a caller resolves remote
- * baselines or creates an Integration Attempt.  The transactional completion
+ * Check every read-only completion blocker before a caller observes remote
+ * baselines. The transactional completion
  * path invokes this same preflight and then repeats its checks while holding
- * the store write fence, so remote reconciliation can never get ahead of the
+ * the store write fence, so remote observation can never get ahead of the
  * local lifecycle/readiness gate.
  *
  * Issue 06: the blocker enumeration is the pure `projectCompletionReadiness`
@@ -262,7 +263,7 @@ export function preflightTaskCompletion(taskId, store, options = {}, _request =
     if (task.status !== "active")
         throw usageError(`Task is not active: ${task.id}.`);
     // Resolve the durable Task-local Reviewer policy before any remote fetch or
-    // Integration write. Historical control-plane identity is audit evidence,
+    // final Review preparation. Historical control-plane identity is audit evidence,
     // not a capability that every compatible CLI must reproduce.
     const taskFinalReviewContract = taskFinalReviewContractForMutation(store, task.id, options);
     const activeTaskReview = store.listReviewRounds(task.id).some((round) => (round.scope === "task"
@@ -274,7 +275,7 @@ export function preflightTaskCompletion(taskId, store, options = {}, _request =
     const readiness = projectCompletionReadiness(readinessFacts);
     // An active Task-final Review is not a preflight failure: the transactional
     // path resumes a pending Round (or reports the running one) via
-    // `prepareFinalTaskReview`, and the CLI skips remote reconciliation while
+    // `prepareFinalTaskReview`, and the CLI skips remote observation while
     // `activeTaskReview` is true.  The blocker stays in the shared projection
     // so other surfaces (next-action, future readers) see the full rule set.
     const blockers = readiness.blockers.filter((blocker) => blocker.code !== "active-task-review");
@@ -1055,6 +1056,7 @@ function completeTaskCommand(args, store, options) {
             return {
                 task,
                 changed: false,
+                projectHeads: undefined,
                 completionAdvisories: [],
                 finalReview: undefined
             };
@@ -1076,6 +1078,7 @@ function completeTaskCommand(args, store, options) {
             return {
                 task,
                 changed: false,
+                projectHeads: actualTaskCandidate?.projects ?? [],
                 completionAdvisories: [],
                 finalReview,
             };
@@ -1167,6 +1170,7 @@ function completeTaskCommand(args, store, options) {
         return {
             task: completed,
             changed: true,
+            projectHeads: actualTaskCandidate?.projects ?? [],
             completionAdvisories: readiness.advisories,
             finalReview: undefined
         };
@@ -1174,13 +1178,21 @@ function completeTaskCommand(args, store, options) {
     if (result.changed) {
         notifyMailbox(options.runtime, { kind: "operator" });
     }
+    const headOutput = (result.projectHeads ?? []).map(({ projectId, commit }) => (`Task HEAD ${projectId}: ${commit}\n`)).join("");
     if (result.finalReview !== undefined) {
-        const status = result.finalReview.status === "pending"
-            ? `Final Task Review requested as ${result.finalReview.id}.`
-            : `Final Task Review is blocked: ${result.finalReview.failure?.message ?? result.finalReview.id}.`;
-        return output(`${status}\n`, {
+        const round = result.finalReview;
+        const stage = round.status === "pending" ? "review-pending"
+            : round.status === "running" ? "review-running" : "review-blocked";
+        const status = round.status === "pending"
+            ? `Final Task Review requested as ${round.id}.`
+            : round.status === "running"
+                ? `Final Task Review is still running: ${round.id}.`
+                : `Final Task Review ${round.id} is blocked: ${round.failure?.message ?? round.status}.`;
+        return output(`${status}\nTask ${result.task.id} remains active.\n${headOutput}`, {
+            stage,
             task: result.task,
-            reviewRound: result.finalReview
+            projectHeads: result.projectHeads,
+            reviewRound: round
         });
     }
     const completionOutput = result.changed
@@ -1190,8 +1202,10 @@ function completeTaskCommand(args, store, options) {
         ? ""
         : `Cleanup advisories (non-blocking; settle before archive):\n`
             + result.completionAdvisories.map((advisory) => (`- ${advisory.code} (${advisory.ref.kind} ${advisory.ref.id}): ${advisory.fix}`)).join("\n").concat("\n");
-    return output(completionOutput + advisoryOutput, {
+    return output(completionOutput + headOutput + advisoryOutput, {
+        stage: result.changed ? "completed" : "already-completed",
         task: result.task,
+        ...(result.projectHeads === undefined ? {} : { projectHeads: result.projectHeads }),
         completionAdvisories: result.completionAdvisories
     });
 }
@@ -2534,7 +2548,7 @@ function taskRoleSessionCommand(args, store, options) {
                 throw usageError("Use task role session new to request your own replacement and end this turn; synchronous self-stop cannot return.", usage);
             }
             const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
-            const session = taskRoleControlTarget(sessions);
+            const session = roleSessionControlTarget(sessions);
             if (session === undefined || session.adapterId === undefined) {
                 throw usageError(`Task Role has no active Session: ${task.id}/${role.name}.`, usage);
             }
@@ -3494,38 +3508,36 @@ function dispatchWork(args, store, options) {
                 workspace,
                 workItemWriteProjectIds: item.writeProjectIds
             });
+            tx.saveWorkItem(task.id, workItemForDispatch);
             const runId = tx.nextRunId(task.id);
+            const snapshot = freezeRunContextSnapshot(tx, {
+                taskId: task.id,
+                roleName: role.name,
+                purpose: "execution",
+                workItemId: item.id,
+                workspace
+            }, now, "controller");
             const run = createRun(runId, task.id, role.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(task.id, role.name), effective.agentId, effective), createRunInput({
                 source: { type: "yui", channel: "workitem-dispatch" },
                 directive: rawInput,
-                deltaRefIds: []
+                contextSnapshotRef: contextSnapshotRef(snapshot),
+                deltaRefIds: contextSnapshotDeltaRefIds(tx, snapshot)
             }), now, {
                 workItemId: item.id,
                 workspace,
                 effective
             });
-            const snapshot = freezeRunContextSnapshot(tx, {
-                taskId: task.id,
-                roleName: run.roleName,
-                purpose: "execution",
-                workItemId: item.id
-            }, now, "controller");
-            const withContext = withRunContextSnapshot(run, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            if (workItemForDispatch.status !== "open") {
-                workItemForDispatch = updateWorkItemStatus(workItemForDispatch, "open", now);
-            }
-            tx.saveWorkItem(task.id, workItemForDispatch);
-            tx.saveRun(withContext);
-            tx.saveActiveRun(withContext);
+            tx.saveRun(run);
+            tx.saveActiveRun(run);
             enqueueRoleRunDispatch(tx, {
                 taskId: task.id,
                 roleName: role.name,
-                runId: withContext.id,
+                runId: run.id,
                 reason: "turn-dispatched",
                 occurredAt: now
             });
-            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(withContext), now);
-            return { kind: "direct", runs: [withContext] };
+            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(run), now);
+            return { kind: "direct", runs: [run] };
         }
         const groupId = `execution-group-${tx.peekNextRunId(task.id)}`;
         if (workItemForDispatch !== item) {
@@ -3597,10 +3609,18 @@ function dispatchWork(args, store, options) {
         }
         tx.saveWorkItem(task.id, workItemForDispatch);
         const runs = plans.map((plan, index) => {
+            const snapshot = freezeRunContextSnapshot(tx, {
+                taskId: task.id,
+                roleName: plan.role.name,
+                purpose: "execution",
+                workItemId: item.id,
+                workspace: plan.managedWorkspace
+            }, now, "controller", assignment.contextSnapshotRef);
             const run = createRun(plan.runId, task.id, plan.role.name, plan.dispatchMode, createRunInput({
                 source: { type: "yui", channel: "workitem-dispatch" },
                 directive: assignment.input,
-                deltaRefIds: []
+                contextSnapshotRef: contextSnapshotRef(snapshot),
+                deltaRefIds: contextSnapshotDeltaRefIds(tx, snapshot)
             }), now, {
                 workItemId: item.id,
                 executionGroupId: group.id,
@@ -3608,28 +3628,21 @@ function dispatchWork(args, store, options) {
                 workspace: plan.managedWorkspace,
                 effective: plan.effective
             });
-            const snapshot = freezeRunContextSnapshot(tx, {
-                taskId: task.id,
-                roleName: run.roleName,
-                purpose: "execution",
-                workItemId: item.id
-            }, now, "controller", assignment.contextSnapshotRef);
-            const withContext = withRunContextSnapshot(run, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
             const prepared = options.executionLaneWorkspaces?.get(group.lanes[index].id);
             if (prepared !== undefined && tx.getManagedWorkspace(prepared.owner) === null) {
                 tx.saveManagedWorkspace(prepared);
             }
-            tx.saveRun(withContext);
-            tx.saveActiveRun(withContext);
+            tx.saveRun(run);
+            tx.saveActiveRun(run);
             enqueueRoleRunDispatch(tx, {
                 taskId: task.id,
                 roleName: plan.role.name,
-                runId: withContext.id,
+                runId: run.id,
                 reason: "turn-dispatched",
                 occurredAt: now
             });
-            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(withContext), now);
-            return withContext;
+            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(run), now);
+            return run;
         });
         return { kind: "replicated", runs };
     });
@@ -4590,7 +4603,6 @@ function retireRun(args, store, options) {
     const parsed = parseTail(args, new Set([
         "--reason",
         "--expected-progress-at",
-        "--progress-at",
         "--agent-id",
         "--adapter-id",
         "--native-session-id"
@@ -4611,12 +4623,7 @@ function retireRun(args, store, options) {
             return { task, run: run, changed: false };
         }
         if (run.status === "active") {
-            const expectedProgressAt = requiredOption(parsed.options, parsed.options.has("--expected-progress-at")
-                ? "--expected-progress-at"
-                : "--progress-at");
-            if (parsed.options.has("--expected-progress-at") && parsed.options.has("--progress-at")) {
-                throw usageError("--expected-progress-at and --progress-at are mutually exclusive.", usage);
-            }
+            const expectedProgressAt = requiredOption(parsed.options, "--expected-progress-at");
             const agentId = requiredOption(parsed.options, "--agent-id");
             const adapterId = requiredOption(parsed.options, "--adapter-id");
             const nativeSessionId = parsed.options.get("--native-session-id");
@@ -4646,11 +4653,9 @@ function retireRun(args, store, options) {
             runId: run.id,
             reason,
             ...(parsed.options.get("--expected-progress-at") === undefined
-                && parsed.options.get("--progress-at") === undefined
                 ? {}
                 : {
                     expectedProgressAt: parsed.options.get("--expected-progress-at")
-                        ?? parsed.options.get("--progress-at")
                 }),
             ...(parsed.options.get("--native-session-id") === undefined
                 ? {}
@@ -4679,16 +4684,17 @@ function retireRun(args, store, options) {
 function runContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
-        const usage = "Task run context expand usage: yui task run context expand <task>/<run> <ref-id> [--store <store>] [--mode full].";
+        const usage = "Task run context expand usage: yui task run context expand <task>/<run> <ref-id> --store <store> [--mode full].";
         const parsed = parseTail(rest, new Set(["--store", "--mode"]), usage);
         exactPositionals(parsed.positionals, 2, usage);
+        const refStore = requiredOption(parsed.options, "--store");
         const mode = parsed.options.get("--mode");
         if (mode !== undefined && mode !== "full") {
             throw usageError("AgentRun Context expansion mode must be full.", usage);
         }
         const { taskId, runId } = parseRunContextReference(parsed.positionals[0]);
         authorizeRunContext(store, taskId, runId, options.environment);
-        const expanded = store.transaction((tx) => expandRunContextRef(tx, taskId, runId, parsed.positionals[1], optionalNonEmptyOption(parsed.options, "--store")));
+        const expanded = store.transaction((tx) => expandRunContextRef(tx, taskId, runId, parsed.positionals[1], refStore));
         return output(`${JSON.stringify(expanded, null, 2)}\n`, { context: expanded });
     }
     if (first === "delta") {
@@ -4908,7 +4914,11 @@ function retryRun(args, store, options) {
 function retryRunOperation(args, store, options) {
     exactPositionals(args, 1, "Task run retry usage: yui task run retry <task>/<run>.");
     const now = clock(options);
-    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
+    const previous = store.transaction((tx) => {
+        const run = requireRun(tx, args[0], options);
+        readRunContextSnapshot(tx, run);
+        return run;
+    });
     if (previous.purpose === "review") {
         return retryFailedReviewRun(previous, store, options, now);
     }
@@ -5008,13 +5018,6 @@ function retryRunOperation(args, store, options) {
         }
         if (retryItem !== null)
             assertWorkItemDependenciesCompletedForCommand(tx, retryItem);
-        const runWorkspace = previous.workspace
-            ?? (retryItem === null
-                ? tx.getTaskWorkspace(task.id)
-                : retryItem.assignee === "leader"
-                    ? tx.getTaskWorkspace(task.id)
-                    : tx.getWorkItemWorkspace(task.id, retryItem.id))
-            ?? undefined;
         const retryGroup = retryItem === null || previous.executionGroupId === undefined
             ? undefined
             : workItemExecutionGroupById(retryItem, previous.executionGroupId);
@@ -5029,7 +5032,7 @@ function retryRunOperation(args, store, options) {
                     || retryLane === undefined))) {
             throw dataError(`AgentRun ${previous.id} execution lineage no longer matches its Work Item.`);
         }
-        const retryManagedWorkspace = retryLane === undefined ? runWorkspace : previous.workspace;
+        const retryManagedWorkspace = previous.workspace;
         if (retryLane !== undefined) {
             const storedLaneWorkspace = previous.workspace === undefined
                 ? null
@@ -5119,6 +5122,7 @@ function retryRunOperation(args, store, options) {
                     taskId: task.id,
                     roleName: role.name,
                     purpose: previous.purpose,
+                    ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
                     ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId })
                 }, now, "controller", retryGroup?.assignment.contextSnapshotRef);
                 return createRunInput({
@@ -5370,7 +5374,7 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
     const config = taskFinalReviewConfig(taskFinalContract);
     const latest = establishedRound;
     if (latest?.status === "running") {
-        throw usageError(`Final Task Review is still active: ${latest.id}/${latest.status}.`);
+        return latest;
     }
     if (latest?.status === "pending") {
         return resumablePendingFinalTaskReview(store, task, latest, config, latest.taskCandidate, taskFinalContract, options);
@@ -6116,7 +6120,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 roleName: reviewer.name,
                 purpose: "review",
                 ...(item === undefined ? {} : { workItemId: item.id }),
-                reviewRoundId: round.id
+                reviewRoundId: round.id,
+                workspace: round.workspace
             }, now, "controller");
             const created = createRun(runId, taskId, reviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(taskId, reviewer.name), effective.agentId, effective), createRunInput({
                 source: {
@@ -6173,6 +6178,14 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 reviewBaseCommit: round.reviewBaseCommit
             });
             const runId = tx.nextRunId(taskId);
+            const snapshot = freezeRunContextSnapshot(tx, {
+                taskId,
+                roleName: laneReviewer.name,
+                purpose: "review",
+                ...(item === undefined ? {} : { workItemId: item.id }),
+                reviewRoundId: round.id,
+                workspace: laneManagedWorkspace
+            }, now, "controller", runningGroup.assignment.contextSnapshotRef);
             const input = createRunInput({
                 source: {
                     type: "yui",
@@ -6192,7 +6205,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                         assignment: runningGroup.assignment
                     }, null, 2)
                 ].join("\n"),
-                deltaRefIds: []
+                contextSnapshotRef: contextSnapshotRef(snapshot),
+                deltaRefIds: contextSnapshotDeltaRefIds(tx, snapshot)
             });
             runningGroup = updateUnifiedExecutionLane(runningGroup, lane.id, {
                 currentRunId: runId,
@@ -6226,23 +6240,12 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                     tx.saveManagedWorkspace(prepared);
             }
         }
-        for (let index = 0; index < createdRuns.length; index += 1) {
-            const unboundRun = createdRuns[index];
-            const snapshot = freezeRunContextSnapshot(tx, {
-                taskId,
-                roleName: unboundRun.roleName,
-                purpose: "review",
-                ...(item === undefined ? {} : { workItemId: item.id }),
-                reviewRoundId: round.id
-            }, now, "controller", runningGroup.assignment.contextSnapshotRef);
-            const created = withRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            createdRuns[index] = created;
-            const laneReviewer = requireRole(tx, taskId, unboundRun.roleName);
+        for (const created of createdRuns) {
             tx.saveRun(created);
             tx.saveActiveRun(created);
             enqueueRoleRunDispatch(tx, {
                 taskId,
-                roleName: laneReviewer.name,
+                roleName: created.roleName,
                 runId: created.id,
                 reason: "review-requested",
                 occurredAt: now

package/dist/commands/taskCompletionGate.js

@@ -1,6 +1,4 @@
 import { usageError } from "../errors/cliError.js";
-import { GitIntegrationService } from "../integration/gitIntegrationService.js";
-import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { isCompletedTaskReviewEvidence } from "../review/reviewAcceptance.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
@@ -150,121 +148,6 @@ function sameTaskCandidate(left, right) {
         && left.projects.every((project, index) => (project.projectId === right.projects[index]?.projectId
             && project.commit === right.projects[index]?.commit));
 }
-/**
- * Reconcile configured remote baselines before a Task completion attempt.
- *
- * Remote resolution and fetches happen from the Task's managed worktree.  A
- * moved remote is represented by a normal upstream Integration Attempt. The
- * normal check and CAS path advances only the Task clone; stable Project
- * checkouts are never refreshed or otherwise mutated here.
- */
-export async function reconcileTaskRemoteBaselines(taskId, store, home, options = {}) {
-    const task = store.getTask(taskId);
-    if (task === null)
-        throw usageError(`Task not found: ${taskId}.`);
-    if (task.projectBindings.length === 0) {
-        return [];
-    }
-    const workspace = requireTaskWorkspace(store, task);
-    const git = options.git ?? new NodeGitWorkspace();
-    if (git.fetchRemoteHeadIntoWorktree === undefined) {
-        throw usageError(`Task ${task.id} cannot verify remote baselines: managed Git workspace support is unavailable.`);
-    }
-    const plans = [];
-    for (const binding of task.projectBindings) {
-        const project = store.getProject(binding.projectId);
-        if (project === null) {
-            throw usageError(`Project not found for Task ${task.id}: ${binding.projectId}.`);
-        }
-        if (project.remoteUrl === undefined)
-            continue;
-        const entry = workspaceProjectEntry(workspace, project.id);
-        if (entry === undefined || entry.access !== "write") {
-            throw usageError(`Task ${task.id} has no writable managed main workspace for remote Project ${project.id}.`);
-        }
-        const currentCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        if (binding.currentCommit !== currentCommit || binding.baseCommit === undefined) {
-            throw usageError(`Project ${project.id} Task commit record does not match its authoritative main clone.`);
-        }
-        const remote = await fetchRemote(git, entry, project);
-        if (remote.commit === currentCommit)
-            continue;
-        if (await git.isAncestor(entry.path, remote.commit, currentCommit))
-            continue;
-        if (!await git.isClean(entry.path)) {
-            throw usageError(`Project ${project.id} managed Task workspace is dirty; commit or clean it before remote reconciliation.`);
-        }
-        plans.push({
-            project,
-            entry,
-            remote,
-            currentCommit,
-            taskBaseCommit: binding.baseCommit
-        });
-    }
-    const reconciled = [];
-    for (const plan of plans) {
-        const attempt = store.transaction((tx) => {
-            const created = createIntegrationAttempt({
-                id: tx.nextIntegrationAttemptId(task.id),
-                taskId: task.id,
-                projectId: plan.project.id,
-                targetRef: plan.entry.branch,
-                beforeCommit: plan.currentCommit,
-                source: {
-                    kind: "upstream",
-                    branch: plan.remote.branch,
-                    remoteCommit: plan.remote.commit,
-                    taskBaseCommit: plan.taskBaseCommit,
-                    strategy: "rebase"
-                },
-                checkCommands: []
-            }, options.now?.() ?? new Date());
-            tx.saveIntegrationAttempt(task.id, created);
-            return created;
-        });
-        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment, undefined, options.jobPort).integrate(task.id, attempt.id);
-        // 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
-                ?? result.attempt.status;
-            throw usageError(`Remote baseline reconciliation failed for ${task.id}/${plan.project.id}: ${detail}`);
-        }
-        reconciled.push({
-            projectId: plan.project.id,
-            remote: plan.remote,
-            fromCommit: plan.currentCommit,
-            toCommit: result.attempt.candidateCommit,
-            integrationId: attempt.id
-        });
-    }
-    return reconciled;
-}
-async function fetchRemote(git, entry, project) {
-    try {
-        return await git.fetchRemoteHeadIntoWorktree({
-            repositoryPath: entry.path,
-            remoteUrl: project.remoteUrl,
-            branch: project.developmentBranch
-        });
-    }
-    catch (error) {
-        throw usageError(`Project ${project.id} remote target could not be resolved; completion is fail-closed: `
-            + `${error instanceof Error ? error.message : String(error)}`);
-    }
-}
 function requireTaskWorkspace(store, task) {
     const workspace = store.getTaskWorkspace(task.id);
     if (workspace === null || workspace.owner.type !== "task") {

package/dist/commands/taskRoleRuntimeStatus.js

@@ -18,7 +18,7 @@ export function taskRoleHostDiagnostic(host) {
     const delivery = snapshot.eventDelivery;
     return [
         `Provider Host=${snapshot.state}`,
-        delivery === undefined ? "event delivery=unreported (legacy Host)" :
+        delivery === undefined ? "event delivery=unreported" :
             `pending facts=${delivery.pending}; native terminals awaiting acknowledgement=${delivery.pendingTerminals}`,
         delivery?.failure === undefined ? undefined :
             `reporting failure (${delivery.failure.stage}, ${delivery.failure.observedAt}): ${delivery.failure.detail}`,