Migration
Prepare for Rewire
What Is Prepare for Rewire?
After migrating repositories from Azure DevOps to GitHub, whether through Migrating Repositories or with gh ado2gh, pipeline files and other repository content may still contain references pointing at Azure DevOps — hardcoded clone URLs, pipeline resource declarations, and .gitmodules entries. The Prepare for rewire page finds those lingering references, proposes fixes, and delivers them as pull requests you merge. It then rebinds your pipelines onto their GitHub repositories and follows how they run from there.
The page opens on an Overview of where the rewire stands. A strip across the top leads to six stages, in this order:
- Service connection - Choose the GitHub service connection your pipelines clone through, and check that every project has it
- Review mappings - Confirm the GitHub repository each Azure DevOps repository moved to
- Review references - Settle the references the scan can't rewrite on its own
- Pull requests - Open and merge one update pull request per repository branch
- Rewire - Approve imported pipeline definitions and rebind them onto their GitHub repositories
- Verify - Check each rebound pipeline's pull request trigger, and watch its runs from GitHub
Each stage's card in the strip says what waits there, such as 3 mappings to review or 2 pipelines to review.
To open the page, open an Azure DevOps instance from the Pipelines dashboard. Once the instance has been analyzed and has repositories to update, its header shows Prepare for rewire (N to update). When you run the migration as a Migration Plan, the plan's Prepare the Rewire step reads this page's decisions from the dry run. Each wave's Rewire pipelines stage carries those decisions to its destination orgs and opens this page there.
Until the instance has been analyzed, the page says Not analyzed yet. Click Analyze to trace where each Azure DevOps repository migrated and find references that still point at Azure DevOps. Re-analyze at the top of the page runs the analysis again.
The Overview
The Overview is one card, Where it stands:
- A bar splits the repository branches into Needs you, Waiting, Ready, PR open, Done, and No changes, with a count for each. Click a segment, or its entry in the legend, to list those repositories: Ready, PR open, and Done open their list in Pull requests, and the others open Review references.
- Ready checks off what is settled without you: the service connection once every project has it, automatic updates, references fixed by AI, references dismissed with a reason, and repositories that need no changes. Each line opens the repositories behind it.
- Next steps lists what needs a person, one row for each kind of work, in the order to work through it: the service connection, mappings, the AI review and decisions to recheck, references to review, changes you are making by hand, shared template repositories to update first, and pipelines to review in Verify. Each row leads to the stage where it's done. The top row is the next step, with the primary button. While an AI review runs, its progress takes that place, with Cancel review.
Once only update pull requests are left, the next step is Open N update PRs, then Watch N open PRs while they are open. When nothing is left to do, Next steps says Ready for rewire. In a dry run, or while repositories are still waiting, it says Nothing to review right now.
After you import decisions from a dry run, a banner on the Overview counts them. See Carry Decisions from a Dry Run.
Service Connection
Pipelines in Azure DevOps need a service connection for GitHub to clone repositories from GitHub. This stage chooses the one connection the rewire uses for the instance, and checks that each project's pipelines can use it.
Pick the connection under Connection, then click Save. The stage lists what it checks about the connection:
- Created by the Azure Pipelines app for GitHub - A connection created with a personal access token is strongly discouraged.
- Matches your GitHub organization - It connects to the GitHub organization your repositories moved to.
- Can read the GitHub repositories its pipelines build from - Checked once the connection is saved. If GitHub refuses its credential, update the connection in Azure DevOps. If it can't read some repositories, the stage names them: install the Azure Pipelines app on them, or give the connection's account access. Then click Recheck access.
None of these checks stops the rewire. Which connection to use, and how to set one up opens the setup steps beside the page.
Under Project configuration, a table answers one question for each Azure DevOps project in the rewire: Service connection configured in project? CodeCargo looks for a connection with the chosen name in each project, among the service connections the latest import read.
- Yes - The project has it.
- No - The project has another GitHub connection instead, which the row names, or none at all.
- No GitHub service connection in this project yet - See No GitHub Service Connection Yet.
- Can't tell - CodeCargo can't see the project's service connections.
How to fix on a row opens the steps for every project in the same state. To give a project the connection, share it under the same name through the Azure DevOps Share Service Endpoint API, not through Project permissions. Project permissions adds the project's name to each copy, and a connection the Azure Pipelines app created can't be renamed. Only an organization administrator for the connection can share it.
A project is checked only when it has a mapped repository and an imported pipeline. A line under the table counts the projects that have mapped repositories but no imported pipelines.
In a dry-run organization the connection doesn't matter. It isn't exported, and you choose one in the production organization.
No GitHub Service Connection Yet
A project with no GitHub service connection says No GitHub service connection in this project yet. How to set one up gives the steps:
- A GitHub organization owner installs the Azure Pipelines app in the organization your repositories moved to.
- During the install, they pick this Azure DevOps organization and one of these projects. The install creates the connection there, named after your GitHub organization.
- Share it with the other projects.
- Click Check again.
When another project already has the chosen connection, the steps share that one instead.
CodeCargo sees a connection you create or share in Azure DevOps only after that project's pipelines are imported again. Check again re-imports the pipelines in those projects, then runs a new analysis, and shows how the import goes. It leaves out projects that aren't selected on the Azure DevOps connection page. If you can't import, the stage points you to the connection page to import the pipelines again.
Can't tell means the import could not read the project's service connections. It needs read access to them.
- Connected through Microsoft sign-in. On the organization's connection page, select Change projects on its card, select the projects that aren't connected, and click Save changes. If the card says CodeCargo is missing access, select Update access there. Then click Check again.
- Connected with a personal access token. The token's owner needs to see those projects' service connections, and the token needs the Service Connections: Read & query scope. Then click Check again.
Review Mappings
Migration Assistant builds a map of Azure DevOps repositories to their new GitHub homes. Repositories migrated from inside CodeCargo write their mapping the moment the copy succeeds. For repositories migrated with gh ado2gh, Migration Assistant reads GitHub's migration record (see Repository Link Resolution). The analysis also adds repositories that migrated files point at. References to a repository are updated only once its mapping has a GitHub repository and is confirmed or auto-verified.
Filter pills above the table narrow it to Needs review, Confirmed, Auto-verified, or All mappings. In another org appears when the Migration Plan moved some repositories to another destination org; see Repositories That Move to Another Org. The table shows:
- Repository and Project - The Azure DevOps repository
- Origin - Why the repository is in the list: GitHub migration record, Found by the analysis, or Added by hand. It never changes.
- In use - How many imported pipelines live in the repository, and how many references in other repositories point at it
- Mapping - Where the mapping stands: Needs confirmation for a suggestion from the
ado2ghnaming convention, Needs a target, Confirmed, Auto-verified when GitHub recorded the exact pairing, or Stays in Azure DevOps. No repository or Lost its repository means a confirmed mapping has no GitHub repository, or its repository is no longer found. - GitHub repo - The target, with a picker to change it
Working the Review Queue
Mappings with a suggested repository start out ticked. Picking a repository, or Stays in Azure DevOps, ticks a mapping too. Untick any you aren't sure of, then click Save and confirm selected (N). It saves your changes and confirms the ticked mappings. When nothing ticked can be confirmed, the button reads Save, and keeps your edits without confirming anything. A ticked mapping with no GitHub repository stays in review.
Ticks survive searching and filtering, so you can search for a project and tick its repositories. If someone changes a ticked mapping's target before you save, the tick is dropped, and the page says so.
Click any row to open its details panel: links to the repository in Azure DevOps and in GitHub, a GitHub repository picker, where the mapping came from, the pipelines that live in the repository, and the files in other repositories that reference it. On a confirmed mapping, Unconfirm returns it to the review queue. The target stays a suggestion until someone confirms it again. The Confirmed pill in the table offers the same.
Saving a target does not scan again. A banner says Re-analyze to apply your mapping changes, and references keep their current status until the next analysis. Click Re-analyze there.
Re-analyze to pick up new repos
If you add more repositories to your GitHub organization after the initial import, click Re-analyze at the top of the page to run discovery again and extend the mapping table.
If the GitHub copy of a repository will serve migrated pipelines but the Azure DevOps original must keep serving pipelines you haven't moved, tick Shared template repository in its panel, so the original isn't decommissioned with the migrated consumers. The mark saves at once, and reaches the references at the next analysis.
Stays in Azure DevOps
When a repository should remain in Azure Repos instead of moving to GitHub, choose Stays in Azure DevOps, the first option in its GitHub repository picker, and save. To keep several, tick them — search for a project and tick them all, for example — click Keep selected in Azure DevOps, then click Save and confirm selected (N). The mapping is confirmed with no GitHub repository, and references to it are left as they are, right away, with no analysis needed. The update pull request does not rewrite them.
Only a pick of Stays in Azure DevOps does this. A mapping confirmed with no GitHub repository any other way still leaves its references waiting on a mapping.
This is not a shared template. A shared template has a GitHub copy for pipelines you have moved, and keeps the Azure DevOps original for pipelines you have not. A repository that stays has no GitHub copy.
Pick a GitHub repository on the mapping when you do want to move it. To send it back to review, click its Stays in Azure DevOps pill, then Unconfirm; its references wait on a mapping again. Choosing stay does not mark the repository migrated, so you can still copy it from Migrating Repositories.
If a pipeline reads templates from that repository, or an az repos call reaches it, click Re-analyze. References settle at once, but questions the last analysis asked about a GitHub copy remain until that analysis runs. If an update pull request for that repository is already open or merged, edits it already made stay in that pull request.
Review References
The scan rewrites most references on its own. The rest need a decision before their branch's update pull request can carry them: Review with AI decides many, some are asked of you right after the scan, and you can answer, dismiss, or take on any of them yourself.
The stage has up to three lists:
- References to review - Every reference waiting on your decision, one at a time. Filter by type, or search by repository. The stage opens on this list.
- Repositories - Every repository branch, with its Status, What changes in its update pull request, and Why it stands where it does. The status filter starts on Needs you or waiting; pick one status, or All.
- Changes made by hand - Changes people took on themselves that aren't done yet, shown while any are waiting. Click Mark done, with a note, once each is made.
A repository has one row for each branch its pipelines build from. Click a row to open its panel: questions first, then what's decided, what's automatic, what waits on a mapping, and what was left unchanged. The panel also lists the repository's pipelines, with See in Verify, and links its update pull requests. Open update PR at its foot queues that row's pull request.
While repositories haven't been reviewed by AI, a band across the top of the stage offers Review with AI. Once nothing is left to review, the foot of the stage counts the repositories ready for an update pull request, and leads to Pull requests.
What the Scan Reads
The scan reads pipeline YAML on the branch the pipeline builds from, not on the repository's default branch. Relative paths and @self includes are read on that branch. A repository resource (@alias) with no ref: is read on that repository's default branch, even when the alias names this repository — that is where Azure DevOps checks the resource out. A ref: changes that; see Repository Resources Pinned with ref:.
Each branch is scanned for:
- Pipeline YAML - Resource declarations and ADO URLs in the files that branch's pipelines run
.gitmodules- Submodule URLs pointing at Azure Repos- Hardcoded clone URLs - Remaining
dev.azure.comreferences
When every pipeline in a repository builds from some other branch, the default branch is scanned only for .gitmodules and for ADO URLs outside pipeline YAML. It gets a row only when those need fixing.
Org-gated URL matching
URL rewriting is scoped to your Azure DevOps organization. References from a different ADO organization are never rewritten to the wrong target, even if a project or repository name collides.
Review with AI
The scan flags pipeline references it cannot rewrite on its own — pipeline variables, composed URLs, template paths, and credentials. Start Review with AI and an agent reads those pipeline files and records a decision for each finding: a fix, a dismissal, or a question for you. A fix is included when you open that branch's update pull request. A question appears in the row for you to answer.
- It decides pipeline variables, composed URLs, and templates that use a computed path or a relative or
@selfinclude. - It asks you about credentials, provider-conditional branches, and templates in another repository that the scan could read.
- It does not review a repository that is not mapped, a URL that embeds a credential, or one of the questions the scan asks. A fix is not applied to those lines.
A finding you have already decided, and a skipped repository, are left out. A decision you made or imported is never replaced, and a fix is not applied to a line you decided or to text you excluded from the update. When the agent's own decision no longer fits, Re-review with AI can replace it.
The review runs in the background, uses AI tokens, and the page shows its progress. If a review of this instance is already running, starting another does not start a second one. Cancel a review that is still running; repositories already reviewed keep what was recorded. You need the Migration Assistant manage permission.
A Repository Resource the Connection Must See
A fix from Review with AI that adds a repository resource is included only when the pipeline's GitHub service connection can see that repository and the branch it reads. Azure DevOps resolves that resource when the run is queued. A resource the connection cannot see fails every run, so it is not added.
- The connection can see the repository and the branch. The fix is included when you open the update pull request.
- The connection cannot see the repository, or GitHub has no such branch. The resource is not added. Install the Azure Pipelines app on that repository, or use a connection whose personal access token can read it. Then click Re-analyze and start Review with AI again.
- CodeCargo could not check. The fix is recorded as a question that offers the resource. Answer it, or give the connection access and review again.
The connection is the one chosen in the Service connection stage.
Questions the Scan Asks
CodeCargo asks you about some findings right after the scan, and never sends them to Review with AI. A repository with only these findings is not sent for review. The question is written from the finding and shows the scan's reason. No option rewrites the line: leave it as it is, or make the change yourself. An option that leaves the change to you says whether the update pull request can take it before you choose it.
- A repository resource pinned to a tag or commit, a
ref:the migrated repository does not have, a copy the scan could not read, or aref:computed when the pipeline compiles. See Repository Resources Pinned withref:. - An alias the pipeline never declares.
- A template file that is missing, included through another repository's alias.
- A pipeline trigger.
- An
az reposcall against a repository that is moving. See Azure CLI Calls to Azure Repos. - A repository reached over SSH. See A Repository Reached Over SSH.
- A checkout step whose folder the move can change, when the pipelines that run it do not share one folder, or when the update pull request leaves its path to you. See Checkout Folders.
If a later scan reports a different problem on that line, answer the new question on its own.
Answering a Question
In a row's reference list, a question shows the code around the line it asks about. View on GitHub opens that file at the commit the scan read, and View in Azure DevOps opens the same lines there. Pick an option to preview what it changes — an edit becomes a diff of those lines, and a change outside them is shown on its own — then click Save answer. Pick another returns to the code as it is. If an option no longer applies, Save answer stays disabled and the reason is shown.
Dismiss with a note records why the line stays unchanged. That note is listed in the pull request. A fix shows the edit as a diff. Show the code loads the surrounding lines, and Why opens the rationale.
- If the file changed after the question was asked, the code and the preview are from the latest scan.
- A dismissal whose file later changes still holds. Check the code, then click Re-confirm. A fix carries over, and the update checks that it still applies.
- Restore puts a dismissed finding back in need of a decision. Re-review with AI is available when a decision no longer fits.
- A URL that carries a credential is asked on its own. The credential is masked and is not sent for review. I'll edit it by hand records that you will change it yourself. CodeCargo tracks that change until you mark it done or an analysis no longer finds it.
- When the repository has no GitHub repository yet, Choose a target opens the mapping.
Who can save an answer
Saving an answer, dismissing, changing a finding by hand, marking that change done, re-confirming, or restoring needs the Migration Assistant manage permission. You can still preview an option without it.
Changing a Finding by Hand
Choose I'll change it by hand when you will fix a finding yourself, instead of dismissing it. Say whether the change goes In the update PR or Somewhere else, and leave a note about what you will change. That settles the finding, so the update pull request can open. CodeCargo writes no edit of its own.
- In the update PR. The pull request opens as a draft, and its description lists what is left under Left for you to change, with a link to the file and to GitHub's editor on the update branch. If it is not open yet, open it from Pull requests. Make the change on that branch, then mark it done. Marking the last one done marks the pull request ready for review. Another change by hand on that open pull request turns it back into a draft. If GitHub does not support draft pull requests on that repository, it opens ready for review, and CodeCargo still does not merge it until the changes are confirmed.
- Somewhere else. Make the change on the branch yourself. If the repository is skipped, or nothing else on the row would change, no update pull request opens to carry a change in it. Change the file on that branch, or switch the finding to Somewhere else.
A change is confirmed when you mark it done — you can add a note about how — or when an analysis no longer finds it. CodeCargo does not merge an update pull request while a change in it is still unconfirmed, and does not rebind a pipeline that depends on a change made by hand. If an analysis after that pull request merged still finds a change that was meant to be in it, the change needs you again.
To take on everything left on a row at once, click Hand the rest to me in the PR in its panel, add one note, and click Hand them over. Every finding that still waits on you goes to the update pull request, and the pull request is queued to open. It is refused when the row is skipped, the update pull request has already merged, the update would change nothing else, or nothing on the row is still open.
The Same Question in Many Repositories
The same open question often appears in many repositories: the same finding, in the same surrounding lines. The question tells you how many repositories have it. Answer or dismiss it once, and that decision is recorded for each of them, except any you leave out. You can't leave out the one you are answering.
Each repository still gets its own decision. It is saved only when the answer fits that repository's file. One that doesn't fit stays a question, and you see why. Answer that one on its own, or answer another open copy later — that reaches the ones still open.
- A dismissal is copied as you wrote it.
- A fix is copied when it changes only literal text, or when it replaces
$(System.AccessToken)with a pipeline secret in that token's place. - A fix that changes an expression the pipeline fills in, such as
$(System.TeamProject)or$(Build.Repository.Name), is not copied. Those can mean something different in each repository, so the others stay questions. - An answer that names the repository you answered is copied as written only when the finding's own reference names that repository. When the code means this repository only through a self-reference such as
$(Build.Repository.Name), each other repository is pointed at its own name. If the answer types a name in directly, or names a project, branch, or service connection that differs in another repository, that repository stays a question.
You need the Migration Assistant manage permission, the same as for one answer. A repository still queued to open its update pull request leaves the queue once a decision is recorded for it. Open it again from Pull requests so the pull request includes the answer. If GitHub's rate limit stops the update early, repositories not yet reached stay questions — answering any of them later answers the rest.
You can also record I'll change it by hand for every copy, in each row's update pull request or Somewhere else, with one note. A repository whose update pull request cannot take a change in that pull request stays a question, and you see why.
Excluding Individual References
In a row's panel, untick Include in the update PR on an automatic update to leave it out of that branch's update pull request. Excluded references are removed from both the pull request's diff and its description. If every reference on a row is excluded, the row has nothing to update.
Exclusions persist across re-scans. If a re-scan changes the surrounding text, CodeCargo re-matches your exclusion automatically; any that no longer match are flagged as stale rather than silently dropped.
Pipeline settings that aren't text in a file — service connections, variables, composed URLs, and template dependencies — are not included in update pull requests. The one exception is the YAML pr: block, which the update writes from the build validation policies (see What the Update Pull Request Contains). Dismiss a pipeline-setting item when you've handled it outside the pull request or chosen not to. Dismissing is the resolution, and a row whose only remaining items are dismissed counts as done.
Changing exclusions on a row that is still queued to open takes that row out of the queue. The request was made with the previous exclusions. Open it again from Pull requests so the pull request includes the exclusions you just set.
References Outside This Migration
A reference to a repository no mapping in this instance can hold does not wait on a mapping. The panel lists it under Outside this migration, and the update pull request does not rewrite it. A relative URL in .gitmodules is one of these. Dismiss the reference once you have handled it, or change the line yourself. Until you settle it, that reference can keep the row from opening an update pull request.
A Skipped Repository
A branch can arrive skipped, from a dry run's decisions file, for example. A skipped row reads Skipped under No changes, and gets no update pull request. Its pipelines are held back from the rebind as Repo skipped, and so are pipelines that read templates from it. To bring it back, open its panel and click Put back in the update queue. Other branches of the same repository are not affected.
Pull Requests
Every update pull request, from ready to merged, is in this stage, in three lists: Ready to open, Open, and Merged. Each row's Status reads Ready to open, Opening, Open, Merging, or Merged, and the open and merged lists link each Pull request.
When shared template repositories are not updated yet, a band names them. Open and merge their update pull requests before the others, because pipelines in other repositories use their templates.
Opening Update Pull Requests
On Ready to open, click Open N update PRs to open every ready repository's pull request, or tick rows and click Open selected (N). A ready row has an edit to make and nothing waiting on a decision. Each row gets its own update pull request on its branch.
Pull requests open through a background queue, paced to what GitHub allows one organization an hour, so a large batch takes hours. It finishes even if you close the page. A bar under the stage strip shows the queue's progress and about how long is left, and says when GitHub is rate-limiting the organization. A row shows Opening while its pull request is created, then moves to Open.
Merging Update Pull Requests
Review the open pull requests in GitHub. Then, on Open, click Merge all open PRs, or tick some and click Merge selected (N), and confirm. Each merges on GitHub as it stands, with the first merge method the repository allows — squash, then rebase, then a merge commit — and its update branch is deleted. A merge can't be undone from CodeCargo. Each pull request updates one branch, so a repository can have more than one open.
A pull request GitHub refuses to merge — branch protection or a merge conflict, for example — stays open for you to finish in GitHub. So does a pull request that still has a change you are making in it by hand. Mark those done, then merge that pull request on GitHub. See Changing a Finding by Hand.
A pull request merged or closed on GitHub is normally picked up on its own. Check PRs reads every update pull request's state from GitHub now. Merged ones move to Merged, and their pipelines are rebound in Rewire.
What the Update Pull Request Contains
Each update pull request carries the automatic reference rewrites from the scan, then the fixes recorded for that branch: proposals from AI review, answers you gave in CodeCargo, and imported fixes. A branch whose only remaining work is one of those fixes still gets a pull request — the fix is in the diff, not only on the page.
The description lists the automatic changes first, then:
- Decided by AI review — fixes the review recorded
- Answered in CodeCargo — fixes from an answer you gave
- Left unchanged — items you dismissed, with the note you left
A fix already delivered in an open or merged pull request is not included again. Close that pull request without merging and the fix comes back: the next update pull request for the branch carries it and is stamped on the decision again.
A fix that no longer matches the file
If the text a recorded fix replaces is gone once the automatic updates apply, or the fix breaks the file, that fix is set aside and the row shows it as needing a person. Nothing is written for that attempt. Open the pull request again to deliver the rest without it.
For a YAML pipeline, the update pull request also writes a pr: block from the build validation policies that named the pipeline. On Azure Repos those policies were its pull request validation. The YAML pr: block was not what Azure Repos read. Review the block in the pull request: after you merge and rebind, that is what runs.
An exact branch policy becomes that branch. A prefix such as releases becomes releases/*. The row labels each policy's branches the same way. A policy set to queue manually becomes a comment trigger — the pipeline runs when someone comments /azp run, not on every pull request. No enabled policy validating this repository's pull requests means no pull request trigger. Path filters follow the policy. A path that starts with neither / nor a wildcard is ignored, as Azure DevOps ignores it. A policy that included nothing validated nothing.
Where the block cannot say exactly what the policies did, it covers more branches or paths, never fewer. The pull request and the row say so. A classic pipeline has no YAML to edit. Its trigger is set on the definition when you rebind.
Rewire
Once the update pull requests are merged, Rewire lists the imported pipeline definitions, YAML and classic, that are waiting to be rebound onto their GitHub repositories. Definitions on unmapped repositories are omitted. Pipelines of repositories that moved to another destination org are rebound there. Filter by Ready, Not ready, or All awaiting. A definition's Status says what holds it back, such as Awaiting updates or Branch not on GitHub.
Rebinding is two steps:
- Approve for rebind. Check the definitions to rebind, or check none to approve every ready one, then click Approve for rebind (N). The Approval column marks each approved definition. Withdraw approval (N) takes it back. Each approval covers one rebind.
- Rebind. Click Rebind N pipelines and confirm. CodeCargo points each approved, ready definition at its GitHub repository through this organization's Azure DevOps connection, repairs its pull request trigger in the same save, and checks it afterwards. Approved definitions that aren't ready are left alone.
A line under the toolbar follows the rebind, with Cancel rebind while it runs. CodeCargo runs one rebind, rollback, or check at a time on a connection. A rebind that a Migration Plan wave starts from its wave page shows here too. You still approve its pipelines on this page.
To run it yourself instead, Run from your machine gives a Docker command for the importer (the button reads Run rebind (N) when CodeCargo can't rebind through the connection). It needs a credentials file whose Azure DevOps personal access token has Build read and execute; Generate credentials file downloads one. Either way, each definition's original is saved in CodeCargo before it changes, and the command also writes it to Downloads/rebind-snapshots, so any rebind can be rolled back from Verify. Results appear in Verify.
Merge before rebinding
Rebind only after the update PRs for those repositories are merged. Rebinding before merging may leave pipeline references in an inconsistent state.
When a Definition Is Not Ready
A definition is rebound on the branch it builds from, and the rebind keeps that branch. It stays Not ready while that branch is missing on GitHub, or while the scan has not read that branch yet. Restore a renamed or deleted branch, then click Re-analyze before you rebind.
A definition also stays Not ready until every repository it reads templates from is ready, on the branch those templates are read from — including templates reached through extends and nested includes. With no ref:, or a ref: that is computed when the pipeline compiles, that is the template repository's default branch. A ref: that names another branch is checked on that branch, not the default branch.
The reason names one repository at a time, the first that is not ready. After you clear it, check the definition again.
- Merge that repository's update pull request, then rebind the definition. A repository that had nothing to update does not keep the definition Not ready.
- If the template repository is skipped, put it back in the update queue and open its update pull request. Until then its references still point at Azure DevOps, so pipelines that read its templates stay Not ready. See A Skipped Repository.
- If the reason says the repository or branch has not been scanned, or that its updates can't be read, click Re-analyze, then rebind.
A tag or commit pin is not one of these checks. Settle that row on the resource's ref: line, as described in Repository Resources Pinned with ref:.
A definition also stays Not ready while changes made by hand in its repository, or in a repository it reads templates from, are not confirmed yet. Mark them done on this page, or click Re-analyze once they are in, then rebind. If no update pull request will open to carry them, make them on that branch and mark them done first. See Changing a Finding by Hand.
A definition does not remain Not ready because it reads templates from a repository marked Stays in Azure DevOps, or from a repository no mapping holds. It keeps reading that Azure Repos resource from Azure DevOps. If it still waits on that repository after you mark it as staying, click Re-analyze, then check the definition again.
If an update pull request that is already open or merged rewrote that resource to GitHub, the definition still waits on that pull request. Merge it, then rebind. After it merges, the pipeline reads those templates from GitHub.
When the reason says a repository has no update pull request to merge yet because some references are still open, or left out of it, settle them in Review references, then rebind. A reference still waiting on a mapping needs a GitHub repository or Stays in Azure DevOps.
Access the Rebind Needs
Before CodeCargo rebinds pipelines, it checks what the connection can do in each Azure DevOps project those pipelines belong to. The check uses the same sign-in the rebind would: CodeCargo's user, when the organization connected through Microsoft sign-in, or the personal access token, when it connected with one. It runs when you open the page, and again as your approvals change. Only projects the rebind will update are listed, and the Rewire card in the strip says how the check went.
For each project the page reports allowed, missing, or unknown:
- Edit build pipeline. Without it, Azure DevOps refuses the rebind (TF215106).
- Queue builds
- Use on each GitHub service connection the rebind goes through
A missing permission is called out before the rebind runs, with how to fix it. A definition in a project still missing one of these does not rebind. Grant what the page names, then click Recheck access, which asks Azure DevOps again once the last answer is 30 seconds old.
- Microsoft sign-in. Update access on the organization's Azure DevOps connection grants Edit build pipeline and Queue builds. If it isn't offered there, or Azure DevOps refuses, a Project Administrator allows them for the CodeCargo Azure DevOps Connector identity under Pipelines → More actions → Manage security in each project.
- Personal access token. A Project Administrator allows them for the token's owner the same way. The token also needs the Build (Read & execute) and Service Connections (Read & query) scopes.
- Use on a service connection. Open Project settings → Service connections → the connection → More actions → Security, and add the CodeCargo Azure DevOps Connector identity, or the token's owner, as a User.
Remove a deny the same way. The check reads project-level permissions; a folder's or a pipeline's own permissions can differ.
Unknown is not missing
Unknown means Azure DevOps would not answer — a personal access token without the scope to read permissions, for example. The page says why. If sign-in failed, the check fails; sign in again, then run it again.
Verify
Verify gives each pipeline one status, from its setup check and its runs from GitHub since the rebind. CodeCargo reads those runs from Azure DevOps every few minutes. Filter the list by status:
- Needs you - Its setup check, or its latest run from GitHub, needs you: its pull request trigger needs a repair, its setup check found a problem such as YAML that doesn't compile, or its latest run failed or is stuck. Verify opens on this list.
- Waiting - Not rebound yet, or no passed or failed run from GitHub since the rebind. A run that's still going, or that was canceled, doesn't count.
- Passed - A run from GitHub since the rebind passed, with or without warnings. The first pass decides it: a later failure doesn't take it back, though the row mentions it.
- Not watched - Disabled or paused in Azure DevOps, or someone stopped watching its runs.
- All pipelines - Every pipeline.
The table shows each Pipeline with its Project, Repository, Status, and Why: what its setup check needs, or what its latest run did, such as No run from GitHub yet. or Its latest run from GitHub failed. Click a row to open its panel: where it moved from and to, its runs on GitHub, its definition, YAML path, pull request validation and trigger, and any compile error with what to do about it.
A band across the top says the one thing to do now: grant missing access and click Recheck access, repair triggers with Check and repair, review the pipelines whose latest run failed or is stuck (Show them), rebind the pipelines still waiting (Go to Rewire), or wait for their runs. When every pipeline passed or isn't watched, the band says so.
From a repository's panel in Review references, See in Verify opens Verify on that repository's pipelines.
Check and Repair
Check and repair checks each rebound pipeline in Azure DevOps through this organization's connection, as a job CodeCargo runs. It verifies the binding, sets the pull request trigger from the pipeline's build validation policies — adding, fixing, or removing it — and preview-compiles the rebound YAML. Nothing else about a pipeline changes. Pipelines still on Azure Repos are left alone and counted as waiting for the rebind.
Before it runs, CodeCargo checks its access in each project, as for the rebind. Missing access only warns, because the check still checks what it can. Without Edit build pipeline it can't repair a trigger. Without Queue builds it can't run the compile check that confirms a YAML pipeline. Without Use on a service connection it may not be able to save a repaired trigger. Grant what the band names, then click Recheck access.
The check skips verified and repaired pipelines by default. In the confirmation, turn on Recheck verified and repaired pipelines if a rebind may have been undone outside CodeCargo, a later import picked up branch policy changes, or you want to confirm everything before a cutover. Checked beside the filters says when the check last ran. A pipeline's trigger and setup check results change only when a check runs. The check saves each result as it goes. If it stops before it finishes, run it again: pipelines already settled are skipped.
On Azure Repos, build validation policies decided which pull requests built. The check uses the policies the import recorded. A YAML pipeline uses the pr: block when that block is the trigger the policies call for, including after the update pull request that writes it has merged. See What the Update Pull Request Contains. A classic pipeline has the trigger set on the definition. So does a YAML pipeline when the file is left unchanged: its definitions call for different triggers, you left the edit out of the update, or no edit of its own can write the block. The row says why.
A pr: block already in the file does not settle the trigger. pr: none does not skip the check, and a different pr: on the default branch is not used. A pipeline with no enabled policy still needs the check, which removes a trigger the policies do not call for.
A definition is not checked, and stays Not ready to rebind, when:
- No import has read its build validation policies. If the import could not read them, it warns you. That is not the same as no policy. Import the project again, then run Check and repair again.
- Its pull request trigger is still in the repository's update pull request. Merge that pull request, then run Check and repair again.
When the pr: Block Does Not Match
Answer on the row when the file's pr: block is not the trigger the policies call for.
- Someone changed the block after the update set it. Until you answer, that block runs and the pipeline needs you. Keep it, and the YAML keeps deciding. Match the policies by hand, and the definition carries their trigger until the block matches.
- The policies changed after the update, or the block was never set from them. Until you answer, the definition carries the policies' trigger. Keep the block, and the YAML decides from then on. Match it by hand, and the definition keeps their trigger until it does.
Mark a by-hand change done, then click Re-analyze. If a later scan still does not match, make the block match and analyze again, or change the answer. See Changing a Finding by Hand. If a merged update may not carry the block, the definition carries the policies' trigger until an analysis reads the merged file. Click Re-analyze.
Run the Check from Your Machine
Use this only if CodeCargo's connection isn't allowed to edit pipelines in your Azure DevOps organization, or CodeCargo can't run the check here — when the organization isn't connected, for example. Open the menu beside Check and repair and choose Run from your machine…. Where CodeCargo can't run the check, Run from your machine is the button itself. It runs the same check with Docker and your own Azure DevOps credentials, and the results report back to the page.
You need Docker and a credentials file. Generate credentials file downloads one with a fresh CodeCargo token and the Azure DevOps personal access token you enter, which needs Build read and execute, plus Code read. A file generated here lasts 7 days, and one from the import page lasts 24 hours. If yours has expired, generate a new one. Copy the command and run it.
To check specific definitions instead of every imported YAML pipeline definition for this instance, add ADO_DEFINITIONS to the credentials file, or pass the same list as --definitions:
ADO_DEFINITIONS=Payments/231,Billing/7
Each entry is the Azure DevOps project and that project's definition id. Definition ids are numbered per project, so the project name is required. An empty value, or a value made only of commas, is rejected — it does not select every definition.
Watching Runs from GitHub
After a pipeline is rebound, CodeCargo watches its runs from GitHub and moves it from Waiting to Passed or Needs you. A pipeline with no run says No run from GitHub yet., or No run from GitHub in the 14 days since its rebind. once two weeks have passed.
To stop counting a pipeline you don't expect to run, open it and click Stop watching. It moves to Not watched instead of Waiting or Needs you. Its runs still show, and a run that passes still counts. Resume watching counts its runs again.
If Azure DevOps refuses the connection's credential, the row says CodeCargo can't read its runs. Update the credential on the Azure DevOps connection, and the runs show again.
Why a Run Failed or Is Stuck
When a pipeline's latest run from GitHub fails or is stuck, CodeCargo looks into why, and the Why column says what it found. While it is still looking, the pipeline's panel says so.
- A cause, or Possible cause: and a summary when the evidence doesn't settle it. Where someone has to act, the panel says what to do: authorize the pipeline to use a resource, approve the run, bring agents online in the pool, add a hosted parallel job, set a secret's value, or fix the YAML or a failing step in the repository.
- Already failing before the move, or Already failing before the move, in a different way, when the pipeline's runs on Azure Repos failed too. The panel's Before the move compares the run with those.
- Waiting for approval or Waiting for a check, when its runs before the move waited on the same thing. That is normal.
The panel shows the failing step and links the runs. Diagnose again asks for another look. Same cause in N pipelines lists every pipeline failing the same way. The filter above the table says how many, and clicking it clears it.
Roll Back a Rebound Pipeline
On Verify, you can point a rebound pipeline back at its Azure Repos repository. Open the pipeline and click Roll back under Undo the rebind, then confirm. To roll several back at once, check their rows and click Roll back (N).
CodeCargo runs the rollback over this organization's Azure DevOps connection, from the original it saved before the rebind. It restores that repository and the original triggers, and withdraws the rebind approval, so approve it again to rebind it. Other settings on the pipeline stay as they are. The update pull request on GitHub is left as it is.
The page shows progress and each pipeline's result. Click Cancel rollback to stop a rollback that has not finished. Pipelines already rolled back stay rolled back.
A pipeline whose original CodeCargo did not keep is left out. Roll back from your machine gives the importer command for that pipeline. It uses the snapshot the rebind wrote on that machine, in Downloads/rebind-snapshots.
When a pipeline is left alone
You need the Migration Assistant manage permission. While Dry run is on, rollback is not offered.
CodeCargo runs one rebind, rollback, or check at a time on a connection. Wait for it to finish, or cancel it.
A project that is not selected on the connection is left alone. Select it on the connection page, or roll those pipelines back from your machine.
If a permission is missing, the page names it and how to grant it.
If the approval was withdrawn and the write then failed, the row says so. If the approval cannot be withdrawn, that pipeline is left unchanged.
Limited to a Migration Run or a Wave
Prepare for rewire can open on only the repositories a migration run moved into this organization. A filter under the title names that run, such as Moved by run #12. Click it to remove the filter and show every repository in the Azure DevOps organization again.
A Migration Plan wave's Rewire pipelines card opens each destination org's page limited to that wave, which stands for every run that moved the wave's repositories there. The filter reads Wave N, and the address carries a wave parameter. A follow-up opens the page on the runs that copied its repositories, each a repeated runs parameter. Either way, a shared link opens already limited. The filter only names runs of the organization you are in. A repository the run did not move here is left out, and so is a copy archived on GitHub after its disabled source migrated; the Overview says how many.
While the filter is on, references, questions, changes made by hand, Review with AI, opening and merging update pull requests, and exports cover only those repositories. These parts stay for the whole instance, and the page says so where they appear:
- the update pull request queue's progress, and Check PRs
- Service connection
- Review mappings
- Rewire and Verify, except the pipelines they list, which keep to the filter
- an answer recorded for the same question in many repositories
- an AI review of the whole instance that is already running
In a Plan's Destination Org
When a Migration Plan wave rewires Azure DevOps pipelines, it carries the sandbox's decisions onto this page in each destination org, and opens the page there limited to that wave. In the destination org you merge the update pull requests and approve pipelines for the rebind. The wave's Rewire pipelines stage applies the decisions and runs the rebind.
What the Plan Records in a Destination
When the plan rewires a destination org, it records on that org's repository mapping what a repository already moved there still references. You do not enter these. A preview records the same marks. It still does not apply the rewire decisions themselves.
- A repository that moves into this org later is recorded with the wave it moves in. If that wave has already come and the repository has not moved, the move is recorded as due. References to it read Waits for wave 5 on this page, or Waits for Platform/ledger to move here (wave 5) once the move is due, rather than waiting for you to map the repository.
- A repository the plan leaves on Azure DevOps on purpose is marked Stays in Azure DevOps: confirmed, with no GitHub repository. References to it are left as they are. See Stays in Azure DevOps.
The plan only fills in a mapping nobody has decided. A mapping you confirmed, a stay you chose, or a GitHub repository you set is left as you left it. So is a mark another plan recorded.
A mark the plan no longer stands behind is taken back, including a stay and the confirmation that came with it. Once the repository has moved into the org, the plan's mark is cleared. A repository that nothing moved here references is left unmarked.
Repositories That Move to Another Org
The plan also records a repository it sends to another destination org, when a repository already moved here references it.
Until that repository has moved, the mapping waits for its wave and names the org. A reference that waits reads Waits for wave 5, when Platform/ledger moves to acmebank-platform. When the move is already due, it reads Waits for Platform/ledger to move to acmebank-platform (wave 5).
Once that destination is linked to its CodeCargo organization, and its mapping names the GitHub copy (confirmed, or recorded by an in-app migration or the Migration Log), this org reads it from there. The mapping is confirmed to that repository. Rewire can then point those references at the copy, through a GitHub App service connection installed on that org. See When a Decision Waits on Another Org.
Every project whose repositories moved here and reference it needs that connection under the same name. If more than one name is shared, CodeCargo uses the first in alphabetical order. If the projects do not share one name, or the import did not record which account the connection is installed on, the mapping keeps waiting. It does not point at a repository no pipeline can reach. Create or share the connection in those projects, then click Check again, as No GitHub Service Connection Yet describes. The plan records the target the next time it rewires this org, or previews that rewire.
If the copy is no longer found in that org, the mapping waits for the wave again. If the plan no longer sends the repository there, the mark is taken back, including the confirmation and the connection, and a stay or a wave in this org takes its place.
A mapping you decide ends the plan's mark, including a target in the other org and the connection the plan set for it. A connection this org already had, while the repository had not moved there yet, stays. When the repository moves into this org, that mark ends with it, so the other org's connection is not left as this org's.
When a Decision Waits on Another Org
On the wave's Rewire pipelines stage, a destination org's preview counts decisions that still need a target. Of N that need a target names two waits for a repository the plan sends to another destination org:
- N wait for their repository to move to another destination org. That copy is not available to this org yet. Once its wave moves it there, choose Preview again.
- N need a GitHub App service connection to another destination org. The repository has moved, and no GitHub App service connection from this org reaches it. A personal access token connection does not, and neither does the connection this org uses to rebind its own pipelines unless that connection is installed on the other org. Create or share a GitHub App service connection installed on that org, then choose Preview again. See No GitHub Service Connection Yet.
A decision that names more than one such repository counts once, as whichever of those waits longer: the move, then the connection.
Preview again scans that org again when a repository the plan sends to another destination org changed since the last scan, so the preview reads that target as it is now. With no such change, it keeps the last scan.
Dry-Run Organizations
A dry-run organization connects the same Azure DevOps organization as production and copies repositories into a separate GitHub organization, so you can rehearse the rewire before production does it.
A Migration Plan's sandbox is a dry-run organization. Starting the plan turns on Dry run there, and it stays on for as long as the plan exists: Prepare for rewire shows a locked Dry run badge instead of the switch. Each wave's Rewire pipelines stage carries the decisions, so don't export or import them.
Turning On Dry Run
Turn on Dry run in the dry-run organization. The pipeline definitions it imports are production's. Rebinding them from here would point those pipelines at this organization's repositories.
The Dry run switch sits in the header of Prepare for rewire once the instance has been analyzed, and it applies to the whole organization. Turn it on before anyone rebinds. Leave it off in the organization whose GitHub repositories production pipelines should build from.
While Dry run is on:
- Rewire and Verify say Rebinding is off in a dry run, and why. They offer Export decisions instead of the rebind and Check and repair. Their cards in the strip read Off in a dry run.
- The service connection chosen here doesn't matter. It isn't exported.
- A check-and-repair started from this organization stops before it changes anything in Azure DevOps. Running it again is refused until you turn Dry run off.
- Update pull requests tell you not to rebind pipelines to this organization's repositories.
Turning Dry run off asks you to confirm, because that allows rebinding again: Turn off dry run? Turn it off only in the production organization.
A rebind already running is not stopped
Turning Dry run on does not stop a rebind command you already copied from Rewire, or a check that has already started. Stop those yourself, then check which pipeline definitions they changed.
Carry Decisions from a Dry Run
Decisions you make in the dry-run organization do not have to be made again in production. Carry them over, and production's update pull requests open with those decisions already recorded. Findings you already decided are not sent for AI review again.
- In the dry-run organization, open Prepare for rewire and choose Export → Decisions for import (.json). In a dry run, Export decisions on Rewire and Verify downloads the same file.
- In the production organization, open Prepare for rewire for the same Azure DevOps organization. Analyze the instance if you have not already — decisions are matched to that analysis.
- Click Import in the page header, choose the file, review the preview, and apply it. Nothing is written until you apply it. The Overview then counts what was imported, and from which organization.
On a page limited to a run or a wave, the file carries only those repositories' decisions. You need the Migration Assistant manage permission in both organizations. Importing the file into a different Azure DevOps organization is refused.
Repositories are matched by Azure DevOps project and repository name, ignoring differences in capitalization, then by branch and finding. The file carries fixes, dismissals, and questions; edits you left out of an update pull request; and shared template or skipped marks. It does not carry GitHub targets, mapping confirmations, or the service connection — confirm those in production in Review mappings and Service connection. A carried decision is filled in from production's mappings, so it points at production's GitHub repositories, not the dry-run organization's. One that names a repository with no migrated target here is kept, and applies once you map it.
A finding this organization already decided keeps that decision unless you choose to replace it. When the file changed since the dry run, a fix or dismissal is still carried for AI review to confirm across that change. A question goes back for review.
A row is not applied when this organization has no mapping for that repository, has not analyzed that branch, or no longer finds that reference. It is also left as it is when the update pull request is already open or merged, or the repository is queued to open one. Import the file again after that pull request opens. A skip in the file takes a queued repository out of the queue instead.
A shared template mark takes effect the next time you click Re-analyze. A skip applies only to branches still awaiting an update pull request, and import never clears a skip or shared template mark this organization already set. An edit is left out only when this analysis plans that same edit, up to the same limit as on the page. A decision the dry run set aside, because no Azure DevOps repository mapped to it, is not included. Notes, the person who decided, and the source organization name are masked.
Questions CodeCargo asks after the scan are not in this file. The organization you import into asks them after its own analysis. An answer in the file applies over that question, because the question is not a decision made there. When the dry run decided a different problem with that reference than this organization's analysis reports, the preview marks the row changed and says the decision was about a different problem.
The file also carries a Stays in Azure DevOps mark. Other mapping confirmations still do not travel. Applying the mark confirms that mapping with no GitHub repository, and references to it are left as they are. If the repository already moved to GitHub here, the mark is not applied — the preview says it moved, so it does not stay. Import never clears a stay this organization already set. When a pipeline reads templates from that repository, or an az repos call reaches it, click Re-analyze after you apply the file.
Exporting Rewire Data
Click Export in the page header at any point to download the current findings for sharing with teams outside CodeCargo:
- Excel workbook (.xlsx) — all sheets - One file with a Read me sheet, the References list, a Repository summary, and the full Azure DevOps to GitHub mapping, with plain-English labels and styled, frozen, filterable headers so it's readable even by teams unfamiliar with CodeCargo.
- Repository mappings (.csv) and References (.csv) - The mapping and the reference list on their own, as UTF-8 CSV files that open cleanly in Excel or any spreadsheet tool.
- Decisions for import (.json) - The decisions file another CodeCargo organization imports. See Carry Decisions from a Dry Run.
The mapping lists the imported pipelines that live in each repository and the files in other repositories that reference it. The reference list says whether each reference is in a pipeline file. This lets you trace any mapping or reference back to the pipeline that surfaced it.
Every repository on the page
Exports include every repository on the page, whatever search, filter, or page the table shows. On a page limited to a migration run or a wave, they cover that run's or wave's repositories.
The repository summary includes the branch each update applies to. A repository whose pipelines build from more than one branch appears once per branch, matching the rows on this page.
How Specific References Are Handled
The sections below are reference material. They cover the references that need more than a URL rewrite: how the scan treats each of them, and what you decide.
Repository Resources Pinned with ref:
A repository resource (@alias) is read at the copy its ref: names. With no ref:, or a ref: that names the repository's default branch, the scan reads the default checkout and those updates go on that branch's pull request — including when the alias names this repository. A ref: that names another branch is read on that branch. Relative includes inside a template stay on that copy. An alias an extends template declares is part of the pipeline, including a ref: on that alias.
A pinned branch gets its own row and update pull request for the files pipelines include from it. If a pipeline already builds from that branch, those files are part of that branch's row. If nothing is included from the branch, it has no row.
A tag or a commit is scanned the same way, but no pull request can update it. A copy that needs nothing is left out. A copy that needs changes is one row on the resource's ref: line, listing the files and how many edits and manual fixes each needs.
- Make the changes on the branch the pin was cut from.
- Move the pin to a tag or commit that has them.
A pin declared inside that copy, such as by an extends template on the tag, is its own row on the pin that reads the copy.
Each pin is one row on its ref: line, named for the alias, however many templates the pipeline includes through it. You settle that row yourself — it is not included in an update pull request — when:
- The
ref:is computed when the pipeline compiles. Check the templates on every branch or tag the expression can name. - The migrated repository has no such branch, tag, or commit. The include will not compile after the resource is rewired until the pin names a copy that exists.
- This scan could not check the copy out, or could not tell the repository's default branch, so it read no copy. Click Re-analyze once that copy can be read.
A Repository Reached Over SSH
A pipeline step, a script, or a Terraform module source that reaches a repository that is moving over SSH is one of the questions the scan asks. GitHub does not accept the key Azure DevOps holds, so rewriting the URL to GitHub's SSH address does not settle it. An SSH URL in .gitmodules is rewritten to HTTPS instead, and is not asked about.
- I'll add the key on GitHub. Add the key the step uses to the GitHub repository as a deploy key. Give it write access only if the step pushes. You add the key on GitHub, not in the update pull request, then mark the change done. The line still uses SSH, so a later analysis does not clear it. See Changing a Finding by Hand.
- I'll change the step by hand. Switch the step to HTTPS in the update pull request, then mark it done.
- Leave it: GitHub already accepts the key this step uses. The line stays as it is.
A git command that ssh runs on a deployment host is not this question, even when its URL is SSH. That host reaches the repository with its own key. See Git Commands Run on a Deployment Host.
Git Commands with No Credential
A git clone, git ls-remote, git push, or similar command that reaches a repository that is moving, and carries no credential, is flagged on its own. A command that reaches it over SSH is asked about separately.
A read is dismissed while the GitHub copy is public. GitHub answers that read with no credential, so nothing is rewritten. It does not need an answer, and it does not block the update pull request. A push is not dismissed: GitHub does not accept a push with no credential, even to a public repository. A read is not dismissed once that copy is not public. Those findings go to Review with AI with your other credentials.
A git command that ssh runs on a deployment host is not the agent's credential. See Git Commands Run on a Deployment Host.
Git Commands Run on a Deployment Host
A git clone, git fetch, git push, or similar command that ssh runs on a deployment host reaches the repository with that host's credentials, not the pipeline agent's. The update still points the URL at the GitHub copy. No edit of the pipeline gives the host access there, so CodeCargo does not ask a question.
It lists the hosts' access as a change made by hand, labeled Listed by the analysis. Before the repository moves, give those hosts the access the command needs — read for a clone or fetch, write for a push — with a deploy key or a token in their git credentials. CodeCargo cannot see the hosts, so a later analysis does not clear this item. Mark it done on the row once the hosts are set up. Until you do, it holds the pipeline rebind. See Changing a Finding by Hand.
A done mark stays until the line needs different access. Read access you already confirmed does not cover a push.
Nothing is listed when the command only reads a public GitHub copy, when the repository stays in Azure DevOps, or when it has no GitHub repository yet. A push still needs access, even to a public copy. Host access is listed only once that repository has a GitHub home.
A command that already carries a credential, such as a token in the URL or a git -c setting, stays a credential finding wherever it runs. An SSH URL the host uses with its own key is this item, not the one under A Repository Reached Over SSH.
Azure CLI Calls to Azure Repos
The scan flags az repos commands, and az devops invoke --area git, that talk to a repository moving to GitHub. It finds them in pipeline YAML and in scripts the pipeline runs, including an AzureCLI@2 inline script. Left unchanged, the call keeps using the Azure Repos copy after the repository has moved.
CodeCargo does not rewrite most of these calls. Where the call has a GitHub CLI counterpart, it needs a GitHub token and reviewers mapped to GitHub users or teams. After the scan, CodeCargo asks and includes the suggested gh command when it has one. If it cannot tell which repository the call targets, the question does not include a command. Leave the line as it is, or make the change yourself.
An az repos ref create against this pipeline's own repository is rewritten when that can be done safely. See Branches and Tags.
An az repos import stays pointed at Azure DevOps. The update pull request writes that Azure DevOps URL into the import and leaves the variables and URLs it reads pointing at Azure DevOps, so the import does not read the GitHub copy. An az repos import create has no gh counterpart, so it is asked on its own, and only as a repository that is moving when the scan finds one. When the scan cannot tell which source an import reads, those lines are listed on their own, and Review with AI can settle whether anything else reads them. You can still change one of those lines yourself; a fix you did not make yourself will not.
Branches and Tags
az repos ref create against this pipeline's own repository still succeeds after the move, but it creates the branch or tag on the Azure Repos copy. Nothing that reads the GitHub repository sees it. When the rewrite can be done safely, the update pull request changes the call to gh api, which creates the same branch or tag at the same commit.
That command uses the GitHub token the job's checkout keeps for an hour from the job's start, and only this command reads it. The pull request sets persistCredentials: true on the checkout and drops the step's Azure DevOps token.
The update pull request includes that rewrite, and does not ask you, when:
- The call targets this pipeline's own repository, through an Azure Pipelines GitHub App connection.
- It is in a pipeline YAML step, not in a template or a script file, and nothing but the checkout runs before it.
- The agent is one the rewrite has been proven on: bash on Microsoft-hosted Ubuntu, or PowerShell on Microsoft-hosted Windows.
- The ref name starts with
heads/ortags/, with or without arefs/prefix. A name that is only a variable is left for you. - A commit id written in the call is the full 40 characters. A pipeline value such as
$(Build.SourceVersion)is kept as written.
If the call runs after other steps, Review with AI asks you instead. Those steps may outlast the token. The question names what runs first. Port it in this step when that work finishes within the hour, keep making the branch or tag in Azure Repos, or do it by hand: run the call in a small job of its own so it gets a fresh token, or give the step a longer-lived credential.
Anything else is a question after the scan. That includes a self-hosted pool, bash on Windows, PowerShell on Ubuntu, a name that is not a branch or tag, a short commit id, another repository, a connection that is not a GitHub App, and GitHub Enterprise Server, where the GitHub CLI reads its token from another variable. The question includes the gh api command and says why.
Leave it settles only that command. Keeping this call on Azure Repos does not keep an az repos pr create, and a Leave it on a pull request call does not keep this one. An answer that does not name a command applies to the pull request call.
Checkout Folders
Azure DevOps checks a repository out to s when it is the job's only checkout, and to s/<repository name> when the job checks out more than one. The name is the repository's, not the alias. A path: on the step overrides both. A rename on GitHub changes that folder only in a job with more than one checkout. A deployment job's hooks, such as preDeploy and deploy, each run as their own job.
When every pipeline that runs a checkout checks it out to the same folder, and the move would rename that folder, the update pull request adds path: s/<folder> on that step so anything that uses today's folder keeps working. A job's only checkout stays in s. A step that already sets path: is left as it is. The path is written on the checkout step itself, including in a template. Pipelines that include the template have no checkout step to pin.
CodeCargo asks you after the scan when one path cannot keep every pipeline that runs the step. The reason names those pipelines and folders.
- They check it out to different folders. I'll set the step's path by hand puts one path on the step in the update pull request. I'll change what reads its folder by hand updates whatever uses the folder name, somewhere else. Leave it: nothing reads its folder by name keeps the step as it is.
- The update leaves the path to you. A template another repository runs checks
checkout: selfout into that repository's folder, and a path would give any pipeline that runs the template later that one folder. The same question covers a path no edit can place, such as the same checkout line in a job that must not take it. I'll set the step's path by hand or I'll change what reads its folder by hand. There is no option to leave it: the folder moves with the rename.
A path you add on the step is confirmed the next time the analysis runs. A change somewhere else is not in the file, so mark it done. See Changing a Finding by Hand.
While the only open question is where one repository moves, the step waits on that mapping. Mark it Stays in Azure DevOps to keep the folder name, or give it a GitHub home and click Re-analyze.
After the Migration
Actions Advisor
Standardize the migrated workflows, cut wasted minutes, and climb the SLSA ladder.
Workflow Compliance
Hold every new workflow to your guardrails from its first run.
CargoWall
Control what your new workflows can reach on the network.
Building Blocks
Publish the shared workflows your teams build on next.
