Git and Tracker Integration
AIDLC Collaborative integrates with external systems on two independent axes:
- Code host — GitHub, GitLab, Bitbucket or AWS CodeCommit. The repository is cloned into the agent workspace and all code changes flow back as a pull request (GitHub / Bitbucket / CodeCommit) or merge request (GitLab).
- Issue trackers — GitHub Issues, GitLab Issues, and Jira Cloud. An intent can be started from any tracker issue; the issue's title, body, and comments become the intent's brief for the agent.
A space can attach one or more repositories and zero or more trackers. Repository authorization is configured explicitly per space in Space Settings.
GitHub and GitLab each span both axes: a single connection serves as the code host and backs that provider's issue tracker (GitHub Issues / GitLab Issues), so you authenticate once per provider. Bitbucket and CodeCommit are code hosts only. Jira Cloud is a tracker only.
Operator setup (one time per deployment)
Before users can connect their accounts, an administrator registers OAuth apps with each provider and pastes the credentials into the platform. See Setup → Configure provider OAuth apps for the full walkthrough. Admin pages require the Cognito platform-admin group.
The status of each provider is visible in Admin → Trackers. Until a provider shows Configured, the corresponding Connect button in Space Settings stays disabled with a hint pointing back to the admin panel.
Static egress IPs
lambda_vpc_scope defaults to "required". In this mode, only Lambdas that require access to private resources are attached to the VPC. Repository and tracker operations from source-control and trackers, along with the AgentCore runtime in its default VPC mode, already use NAT egress regardless of this setting.
Deployments that require provider IP allow-listing can set it to "public-egress" in the environment's .tfvars file. This also routes the OAuth connectors, credential broker, and seed-blocks through the NAT gateways.
Set it to "all" to place every Lambda function in the private subnets. This includes the "public-egress" functions, so all outbound Lambda traffic uses the NAT gateways. Use this only when your network policy requires it: every Lambda then depends on NAT availability, and VPC attachment can increase cold-start latency.
Development environments have one address; production environments have two, and both must be allow-listed to avoid intermittent provider failures. These addresses are printed after applying the Terraform configuration.
Space-bound authentication
GitHub OAuth and GitHub App configuration remain available at the same time. There is no platform-wide runtime mode:
- A space owner or admin selects GitHub OAuth or GitHub App for that space's GitHub repositories.
- A space may use only one GitHub authentication type, but different spaces may choose differently.
- OAuth delegation is explicit. The Owner can delegate only their own connected identity and must confirm that the space may act through it.
- For GitHub App bindings, the platform discovers and stores the installation for each repository. No global installation ID is configured.
- GitLab repositories use an explicitly delegated GitLab OAuth connection.
- CodeCommit repositories use one shared IAM role in the repository account, set by a platform admin as a single connection (no OAuth, no personal connection, nothing per user). The platform assumes it per request with a session policy narrowed to the one repository and the actions that request needs. See CodeCommit below.
Every repository is verified before any binding is written. Existing repository-backed spaces remain unbound after upgrade and cannot start until an Owner completes this step. Repository-free spaces are unaffected.
Connecting your account
Each user connects their own GitHub / GitLab / Atlassian account once. A personal connection is available for repository discovery, but a space uses it only after an Owner explicitly delegates it.
- GitHub: from the dashboard (or the space-creation flow), click Connect GitHub and approve the OAuth flow. The connection requests
repo,workflow, andread:userso the engine can also push workflow-file changes. After upgrading an older connection that lacksworkflow, click Reauthorize GitHub when prompted. The button stays disabled if your administrator hasn't configured GitHub OAuth credentials yet. - GitLab: choose GitLab as the provider in the space-creation flow, then click Connect GitLab and approve the OAuth flow. The required
apiscope covers repository writes, including.gitlab-ci.yml; GitLab has no separate workflow-file scope. The button stays disabled until your administrator has configured GitLab OAuth credentials. GitLab access tokens are short-lived; the platform refreshes them automatically using the stored refresh token, so you don't need to reconnect periodically. - Bitbucket: choose Bitbucket as the provider in the space-creation flow, then click Connect Bitbucket and approve the OAuth flow. The connection requests the
account,email,repository,repository:write,pullrequestandpullrequest:writescopes (theemailscope is used for commit attribution). The button stays disabled until your administrator has configured Bitbucket OAuth credentials. Bitbucket access tokens are short-lived (~2h); the platform refreshes them automatically from the stored refresh token, so you don't need to reconnect periodically. - AWS CodeCommit: there is nothing to connect on your account, and no role to supply. Once a platform admin has set the CodeCommit connection, choose AWS CodeCommit in the space-creation flow and pick repositories from the usual list, like any other provider. See CodeCommit.
- Jira Cloud: open Space Settings → Trackers → Connect Jira Cloud. After the Atlassian consent screen, if your account has access to multiple Atlassian sites you'll be asked to pick one. The chosen site is remembered; you can disconnect and reconnect later to change it.
A connection is scoped to its provider: connecting GitHub does not satisfy a GitLab-backed space (and vice versa). Each space uses the connection matching its selected code host.
Selecting a code repository
- Click New Space on the dashboard.
- Choose the code host — GitHub, GitLab, Bitbucket or AWS CodeCommit.
- For GitHub, choose the authentication type: GitHub App (uses the platform App's installations — no personal connection needed) or My GitHub OAuth identity (delegates your own connection). GitLab and Bitbucket always delegate your OAuth identity. On the OAuth paths the platform prompts you to connect if no active connection exists. CodeCommit needs no connection step from you: it uses the shared platform connection a platform admin configured (see below).
- Pick the repository (GitHub / Bitbucket / CodeCommit) or project (GitLab) that should back the space. On the App path the picker lists the repositories the App is installed on; on the OAuth paths it lists your own; on the CodeCommit path it lists the repositories the platform role can read (the ones an AWS admin has shared), in the connection's region — the same generic repository picker as every other provider.
- Confirm the binding (OAuth delegation requires an explicit confirmation). If verification fails, the space is created unbound — rebind it in Space Settings → Repositories before starting intents.
The repository is cloned into the agent workspace and becomes available to the agents while an intent executes. Additional repositories can be added later in Space Settings → Repositories; the space binding must then be reverified.
CodeCommit
CodeCommit has no OAuth, and nothing to connect per user. A platform admin sets one connection — a single IAM role in the AWS account that owns the repositories — and every space uses it. As a space creator you only pick repositories.
The admin side (once per deployment, in Admin → Source Control → AWS CodeCommit):
- An AWS admin creates the role in the repository account from the trust policy and permissions policy the admin card shows, and tags each repository to share with
aidlc=true. The trust policy names the three platform principals (credential broker, source-control API, CodeCommit connector) and the deployment external IDaidlc:<uuid>— one per deployment, the same for every space, created by Terraform and never by the app. The full walkthrough, including the tag and a deny that limits who may set it, is in Setup → CodeCommit. - The platform admin pastes the role ARN and region and clicks Test & save. The platform assumes the role with the deployment external ID, makes one
ListRepositoriescall to prove the trust, and stores the connection. A trust failure returns a hint and stores nothing.
The space side (space-creation flow, and again under Space Settings → Repositories to rebind): choose AWS CodeCommit and pick repositories from the generic list — no ARN, region or IAM. The list shows only repositories the role can actually read: ListRepositories is not filtered by the tag, so the platform probes each one with GetRepository under the role and hides any it cannot read (a repository is hidden only when access is denied or it is gone; a throttled or failed listing fails the request rather than showing fewer repositories). Like the GitHub App picker, only the first 1,000 repositories of the account and region, in name order, are checked; a readable repository beyond that is not listed. If the list is empty, ask your AWS admin to grant the platform role access to the repositories you need.
The external ID is deployment-wide and the app never takes it from a request, so knowing the role ARN does not let anyone outside this deployment assume the role. A binding keeps the role it was verified with: if an admin later changes the connection to a different role, existing spaces keep working on their original role until an owner re-runs Rebind and verify, which moves them to the new connection. The platform's own IAM policy also refuses to assume any role unless an aidlc:* external ID is presented. If the trust later breaks, every CodeCommit operation fails until the admin fixes it, but bindings stay active — there is nothing to rebind. When changing the connection to a new role, keep the old role and its trust until every space has run Rebind and verify: a space still on the old role keeps an active binding, so it shows no error until it fails at run time. A save of a space's source control verifies every CodeCommit repository against the current connection, so the new role must reach them. The same holds for the region: a bind or rebind accepts only repositories in the connection region (the region the list shows), even when the role allows more. A binding made before a region change keeps working in its region; a save that still lists a repository of the old region is refused and leaves that binding as it was.
Repository identity is the ARN (region and account are part of it), so CodeCommit repositories appear as name (region) and link to the regional console. Commits made by the engine carry the committer configured on the binding (CodeCommit has no user-identity API to discover one).
What CodeCommit cannot do, declared by the provider so the engine never attempts it: no draft pull requests, no reopening a closed pull request (closed is terminal — a new execution can open a replacement; final delivery retry refuses only a closed pull request that its own run created), no issues tracker, no CI check statuses (approval rules are read instead). Because PR per unit relies on draft pull requests to keep each unit review unmergeable while its lane reconciles or revises it, that strategy (and its feedback revisions) is not available for a space with CodeCommit repositories: intent creation is refused with PR_STRATEGY_UNSUPPORTED; choose one PR per intent for such a space instead. Pull request state is picked up by the same one-minute reconciler as every other provider; no webhook is needed.
Branches
All git operations are owned by the engine — agents never run git and never hold credentials:
- Each intent works on its own branch,
aidlc/<title-slug>, derived from the intent title. - The branch is created off the base branch — by default each repository's own default branch, overridable per repository at intent creation (see Creating intents → Base branch).
- During parallel construction, each unit of work gets a section-specific per-unit branch. Intent PR delivery merges it through the engine; PR-per-unit delivery opens draft unit-to-intent reviews and serializes readiness in dependency order.
- The engine commits and pushes after every stage, so work is durable even if a run is cancelled. Its commit messages are Conventional Commits (see Engine-owned git).
- On success, the pull/merge request opens from the intent branch onto the base branch.
Binding a tracker to a space
A tracker binding tells the platform which external project to list issues from when starting an intent. The same space can be bound to multiple trackers — for example, GitHub Issues for the platform's own bug tracker plus Jira Cloud for the team's product backlog.
In Space Settings → Trackers:
- GitHub Issues: click Add GitHub Issues for
<owner>/<repo>. The repository name comes from the space's code-host setting. Shown for GitHub-backed spaces. - GitLab Issues: click Add GitLab Issues for
<group>/<project>. The project path comes from the space's code-host setting. Shown for GitLab-backed spaces. - Jira Cloud: click Add Jira project, pick the Jira project, and confirm that the space may use your Jira account. All space members then use that binding to read issues and post comments, without connecting their own accounts. Automated delivery uses the same account. You can bind multiple Jira projects to the same space.
Jira bindings belong to the space. An owner or admin delegates an account to each bound Jira project; ordinary members never need a personal Jira connection. Reads and comments are limited to that project and, for Product Discovery, its directly linked issues. Comments appear in Jira under the delegating account.
The binding records the Jira site and stable project ID. Renaming a Jira project key preserves access and reconnection to the same project. Reconnecting an account to another site cannot silently redirect existing intents. Disconnecting the account or removing its owner from the space invalidates its bindings. An owner or admin can use Reconnect, select the same Jira project, and confirm delegation using their account. Use Connect another Jira account in the dialog if a different account or site is needed. Reconnection preserves the binding ID and existing intent references. A different site requires a new binding.
Bindings created before space delegation was introduced show Needs reconnection. An owner or admin must confirm delegation once through Reconnect; the platform does not infer consent from the old binding creator. Until then, browsing requires reconnection and delivery synchronization stays queued without consuming write retries. After an owner or admin reconnects, the next scheduled run resumes delivery, including comments for intents already in progress. Missing Jira write scope also pauses delivery without disabling reads. Deploy the projects, trackers, and users Lambdas together with the frontend; there is no table migration.
Personal Jira account authorization is shared across your spaces. Add Jira project refreshes expired access tokens automatically. If an administrator has changed the OAuth client ID, or your authorization has been revoked, this action starts Atlassian authorization and returns you to the same space with the project picker open. Atlassian may require consent or site selection.
Cancelling Atlassian site selection returns you to the originating space and clears the saved OAuth return path. If that path is missing or invalid, you return to the dashboard.
When using Add Jira project, connections created before the platform recorded their OAuth client ID require this authorization once per user, even if their access token has not expired. Bindings that already have explicit delegation continue using and refreshing these older connections without requiring the OAuth-client migration. The new authorization records the issuing client ID for future reuse. Rotating only the client secret keeps the existing connection and uses the new secret on the next token refresh. Existing project bindings are preserved. An authorization already in progress when the app credentials change may need to be started again.
You can also enable the matching git-issues tracker in one step at space creation by checking Enable GitHub/GitLab issue integration.
When a space has more than one tracker bound, the space page renders a tab strip above the issue list — one tab per binding, labeled with the provider and external project key.
Starting an intent from an issue
On the New Intent page, use the Import from tracker panel to browse open issues from the bound tracker(s). Selecting an issue seeds the intent:
- The issue title becomes the intent title
- The issue body and any comments are imported into the intent prompt (Jira's ADF body is converted to Markdown server-side; comments are appended in chronological order)
- A polymorphic link back to the originating tracker resource is stored so the intent can reference it
- Supported issue attachments are imported when the draft opens, with a result for each file and a retry control. See tracker attachment support and limitations.
Issues that were already linked to a read-only v1 sprint keep their Open sprint link, scoped per binding so the same numeric ID across two trackers (PROJ-1 vs OTHER-1) doesn't collide. New sprints can no longer be started from issues.
Delivery updates
When an intent imported from a tracker completes and opens final delivery pull/merge requests, the platform comments on the originating GitHub issue, GitLab issue, or Jira task with links to the intent, branches, and delivery requests. After every final delivery request has merged, it adds a merge confirmation and closes GitHub or GitLab issues. Jira receives the comments without changing the task's status.
Synchronization waits until all delivery requests have merged. Closing a delivery request without merging blocks synchronization; authorization failures and exhausted write retries are recorded in the intent's activity. Tracker write failures do not change a successfully completed intent to failed.
Jira delivery comments require write:jira-work. For connections created before v2.1.0, add that scope to the Atlassian OAuth application and reconnect Jira to grant it. The existing read:jira-work, read:jira-user, and offline_access scopes remain required.
Reconnecting a tracker
If an OAuth token or refresh token is revoked, every dependent space source-control binding is marked invalid. Reconnect the personal account, then have a Space Owner explicitly rebind the affected repositories. Removing the delegating member or uninstalling a GitHub App installation also invalidates dependent bindings.
For GitLab and Bitbucket specifically, routine token expiry does not require reconnecting: their short-lived access tokens are refreshed automatically from the stored refresh token. A reconnect is only needed if that refresh token itself is revoked.
Migrating from legacy issue integration
If your install pre-dates the tracker provider abstraction (issue #194), some spaces may still carry the old issue_integration_enabled boolean and the GitHub-specific issue_number / issue_url fields on their sprints. The platform reads both shapes side-by-side, so legacy spaces keep rendering exactly as before — but they cannot bind a Jira project (or any future provider) until they're migrated onto the new shape.
Migration is always optional and fully reversible-by-omission: nothing is deleted. The legacy fields, the dual-shape readers, the migration banner, the per-space endpoint, and the bulk Lambda all stay deployed indefinitely. There is no deprecation cycle.
Three paths exist, all idempotent and equivalent:
- Per space, in-product: open the affected space's page or settings. A "Migrate to the new tracker data model" banner appears for Owners. Click Migrate now. The banner self-dismisses on success.
- Bulk, from the Admin page: open Admin → Trackers → Tracker Migration. The card displays a count of spaces and sprints still on the legacy shape; click Migrate all to convert everything in one shot. Re-clicking is a no-op.
- Bulk, from the CLI: invoke the
migrate-tracker-fieldsLambda directly for installs that prefer shell access. Supports a{"dryRun": true}payload for previewing.
aws lambda invoke \
--function-name "$(terraform output -raw migrate_tracker_fields_lambda_name)" \
--payload '{"dryRun":true}' --cli-binary-format raw-in-base64-out /tmp/out.json
All three paths share the same shared core (lambda/shared/tracker-migration.js), so they cannot drift. After migrating, GitHub Issues and Jira Cloud bindings can be added on the affected space's settings page like any other.
Why nothing is removed: this is open source. Downstream forks are on their own upgrade timelines, and we cannot tell when (or whether) a fork has finished migrating its own data. Removing the safety nets would risk silently emptying sprint pages on installs that haven't yet caught up, so they stay forever.
Reviews
The platform supports two delivery strategies:
- Intent PR — completed unit branches are engine-merged into the intent branch. After shared stages pass, one pull request (GitHub / Bitbucket / CodeCommit) or merge request (GitLab) opens from intent to base.
- PR per unit — every changed repository gets a draft unit-to-intent PR/MR. Draft reviews may happen concurrently, but the platform promotes one dependency-ready unit at a time after reconciling it with the latest intent branch. The final intent-to-base PR/MR still opens after all units and shared stages complete.
In the intent view, each unit card shows repository-specific review state and links. Space members can open Address feedback, select up to 20 current human-authored comments, and queue a targeted revision. The backend refetches selected comments by provider ID, records their versions, and ignores provider comments unless a member explicitly selects them. The agent does not automatically resolve discussion threads.
If a unit PR closes without merging, or only part of a multi-repository unit merges, the run enters halt-and-ask with retry, skip, and abort outcomes. Already merged work is preserved.
Check and retry final delivery
Stage completion and final publication are separate outcomes. A completed intent can still need attention when its code host rejects or cannot confirm a PR/MR. The intent page shows Final delivery with each repository's branch, target, result and reason. Published PR links also remain available in Code when the graph projection was unavailable. No changes to publish is a verified no-diff outcome; missing records and failed reads are not treated as success.
A project owner or admin can choose Check delivery. This is read-only: it checks the run's recorded completion decision, the captured branches and existing PRs. Review the repository results, then choose Retry delivery. This publishes only unfinished repositories from their existing intent branches. It does not run a model, repeat stages or gates, regenerate code, integrate units again, or merge the final PR. Deliberately accepted partial work remains partial.
An uncertain previous create request is reconciled with the code host before another request is made. Successfully published repositories are preserved. An open PR from the intent branch is reconciled as the current PR. A closed or merged PR that this run created (for example after its create response was lost), a changed intent branch or a missing branch is shown with an actionable refusal; retry does not recreate closed work or choose a different target. Rewind and relaunch keep the intent branch: a PR that an earlier run opened and a reviewer closed or merged is history, and the new run publishes a new PR. Restore a missing captured branch, fix repository access, or review a separate execution/recovery plan as the displayed reason directs.
Each PR that final delivery creates ends with a delivery marker, an HTML
comment such as <!-- aidlc-delivery: aidlc-delivery-… -->. GitHub and GitLab
hide it; Bitbucket and CodeCommit may show it as a line of text. Leave it in
place: it is how a later check recognizes this run's own closed or merged PR. When a
create response was lost and a closed or merged PR on the branch has no marker
(for example because its description was edited), the repository shows
Pull request ownership unconfirmed. Delivery neither adopts that PR nor
opens a duplicate. Check the branch's PRs at the provider: reopen the PR if it
holds this run's work (the next check reconciles the open PR), or start a new
run, which publishes a new PR. On CodeCommit a closed PR cannot be reopened, so
there the only option is a new run.
This state needs a create request whose outcome is unknown: the request threw or timed out. A create that the provider or the platform refused without creating anything (unintegrated task branches, a changed intent branch, a missing base branch, no changes) leaves no request behind, so after the cause is fixed Retry delivery publishes even when the branch has older closed PRs without a marker.
CodeCommit cannot filter PRs by branch, so delivery reads open PRs only, from any author. It reads closed and merged PRs only after an unknown create outcome, and then only those opened by the platform role, the only author of PRs with a delivery marker.
PR-per-unit workflows keep their existing unit review process; this action covers their final intent-to-base publication only.
Older completed runs initially show Delivery not yet verified. Checking them does not rewrite their history. An older serial run without a pinned workflow version can be checked when all of its stages succeeded or were skipped; one with unit work stays unverified because its historical sections cannot be proven. Save delivery assessment records a reconciled or refused result when no publication is needed. Missing ownership or unfinished workflow/unit records require execution recovery first.
Only one delivery attempt owns an intent at a time. The page refreshes while it is publishing. If an attempt stops responding, its lease expires after 20 minutes; check delivery again to reconcile before retrying. Rewind, relaunch and other recovery actions wait for publication ownership to end.
Final publication recovery
DELIVERY#<orchestratorRunId> stores final intent-to-base publication separately
from META.status. Repository entries preserve captured provider, branch, target,
head SHA and remote PR identity. Current attempt metadata is mutable; prior-run
delivery rows, unit PR rows, events and human decisions are retained. Publication
success means the PR was created or reconciled, not that it was merged. Graph
projection failure does not erase the durable remote identity.
POST .../intents/{intentId}/delivery requires Space Owner membership and
entity scope. {"preview":true} resolves the original methodology/plan and
reads provider state. A run finalized under the completion policy carries a
completionValidation receipt: when it names the current run, unit plan identity
and the plan's expected sections, it is the completion decision and is not
re-assessed. Older runs without a receipt are assessed from their records,
including missing rows, once: in the preview for a retry, or immediately before
the claim for initial publication. A subsequent {"previewToken":"..."} must
match the refreshed preview. Unknown legacy runs
are never automatically migrated. Accepted omission receipts and section-scoped
legacy halt decisions are honored; unfinished work requires ordinary execution recovery or a new intent.
The process store claims publication with one transaction over META, the checked
UNITPLAN snapshot and the run's delivery row, which records that snapshot's
identity. Publication confirms the identity and fences the UNITPLAN snapshot
again in the write that records each create request; a changed plan or lost
ownership withholds the repository as non-retryable with a readable reason. It
compares the current success status, run, META timestamp and delivery revision; only an expired or absent lease can be claimed. Progress
and result writes require the same run, attempt and revision. Status/run changes
in updateExecution refuse an active delivery lease, preventing rewind or a new
run from racing publication. A provider mutation requires at least 150 seconds
of lease remaining. The 20-minute lease exceeds the orchestrator invocation's
900-second maximum plus the source-control Lambda's 120-second maximum. Preserve
that bound if either timeout changes. An uncertain launch keeps the lease since
the invocation might already be accepted; a later check recovers abandonment.
Retry invokes a separate durable retry-delivery history through the configured
orchestrator target. It only uses the shared publication logic and the existing
source-control service. It never invokes AgentCore, stages, Git integration or
models. A failed or incomplete provider lookup blocks creation. Strict lookup
lists the complete relevant PR set from the intent branch on every page, reduced to
number, state, branches, head SHA and the delivery markers its description
carries; descriptions do not leave the source-control service. Ownership is
decided over the whole list by exact identity, never by timestamps or list
order. Before create-pr, the fenced write that records the create request
stores createRequestedAt and a random deliveryMarker on the repository
entry; the PR description carries the same marker, and retries in the run reuse
it. CodeCommit additionally keeps its per-run idempotency token.
CodeCommit completes its bounded open-PR scan first. If any open PR uses the intent branch, the selection rules below decide the result without reading terminal history. Otherwise, a recorded create request requires a bounded scan of the platform session's closed PRs. A truncated scan refuses publication and reports the inspection limit; it does not suggest that fixing credentials will resolve the missing evidence.
A definitive refusal that created nothing withdraws only this attempt's newly
recorded request. GitHub's direct HTTP 422 create refusal is carried through
source-control as PR_CREATE_REJECTED; existing classified no-change and branch
refusals keep their result contract on all providers. Timeouts, lost responses,
server failures and unclassified exceptions remain unknown outcomes. A request
from an earlier uncertain attempt is always retained, even if a later attempt
is definitively refused.
| PR on the intent branch (any target unless stated) | No create request recorded | Create request recorded |
|---|---|---|
| Open, onto the captured target | Reused as the current PR | Reused as the current PR |
| Open, onto another target only | Refused (no retarget) | Refused (no retarget) |
| Closed or merged, this entry's marker, captured target | Not applicable | This run's: refused |
| Closed or merged, this entry's marker, other target | Not applicable | This run's, retargeted: refused |
| Closed or merged, this marker on two or more PRs | Not applicable | Uncertain |
| Closed or merged, another run's marker | Ignored | Ignored |
| Closed or merged, no marker | Ignored | Uncertain |
| None of the above | Published | Published |
Rows apply top to bottom. The target branch never decides ownership: a reviewer
can retarget this run's PR and it keeps its marker, so a retargeted, closed or
merged PR of this run is refused rather than published again. Only PRs from this
repository count; a fork's branch with the same name is not a candidate. A
GitLab merge request that is locked while it merges counts as open. An
uncertain entry is not retryable and never blocks a new run: a new run has no
recorded request. Entries written before markers existed (createRequestedAt
without deliveryMarker) can prove no closed PR, so an unmarked one is
uncertain. The delivery view links only a published or reconciled PR, or one
proven by this run's marker. A changed source SHA, missing branch, retargeted PR
or this run's closed work requires review instead of implicit replacement.
Deploy source-control first (strict lookup, branch preconditions and refusal
classification), then the
orchestrator and intents API with the delivery route, then the frontend. Install
all parts from the same release before offering retry. New orchestrator histories
capture deliveryPolicyVersion: 1 in the existing load-meta step. Frozen
pre-change results retain the previous open-pr sequence, including #534's
completion marker. Changing an alias does not upgrade their durable checkpoints.
The new API can assess a completed old history without changing its execution
pins; publication retry creates its own history on the configured fixed target.
An older source-control service does not preserve the new refusal code, so the
publisher conservatively retains the request as unknown. Updating the service
does not retroactively clear an existing uncertain request.
This release requires no status migration, production recovery or model E2E as
part of deployment. The existing tracker handoff is scheduled after complete
publication, including a successful retry; while only some repositories are
published, the intent's activity records a v2.tracker.blocked note naming how
many are published, and the tracker receives nothing until the rest are. Graph
projection retains its owner. Publication recovery
exposes durable PR links directly. Existing historical tracker rows are not
rewritten.