func (p *PacRun) resolveRepoForTargetCancelPipelineRun(ctx context.Context, repo *v1alpha1.Repository) *v1alpha1.Repository {
	if repo == nil || p.event.TargetCancelPipelineRun == "" || p.vcx == nil {
		return repo
	}

	provenance := "source"
	if repo.Spec.Settings != nil && repo.Spec.Settings.PipelineRunProvenance != "" {
		provenance = repo.Spec.Settings.PipelineRunProvenance
	}

	rawTemplates, err := p.vcx.GetTektonDir(ctx, p.event, tektonDir, provenance)
	if err != nil || rawTemplates == "" {
		return repo
	}

	allTemplates := p.makeTemplate(ctx, repo, rawTemplates)
	types, err := resolve.ReadTektonTypes(ctx, p.logger, allTemplates)
	if err != nil {
		return repo
	}

	pipelineRuns, err := resolve.MetadataResolve(types.PipelineRuns)
	if err != nil || len(pipelineRuns) == 0 {
		return repo
	}

	targetPR := filterRunningPipelineRunOnTargetTest(p.event.TargetCancelPipelineRun, pipelineRuns)
	if targetPR == nil {
		for _, pr := range pipelineRuns {
			prName := strings.TrimSuffix(pipelineRunIdentifier(pr), "-")
			if prName == p.event.TargetCancelPipelineRun {
				targetPR = pr
				break
			}
		}
	}
	if targetPR == nil {
		return repo
	}

	return p.resolveTargetNamespaceRepo(ctx, repo, targetPR)
}

func (v *Provider) listCommentsByMarker(ctx context.Context, event *info.Event, marker string) ([]*github.IssueComment, error) {
	comments, _, err := wrapAPI(v, "list_comments", func() ([]*github.IssueComment, *github.Response, error) {
		return v.Client().Issues.ListComments(ctx, event.Organization, event.Repository, event.PullRequestNumber, &github.IssueListCommentsOptions{
			ListOptions: github.ListOptions{
				Page:    1,
				PerPage: 100,
			},
		})
	})
	if err != nil {
		return nil, err
	}

	re := regexp.MustCompile(regexp.QuoteMeta(marker))
	matchedComments := make([]*github.IssueComment, 0, len(comments))
	for _, comment := range comments {
		if re.MatchString(comment.GetBody()) {
			matchedComments = append(matchedComments, comment)
		}
	}
	return matchedComments, nil
}

func (v *Provider) ensureSingleMarkerComment(
	ctx context.Context,
	event *info.Event,
	comments []*github.IssueComment,
	commit string,
) error {
	if len(comments) == 0 {
		return nil
	}

	primaryComment := comments[0]
	for _, comment := range comments {
		if comment.GetBody() == commit {
			primaryComment = comment
			break
		}
	}

	if primaryComment.GetBody() != commit {
		if _, _, err := wrapAPI(v, "edit_comment", func() (*github.IssueComment, *github.Response, error) {
			return v.Client().Issues.EditComment(ctx, event.Organization, event.Repository, primaryComment.GetID(), &github.IssueComment{
				Body: github.Ptr(commit),
			})
		}); err != nil {
			return err
		}
	}

	// Best-effort cleanup to collapse duplicates into a single canonical marker comment.
	for _, comment := range comments {
		if comment.GetID() == primaryComment.GetID() {
			continue
		}
		if _, _, err := wrapAPI(v, "delete_comment", func() (struct{}, *github.Response, error) {
			resp, err := v.Client().Issues.DeleteComment(ctx, event.Organization, event.Repository, comment.GetID())
			return struct{}{}, resp, err
		}); err != nil && v.Logger != nil {
			v.Logger.Warnf("failed to delete duplicate comment %d on %s/%s#%d: %v",
				comment.GetID(), event.Organization, event.Repository, event.PullRequestNumber, err)
		}
	}
	return nil
}

if err != nil {
	return err
}

if updateMarker == "" {
	return nil
}

// Best-effort post-create reconciliation to collapse duplicates created by
// concurrent processors handling the same event.
matchedComments, listErr := v.listCommentsByMarker(ctx, event, updateMarker)
if listErr != nil {
	return nil
}
return v.ensureSingleMarkerComment(ctx, event, matchedComments, commit)