@zq-silk/yui 0.14.0 → 0.14.2

package/dist/integration/gitIntegrationService.js

@@ -15,6 +15,7 @@ import { resolveWorktreeRoot } from "../repository/taskWorkspacePreparer.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
 import { taskWorkspaceRefSegment } from "../repository/taskWorkspaceIdentity.js";
 import { FileTaskRuntimeIsolation } from "../runtime/taskRuntimeIsolation.js";
+import { advanceTaskProjectCommit } from "../task/task.js";
 import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { recordIntegrationCheckJob, requireResolutionDecision, updateIntegrationAttempt } from "./integrationAttempt.js";
 import { createManagedWorkspace } from "../worktree/managedWorkspace.js";
@@ -51,7 +52,9 @@ const INTEGRATION_OPERATIONAL_ENVIRONMENT_NAMES = [
     "CURL_CA_BUNDLE",
     "REQUESTS_CA_BUNDLE"
 ];
-export const REMOTE_BASELINE_CONFLICT_PREFIX = "Remote baseline merge conflicts";
+export const REMOTE_BASELINE_CONFLICT_PREFIX = "Upstream rebase conflicts";
+const WORK_ITEM_MERGE_CONFLICT_PREFIX = "WorkItem merge conflicts";
+const MANUAL_INTEGRATION_PREFIX = "Manual WorkItem integration";
 export class GitIntegrationService {
     store;
     git;
@@ -75,7 +78,7 @@ export class GitIntegrationService {
     #resourceRegistrar() {
         return this.#resourceRegistrarValue ??= new ResourceRegistrar(this.home, this.now);
     }
-    async integrate(taskId, integrationId, options = {}) {
+    async integrate(taskId, integrationId) {
         const initial = requireIntegration(this.store, taskId, integrationId);
         // The whole Integration is one Git transaction against the Project's
         // repository: worktree creation, cherry-picks, checks, and the target ref
@@ -94,6 +97,13 @@ export class GitIntegrationService {
             const project = this.store.getProject(initial.projectId);
             if (project === null)
                 throw new Error(`Project not found: ${initial.projectId}.`);
+            const taskWorkspace = this.store.getTaskWorkspace(task.id);
+            const taskRepository = taskWorkspace?.entries.find(({ projectId }) => projectId === project.id)?.path;
+            if (taskWorkspace === null
+                || taskWorkspace.owner.type !== "task"
+                || taskRepository === undefined) {
+                throw new Error(`Integration Task clone is unavailable: ${task.id}/${project.id}.`);
+            }
             // Issue 08: a Project with a VerificationPlan gates through its plan
             // (bootstrap + L2) and reuses exact-SHA artifacts; an unconfigured
             // Project keeps the existing explicit check path unchanged.
@@ -103,11 +113,11 @@ export class GitIntegrationService {
             let managedWorkspace;
             try {
                 prepared = await this.git.ensureIntegrationWorktree({
-                    repositoryPath: project.path,
+                    repositoryPath: taskRepository,
                     container: join(this.worktreeRoot, project.name),
                     taskSegment: taskWorkspaceRefSegment(task),
                     integrationId: initial.id,
-                    baseRef: initial.expectedHead
+                    baseRef: initial.beforeCommit
                 });
                 workspace = {
                     projectId: project.id,
@@ -129,7 +139,7 @@ export class GitIntegrationService {
                             access: "write",
                             path: prepared.path,
                             branch: prepared.branch,
-                            baseRef: initial.expectedHead,
+                            baseRef: initial.beforeCommit,
                             baseCommit: prepared.baseCommit
                         }]
                 }, this.now());
@@ -140,52 +150,17 @@ export class GitIntegrationService {
                 return this.#fail(initial, error, "integration-preparation");
             }
             if (initial.status === "validating") {
-                return this.#recoverValidating(initial, workspace, project.path);
+                return this.#recoverValidating(initial, workspace, taskRepository);
             }
             let current = initial;
             // A check DurableJob is the source of truth for a running attempt that
             // already bound one: never re-apply commits or spawn a second job. The
             // job's terminal wakeup drives the resume through `integration continue`.
             if (current.status === "running" && current.jobId !== undefined) {
-                return this.#resumeCheckJob(current, workspace, prepared.path, project.path, gate);
+                return this.#resumeCheckJob(current, workspace, prepared.path, taskRepository, gate);
             }
             try {
-                if (options.remoteBaseline !== undefined) {
-                    const mergeRemote = this.git.mergeRemoteIntoWorktree;
-                    if (mergeRemote === undefined) {
-                        throw new Error("Integration Git workspace does not support remote baseline reconciliation.");
-                    }
-                    await mergeRemote.call(this.git, {
-                        repositoryPath: prepared.path,
-                        remoteUrl: options.remoteBaseline.remoteUrl,
-                        branch: options.remoteBaseline.branch
-                    });
-                }
-                // A remote-baseline Attempt starts from the exact previously committed
-                // Task head, so its ChangeSets are already represented by that tree.
-                // Keep their IDs as provenance/check evidence, but never cherry-pick the
-                // source commits again. A manual continuation of a remote merge carries
-                // the same semantic marker in its conflict report.
-                const remoteOnly = options.remoteBaseline !== undefined
-                    || (current.resolution?.action === "manual-resolution"
-                        && current.conflict?.summary.startsWith(REMOTE_BASELINE_CONFLICT_PREFIX));
-                const plan = remoteOnly
-                    ? []
-                    : await integrationCommitPlan(this.store, task.id, project.path, current.changeSetIds, current.expectedHead);
-                let remaining = plan;
-                if (current.resolution?.action === "manual-resolution"
-                    && current.conflict?.summary.startsWith(REMOTE_BASELINE_CONFLICT_PREFIX)) {
-                    await completeRemoteBaselineResolution(prepared.path);
-                }
-                else if (current.resolution?.action === "manual-resolution") {
-                    const resolvedCommit = await completeManualResolution(prepared.path);
-                    const resolvedIndex = plan.findIndex(({ commit }) => commit === resolvedCommit);
-                    if (resolvedIndex < 0) {
-                        throw new Error(`Manual resolution commit is not part of the Integration plan: ${resolvedCommit}.`);
-                    }
-                    remaining = plan.slice(resolvedIndex + 1);
-                }
-                const conflict = await this.#applyCommits(current, workspace, prepared.path, remaining);
+                const conflict = await this.#applySource(current, workspace, prepared.path, project.remoteUrl);
                 if (conflict !== undefined) {
                     return conflict;
                 }
@@ -193,12 +168,12 @@ export class GitIntegrationService {
                 // moved or its worktree is dirty, so the check commands never run on a
                 // target that cannot be advanced.  advanceTargetRef re-verifies both
                 // after the checks, so a move during the gate is still fenced at CAS.
-                await assertTargetReadyForChecks(project.path, current.targetRef, current.expectedHead);
+                await assertTargetReadyForChecks(taskRepository, current.targetRef, current.beforeCommit);
                 if (gate !== undefined) {
-                    return this.#runVerificationGate(current, workspace, prepared.path, managedWorkspace, project.path, gate);
+                    return this.#runVerificationGate(current, workspace, prepared.path, managedWorkspace, taskRepository, gate);
                 }
                 if (this.jobPort !== undefined && current.checkCommands.length > 0) {
-                    return this.#startCheckJob(current, workspace, prepared.path, managedWorkspace, project.path);
+                    return this.#startCheckJob(current, workspace, prepared.path, managedWorkspace, taskRepository);
                 }
                 const checkedHead = await gitLine(["-C", prepared.path, "rev-parse", "HEAD^{commit}"]);
                 const checkResults = await this.#runChecks(current, managedWorkspace, prepared.path);
@@ -221,9 +196,8 @@ export class GitIntegrationService {
                     checks: checkResults
                 }, this.now());
                 this.store.saveIntegrationAttempt(task.id, current);
-                await advanceTargetRef(project.path, current.targetRef, candidateCommit, current.expectedHead);
-                const committed = updateIntegrationAttempt(current, { status: "committed" }, this.now());
-                this.store.saveIntegrationAttempt(task.id, committed);
+                await advanceTargetRef(taskRepository, current.targetRef, candidateCommit, current.beforeCommit);
+                const committed = this.#recordCommitted(current);
                 return this.#terminalResult("committed", committed, workspace);
             }
             catch (error) {
@@ -236,11 +210,18 @@ export class GitIntegrationService {
                     return { status: "blocked", attempt: pending, workspace };
                 }
                 if (current.status === "validating" && current.candidateCommit !== undefined) {
-                    const target = await resolveRef(project.path, current.targetRef);
+                    const target = await resolveRef(taskRepository, current.targetRef);
                     if (target === current.candidateCommit) {
-                        const committed = updateIntegrationAttempt(current, { status: "committed" }, this.now());
-                        this.store.saveIntegrationAttempt(task.id, committed);
-                        return this.#terminalResult("committed", committed, workspace);
+                        try {
+                            await assertTargetReadyForChecks(taskRepository, current.targetRef, current.candidateCommit);
+                            const committed = this.#recordCommitted(current);
+                            return this.#terminalResult("committed", committed, workspace);
+                        }
+                        catch {
+                            // Preserve the original failure below; a target ref at the
+                            // candidate is insufficient when its checked-out tree is dirty or
+                            // incomplete after an interrupted CAS application.
+                        }
                     }
                 }
                 return this.#fail(current, error, "integration", workspace);
@@ -263,13 +244,17 @@ export class GitIntegrationService {
             const project = this.store.getProject(integration.projectId);
             if (project === null)
                 throw new Error(`Project not found: ${integration.projectId}.`);
+            const taskRepository = this.store.getTaskWorkspace(task.id)?.entries.find(({ projectId }) => projectId === project.id)?.path;
+            if (taskRepository === undefined) {
+                throw new Error(`Integration Task clone is unavailable: ${task.id}/${project.id}.`);
+            }
             const managedWorkspace = this.store.getIntegrationWorkspace(integration.taskId, integration.id);
             if (managedWorkspace !== null) {
                 const runtime = this.#runtimePreparation(integration, managedWorkspace);
                 this.runtimeIsolation.cleanup(runtime, integration.status === "committed" ? "completion" : "failure");
             }
             const result = await this.git.removeIntegrationWorktree({
-                repositoryPath: project.path,
+                repositoryPath: taskRepository,
                 container: join(this.worktreeRoot, project.name),
                 taskSegment: taskWorkspaceRefSegment(task),
                 integrationId: integration.id,
@@ -417,7 +402,7 @@ export class GitIntegrationService {
                 level: "L2",
                 commit: job.head,
                 targetRef: attempt.targetRef,
-                baseHead: attempt.expectedHead
+                baseHead: attempt.beforeCommit
             });
             try {
                 const artifact = await recordGateArtifactFromJob(this.store, this.home, identity, gate.plan, job, this.now());
@@ -451,9 +436,8 @@ export class GitIntegrationService {
             checks
         }, this.now());
         this.store.saveIntegrationAttempt(attempt.taskId, validating);
-        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.expectedHead);
-        const committed = updateIntegrationAttempt(validating, { status: "committed" }, this.now());
-        this.store.saveIntegrationAttempt(attempt.taskId, committed);
+        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.beforeCommit);
+        const committed = this.#recordCommitted(validating);
         return this.#terminalResult("committed", committed, workspace);
     }
     async #runChecks(attempt, workspace, path) {
@@ -503,7 +487,7 @@ export class GitIntegrationService {
             level: "L2",
             commit: candidateCommit,
             targetRef: attempt.targetRef,
-            baseHead: attempt.expectedHead
+            baseHead: attempt.beforeCommit
         });
         if (gate.mode !== "record") {
             const existing = await lookupReusableGateArtifact(this.store, identity);
@@ -558,25 +542,136 @@ export class GitIntegrationService {
             checks
         }, this.now());
         this.store.saveIntegrationAttempt(attempt.taskId, validating);
-        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.expectedHead);
-        const committed = updateIntegrationAttempt(validating, { status: "committed" }, this.now());
-        this.store.saveIntegrationAttempt(attempt.taskId, committed);
+        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.beforeCommit);
+        const committed = this.#recordCommitted(validating);
         return this.#terminalResult("committed", committed, workspace);
     }
     #runtimePreparation(attempt, workspace) {
         return this.runtimeIsolation.preflight({
             workspace,
-            launchId: integrationRuntimeLaunchId(this.home, attempt.id),
+            runtimeGenerationId: integrationRuntimeRuntimeGenerationId(this.home, attempt.id),
             generationId: "integration-checks",
             allowExactActive: true
         });
     }
