feat(mcp): merge back conversation context#8697

@@ -360,8 +423,169 @@ export const make = Effect.gen(function* () {
           source,
         });
       }),
+    mergeBack: (scope, input) =>
+      Effect.gen(function* () {
+        yield* requireCapability(scope);
+        const commandId = mergeBackCommandId(scope, input.clientRequestId);
+        const priorReceipt = yield* commandReceipts.getByCommandId(commandId).pipe(
+          Effect.map(
+            Option.filter(
+              (existing) =>
+                existing.status === "accepted" && existing.commandType === "thread.merge_back",
+            ),
+          ),
+          Effect.mapError((error) =>
+            failure(
+              "orchestration_error",
+              `Unable to inspect the merge-back retry receipt: ${errorMessage(error)}`,
+            ),
+          ),
+        );
+        if (Option.isSome(priorReceipt)) {
+          const caller = yield* threads
+            .getThreadProjection(scope.threadId)
+            .pipe(
+              Effect.mapError((error) =>
+                failure(
+                  "orchestration_error",
+                  `Unable to load the calling thread: ${errorMessage(error)}`,
+                ),
+              ),
+            );
+          const recordedTarget = yield* threads
+            .getThreadProjection(priorReceipt.value.threadId)
+            .pipe(
+              Effect.mapError((error) =>
+                failure(
+                  "orchestration_error",
+                  `Unable to load the accepted merge-back target: ${errorMessage(error)}`,
+                ),
+              ),
+            );
+          if (recordedTarget.thread.projectId !== caller.thread.projectId) {
+            return yield* failure(
+              "thread_not_found",
+              `The accepted merge-back target is not in the calling project.`,
+            );
+          }
+          const replayed = yield* threads
+            .dispatch({
+              type: "thread.merge_back",
+              createdBy: "agent",
+              creationSource: "mcp",
+              commandId,
+              sourceThreadId: input.sourceThreadId ?? scope.threadId,
+              targetThreadId: priorReceipt.value.threadId,
+              sourcePoint: input.sourcePoint,
+            })
+            .pipe(
+              Effect.mapError((error) =>
+                failure(
+                  "orchestration_error",
+                  `Unable to replay the merge-back receipt: ${errorMessage(error)}`,
+                ),
+              ),
+            );
+          return yield* mergeBackResultFromDispatch({
+            request: input,
+            commandId,
+            dispatched: replayed,
+          });
+        }
+
+        const { parent, target: source } = yield* loadScoped(scope, input.sourceThreadId);
+        const recordedTargetId = source.thread.lineage.parentThreadId;
+        if (source.thread.lineage.relationshipToParent !== "fork" || recordedTargetId === null) {
+          return yield* failure(
+            "invalid_request",
+            `Thread ${source.thread.id} is not a conversation fork and cannot merge back.`,
+          );
+        }
+        const requestedTargetId = input.targetThreadId ?? recordedTargetId;
+        if (requestedTargetId !== recordedTargetId) {
+          return yield* failure(
+            "invalid_request",
+            `Thread ${source.thread.id} can merge back only to its recorded parent ${recordedTargetId}.`,
+          );
+        }
+        const { target } = yield* loadScoped(scope, requestedTargetId);