-    async #applyCommits(attempt, workspace, candidatePath, commits) {
-        for (const { changeSetId, commit } of commits) {
+    async #applySource(attempt, workspace, candidatePath, remoteUrl) {
+        if (attempt.source.kind === "historical-change-sets") {
+            throw new Error(`Historical Integration cannot be resumed under the current source contract: ${attempt.id}.`);
+        }
+        if (attempt.source.kind === "upstream") {
+            if (remoteUrl === undefined) {
+                throw new Error(`Project has no remote URL for upstream Integration: ${attempt.projectId}.`);
+            }
+            if (attempt.resolution?.action === "manual-resolution"
+                && attempt.conflict?.summary.startsWith(REMOTE_BASELINE_CONFLICT_PREFIX)) {
+                await continueUpstreamRebase(candidatePath);
+                return undefined;
+            }
+            const fetchRemote = this.git.fetchRemoteHeadIntoWorktree;
+            if (fetchRemote === undefined) {
+                throw new Error("Integration Git workspace cannot fetch an upstream source.");
+            }
+            const fetched = await fetchRemote.call(this.git, {
+                repositoryPath: candidatePath,
+                remoteUrl,
+                branch: attempt.source.branch
+            });
+            if (fetched.commit !== attempt.source.remoteCommit) {
+                throw new Error(`Upstream branch moved before Integration: expected ${attempt.source.remoteCommit}, fetched ${fetched.commit}.`);
+            }
+            if (await this.git.isAncestor(candidatePath, attempt.source.remoteCommit, attempt.beforeCommit)) {
+                return undefined;
+            }
+            try {
+                await git([
+                    "-C", candidatePath,
+                    "-c", "user.name=Yui",
+                    "-c", "user.email=yui@local",
+                    "rebase", "--onto",
+                    attempt.source.remoteCommit,
+                    attempt.source.taskBaseCommit,
+                    workspace.branch
+                ]);
+            }
+            catch (error) {
+                const affectedPaths = await conflictedPaths(candidatePath);
+                if (affectedPaths.length === 0)
+                    throw error;
+                const pending = requireResolutionDecision(attempt, {
+                    affectedPaths,
+                    summary: `${REMOTE_BASELINE_CONFLICT_PREFIX} in ${attempt.targetRef}.`
+                }, this.now());
+                this.store.saveIntegrationAttempt(attempt.taskId, pending);
+                return { status: "blocked", attempt: pending, workspace };
+            }
+            return undefined;
+        }
+        if (attempt.source.strategy === "manual") {
+            if (attempt.resolution?.action === "manual-resolution"
+                && attempt.conflict?.summary.startsWith(MANUAL_INTEGRATION_PREFIX)) {
+                if (!await this.git.isClean(candidatePath)) {
+                    throw new Error("Manual Integration workspace must be clean and committed.");
+                }
+                return undefined;
+            }
+            const pending = requireResolutionDecision(attempt, {
+                affectedPaths: [],
+                summary: `${MANUAL_INTEGRATION_PREFIX}; apply the selected WorkItem result in the Integration workspace.`
+            }, this.now());
+            this.store.saveIntegrationAttempt(attempt.taskId, pending);
+            return { status: "blocked", attempt: pending, workspace };
+        }
+        if (attempt.source.strategy === "ff") {
+            await git([
+                "-C", candidatePath,
+                "merge", "--ff-only",
+                attempt.source.resultCommit
+            ]);
+            return undefined;
+        }
+        if (attempt.source.strategy === "merge") {
+            if (attempt.resolution?.action === "manual-resolution"
+                && attempt.conflict?.summary.startsWith(WORK_ITEM_MERGE_CONFLICT_PREFIX)) {
+                await completeMergeResolution(candidatePath);
+                return undefined;
+            }
+            try {
+                await git([
+                    "-C", candidatePath,
+                    "-c", "user.name=Yui",
+                    "-c", "user.email=yui@local",
+                    "merge", "--no-edit", "--no-ff",
+                    attempt.source.resultCommit
+                ]);
+            }
+            catch (error) {
+                const affectedPaths = await conflictedPaths(candidatePath);
+                if (affectedPaths.length === 0)
+                    throw error;
+                const pending = requireResolutionDecision(attempt, {
+                    affectedPaths,
+                    summary: `${WORK_ITEM_MERGE_CONFLICT_PREFIX} in ${attempt.targetRef}.`
+                }, this.now());
+                this.store.saveIntegrationAttempt(attempt.taskId, pending);
+                return { status: "blocked", attempt: pending, workspace };
+            }
+            return undefined;
+        }
+        const commits = await commitsBetween(candidatePath, attempt.source.startCommit, attempt.source.resultCommit, attempt.source.workItemId);
+        let remaining = commits;
+        if (attempt.resolution?.action === "manual-resolution") {
+            const resolvedCommit = await completeCherryPickResolution(candidatePath);
+            const resolvedIndex = commits.findIndex(({ commit }) => commit === resolvedCommit);
+            if (resolvedIndex < 0) {
+                throw new Error(`Manual resolution commit is not part of the WorkItem result: ${resolvedCommit}.`);
+            }
+            remaining = commits.slice(resolvedIndex + 1);
+        }
+        for (const { label, commit } of remaining) {
             // Fast-forward when the commit is a direct descendant of HEAD: this
             // preserves the original commit SHA, which exact-SHA review evidence
             // relies on.  Fall back to cherry-pick when the target moved since the
-            // ChangeSet was based (the commit is no longer a direct descendant).
+            // WorkItem was based (the commit is no longer a direct descendant).
             if (await gitSucceeds(["-C", candidatePath, "merge", "--ff-only", commit])) {
                 continue;
             }
@@ -594,7 +689,7 @@ export class GitIntegrationService {
                 }
                 const pending = requireResolutionDecision(attempt, {
                     affectedPaths,
-                    summary: `ChangeSet ${changeSetId} conflicts with ${attempt.targetRef}.`
+                    summary: `${label} conflicts with ${attempt.targetRef}.`
                 }, this.now());
                 this.store.saveIntegrationAttempt(attempt.taskId, pending);
                 return { status: "blocked", attempt: pending, workspace };
@@ -607,21 +702,46 @@ export class GitIntegrationService {
             return this.#fail(attempt, new Error("Validating Integration is missing its candidate commit or checks."), "integration-recovery", workspace);
         }
         const target = await resolveRef(repositoryPath, attempt.targetRef);
-        if (target === attempt.expectedHead) {
+        if (target === attempt.beforeCommit) {
             try {
-                await advanceTargetRef(repositoryPath, attempt.targetRef, attempt.candidateCommit, attempt.expectedHead);
+                await advanceTargetRef(repositoryPath, attempt.targetRef, attempt.candidateCommit, attempt.beforeCommit);
             }
             catch (error) {
                 return this.#fail(attempt, error, "integration-recovery", workspace);
             }
         }
         else if (target !== attempt.candidateCommit) {
-            return this.#fail(attempt, new Error(`Target moved to ${target}; expected ${attempt.expectedHead}.`), "integration-recovery", workspace);
+            return this.#fail(attempt, new Error(`Target moved to ${target}; expected ${attempt.beforeCommit}.`), "integration-recovery", workspace);
         }
-        const committed = updateIntegrationAttempt(attempt, { status: "committed" }, this.now());
-        this.store.saveIntegrationAttempt(attempt.taskId, committed);
+        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.candidateCommit);
+        const committed = this.#recordCommitted(attempt);
         return this.#terminalResult("committed", committed, workspace);
     }
+    #recordCommitted(attempt) {
+        if (attempt.candidateCommit === undefined) {
+            throw new Error(`Committed Integration has no candidate commit: ${attempt.id}.`);
+        }
+        const candidateCommit = attempt.candidateCommit;
+        return this.store.transaction((tx) => {
+            const task = tx.getTask(attempt.taskId);
+            if (task === null)
+                throw new Error(`Task not found: ${attempt.taskId}.`);
+            const binding = task.projectBindings.find(({ projectId }) => projectId === attempt.projectId);
+            if (binding === undefined) {
+                throw new Error(`Task Project binding not found: ${task.id}/${attempt.projectId}.`);
+            }
+            if (binding.currentCommit !== candidateCommit) {
+                tx.saveTask(advanceTaskProjectCommit(task, attempt.projectId, attempt.beforeCommit, candidateCommit, this.now()));
+            }
+            const committed = updateIntegrationAttempt(attempt, {
+                status: "committed",
+                afterCommit: candidateCommit,
+                summary: integrationSummary(attempt)
+            }, this.now());
+            tx.saveIntegrationAttempt(attempt.taskId, committed);
+            return committed;
+        });
+    }
     #fail(attempt, error, checkName, workspace) {
         const failed = updateIntegrationAttempt(attempt, {
             status: "failed",
@@ -651,6 +771,33 @@ export class GitIntegrationService {
         };
     }
 }
+function integrationSummary(attempt) {
+    const unchanged = attempt.beforeCommit === attempt.candidateCommit;
+    if (attempt.source.kind === "upstream") {
+        return unchanged
+            ? `Upstream ${attempt.source.remoteCommit} was already represented; Task head was unchanged.`
+            : `Rebased Task changes onto upstream ${attempt.source.remoteCommit}.`;
+    }
+    if (attempt.source.kind === "historical-change-sets") {
+        return unchanged
+            ? "Historical Integration was already represented; Task head was unchanged."
+            : "Historical Integration advanced the Task head.";
+    }
+    if (attempt.source.strategy === "manual") {
+        const decision = attempt.resolution;
+        if (decision?.action !== "manual-resolution") {
+            throw new Error(`Manual Integration has no Task-control resolution decision: ${attempt.id}.`);
+        }
+        return unchanged
+            ? `WorkItem ${attempt.source.workItemId} was intentionally not applied; `
+                + `Task head was unchanged. Rationale: ${decision.rationale}`
+            : `Integrated WorkItem ${attempt.source.workItemId} with manual resolution. `
+                + `Rationale: ${decision.rationale}`;
+    }
+    return unchanged
+        ? `WorkItem ${attempt.source.workItemId} result was already represented; Task head was unchanged.`
+        : `Integrated WorkItem ${attempt.source.workItemId} with ${attempt.source.strategy}.`;
+}
 async function isEmptyCherryPick(path, commit) {
     let cherryPickHead;
     try {
@@ -664,32 +811,23 @@ async function isEmptyCherryPick(path, commit) {
     return cherryPickHead === commit
         && await gitSucceeds(["-C", path, "diff", "--cached", "--quiet"]);
 }
-async function integrationCommitPlan(store, taskId, repositoryPath, changeSetIds, expectedHead) {
+async function commitsBetween(repositoryPath, startCommit, resultCommit, workItemId) {
+    const commits = (await git([
+        "-C", repositoryPath, "rev-list", "--reverse",
+        `${startCommit}..${resultCommit}`
+    ])).trim().split("\n").filter(Boolean);
     const plan = [];
-    for (const changeSetId of changeSetIds) {
-        const changeSet = store.getChangeSet(taskId, changeSetId);
-        if (changeSet === null)
-            throw new Error(`ChangeSet not found: ${changeSetId}.`);
-        const commits = (await git([
-            "-C", repositoryPath, "rev-list", "--reverse",
-            `${changeSet.baseCommit}..${changeSet.headCommit}`
-        ])).trim().split("\n").filter(Boolean);
-        for (const commit of commits) {
-            // A Task-main recovery may capture commits after they are already
-            // present on the exact target. Treat those commits as applied rather
-            // than attempting an empty cherry-pick; the later checks and CAS still
-            // fence the committed Integration to expectedHead.
-            if (await gitSucceeds([
-                "-C", repositoryPath,
-                "merge-base", "--is-ancestor", commit, expectedHead
-            ]))
-                continue;
-            plan.push({ changeSetId, commit });
-        }
+    for (const commit of commits) {
+        if (await gitSucceeds([
+            "-C", repositoryPath,
+            "merge-base", "--is-ancestor", commit, "HEAD"
+        ]))
+            continue;
+        plan.push({ label: `WorkItem ${workItemId} commit ${commit}`, commit });
     }
     return plan;
 }
-async function completeManualResolution(path) {
+async function completeCherryPickResolution(path) {
     const unmerged = (await git(["-C", path, "diff", "--name-only", "--diff-filter=U"])).trim();
     if (unmerged.length > 0) {
         throw new Error(`Manual resolution is incomplete: ${unmerged.split("\n").join(", ")}.`);
@@ -713,16 +851,16 @@ async function completeManualResolution(path) {
     }
     return cherryPickHead;
 }
-async function completeRemoteBaselineResolution(path) {
-    const unmerged = (await git(["-C", path, "diff", "--name-only", "--diff-filter=U"])).trim();
-    if (unmerged.length > 0) {
-        throw new Error(`Manual remote baseline resolution is incomplete: ${unmerged.split("\n").join(", ")}.`);
+async function completeMergeResolution(path) {
+    const affected = await conflictedPaths(path);
+    if (affected.length > 0) {
+        throw new Error(`Manual merge resolution is incomplete: ${affected.join(", ")}.`);
     }
     try {
         await gitLine(["-C", path, "rev-parse", "--verify", "MERGE_HEAD"]);
     }
     catch {
-        throw new Error("Manual remote baseline resolution has no active merge.");
+        throw new Error("Manual WorkItem resolution has no active merge.");
     }
     await git([
         "-C", path,
@@ -731,6 +869,40 @@ async function completeRemoteBaselineResolution(path) {
         "commit", "--no-edit"
     ]);
 }
+async function continueUpstreamRebase(path) {
+    const affected = await conflictedPaths(path);
+    if (affected.length > 0) {
+        throw new RemoteBaselineConflictError(affected, `${REMOTE_BASELINE_CONFLICT_PREFIX}: ${affected.join(", ")}.`);
+    }
+    try {
+        await gitLine(["-C", path, "rev-parse", "--verify", "REBASE_HEAD"]);
+    }
+    catch {
+        throw new Error("Manual upstream resolution has no active rebase.");
+    }
+    try {
+        await git([
+            "-C", path,
+            "-c", "user.name=Yui",
+            "-c", "user.email=yui@local",
+            "-c", "core.editor=true",
+            "rebase", "--continue"
+        ]);
+    }
+    catch (error) {
+        const nextAffected = await conflictedPaths(path);
+        if (nextAffected.length > 0) {
+            throw new RemoteBaselineConflictError(nextAffected, `${REMOTE_BASELINE_CONFLICT_PREFIX}: ${nextAffected.join(", ")}.`, { cause: error });
+        }
+        throw error;
+    }
+}
+async function conflictedPaths(path) {
+    return (await git([
+        "-C", path,
+        "diff", "--name-only", "--diff-filter=U"
+    ])).trim().split("\n").filter(Boolean);
+}
 /**
  * Map a terminal check job back to the attempt's CheckResult[] shape. The
  * runner stops at the first failing step, so unreached checks are "skipped"
@@ -925,7 +1097,7 @@ function integrationRuntimeRoot() {
     const uid = typeof process.getuid === "function" ? process.getuid() : 0;
     return join("/tmp", `yi-${uid.toString(36)}`);
 }
-function integrationRuntimeLaunchId(home, integrationId) {
+function integrationRuntimeRuntimeGenerationId(home, integrationId) {
     const homeDigest = createHash("sha256")
         .update(resolve(home))
         .digest("hex");
@@ -1098,7 +1270,18 @@ async function advanceTargetRef(repositoryPath, targetRef, candidateCommit, expe
     if (current !== expectedHead) {
         throw new Error(`Target moved to ${current}; expected ${expectedHead}.`);
     }
-    await git(["-C", checkout, "merge", "--ff-only", "--no-edit", candidateCommit]);
+    // The candidate may be a rebased upstream result and therefore need not be
+    // a descendant of the old Task head. Advance the branch with a real
+    // compare-and-swap, then update only this checkout's index and worktree.
+    // `read-tree` never moves the ref, so an external ref change is not
+    // overwritten while the checked-out files are synchronized.
+    await git([
+        "-C", repositoryPath, "update-ref",
+        ref,
+        candidateCommit,
+        expectedHead
+    ]);
+    await git(["-C", checkout, "read-tree", "--reset", "-u", candidateCommit]);
     const advanced = await resolveRef(repositoryPath, targetRef);
     if (advanced !== candidateCommit) {
         throw new Error(`Integration target did not advance to candidate: ${targetRef}.`);