AI Collaboration Capstone: GitHub, Confluence, and Jira

Table of Contents
Return to the AI Collaboration Course
Deliver PROP-042 twice, through GitHub-first and through GitHub with Confluence/Jira. You contribute, separate owners review, and authorized publishers apply the change. Use isolated synthetic sandboxes after preceding lessons. The capstone tests the complete procedure, including rejection, recovery, and independent handoff, rather than assistant prose quality.
Key Takeaways
- One shared change compares both authority models.
- Negative tests matter as much as successful delivery.
- Evidence packages support independent review.
- Lab completion does not authorize production rollout.
Before You Begin
Prerequisites: preceding course modules , approved sandbox access, and separate reviewers. Planning allowance: eight to twelve hours across multiple sessions, plus independent review. Actual time depends on account setup and repair work. Difficulty: advanced.
Required artifacts: charter, map, policy, adapters, baseline, manifest, fixed proposal, owner reviews, ledger, recovery record, and handoff. Missing plan-dependent permissions block completion instead of becoming assumed passes.
Prepare one evidence directory per track before testing. A reviewer should identify the actor, source revisions, attempted action, observed result, and final state without relying on a chat summary.
Establish Two Baselines
- Create isolated runs named GitHub-first and Mixed. Keep revisions and reviews separate.
- Restore seven-day baseline through each track’s approved procedure and capture resulting revisions.
- Verify denial controls with contributor and excluded-user accounts.
- Capture current context and confirm adapter/policy agreement.
- Declare the scope: thirty-day synthetic export retention, excluding real data, backups, and legal holds.
PROP-042 is a correlation label, not reusable approval. Each run needs its own frozen revision and source evidence. Include run IDs in reports.
Deliver GitHub-First
Open the Issue and candidate PR using the GitHub lessons. Change requirement, configuration, proposal, and runbook together. Capture the protected base, run trusted checks, and obtain product and operations reviews at the final commit.
Run: GitHub-first
Change: synthetic retention 7 -> 30 days
Requirement: REQ-17 revision 2
Configuration: retention_days 30
Runbook: Retention days: 30
Proposal: base revision 1, from 7, to 30
Manifest: protected pre-change source hashes
Review: product and operations at final proposal revision
Publication: merged commit and read-back
Limit: no running deletion service exercised
Fill actual references from the sandbox. The outline is expected mapping, not completed evidence. The maintainer merges only after review, then independently reads main. Close the Issue after linking the final records.
Deliver the Mixed Track
Read Confluence versions and freeze the Jira proposal. Obtain both owner reviews. Publish the requirement with delivery pending, merge configuration, publish the runbook, and read all systems back before Done.
Record each publication with page version, commit, or transition evidence. Repository requirement copies remain snapshots. The local checker does not establish current Confluence authority.
| Comparison | GitHub-first | Mixed workplace |
|---|---|---|
| Requirement | Protected repository review | Confluence owner-reviewed publication |
| Coordination | Issue/PR | Jira fixed proposal |
| Publication unit | Repository merge | Separate page writes and merge |
| Freshness | Protected commit | Page versions plus commit |
| Recovery | Reviewed revert/compensation | Ledger-guided compensation |
Choose a workflow by ownership needs. GitHub-first reduces cross-system coordination. The mixed track preserves workplace homes and adds publication/access checks.
Run the Failure Matrix
| Case | Injection | Required observed evidence |
|---|---|---|
| Approved change | Submit reviewed thirty-day proposal | Consistent read-back and review |
| Stale context | Change source after capture | Rejection, reconciliation, reapproval |
| Unauthorized write | Contributor publishes | Denial and unchanged revision |
| Conflict | Jira says sixty, Confluence seven | Block and owner reconciliation |
| Partial publication | Interrupt after one write | Pending ledger and recovery |
| Access denial | Remove task read access | No protected text or publication |
| Recovery | Approved completion/backout | New reviewed revisions |
| Handoff | New session gets map/ledger only | Fresh read and correct next action |
Cross-system conflict belongs to Mixed. In GitHub-first, test an Issue description conflicting with the approved file. Run other applicable cases in both tracks. A local validator failure does not replace live permission evidence.
| Case and evidence file | GitHub-first run | Mixed run |
|---|---|---|
Approved change 01-approved-change.md | Reviewed PR and read-back | Reviewed pages, merge, and ledger |
Stale context 02-stale-context.md | Change protected base after capture | Change an authority page after capture |
Unauthorized write 03-unauthorized-write.md | Contributor direct-push denial | Contributor page edit and transition denial |
Conflict 04-conflict.md | Issue disagrees with approved file | Jira text disagrees with Confluence |
Partial publication 05-partial-publication.md | Stop before merge or read-back | Stop after one page write |
Access denial 06-access-denial.md | Withhold a protected repository source | Exclude a user from a restricted page |
Recovery 07-recovery.md | Reviewed revert or completion | Ledger-guided compensation |
Handoff 08-handoff.md | New session reads protected files | New session reads mapped pages and ledger |
Create each file before its test. Record expected result, observed result, actor role, initial and final revisions, native evidence reference, and reviewer decision. A browser route prompt is not direct-push denial. Keep the two track directories separate.
Keep expected and observed outcomes separate. For each case record run ID, actor role, initial revisions, attempted action, expectation, observation, resulting revisions, and reviewer decision. Redact credentials and account identifiers from shared reports.
Assess Completion
Pass requires observed evidence for every applicable row and independent acceptance. Reviewers inspect permissions, source freshness, role review, partial publication, and handoff reconstruction as well as consistency logs.
Fail immediately on unauthorized publication, denied text reaching the model, or silent overwrite of a changed base. Keep work Blocked until corrected controls pass a repeat test. Do not average these failures into a favorable score.
Measure completed/blocked cases, rejected stale proposals, denied writes, recoveries, and reviewer time. Proposed outcomes remain expected until observed. The supplied ten unit tests cover consistency, not live tenant security.
Plan the Two Runs
Do not reuse an approval across tracks. The requested value is the same, but the source homes, captured revisions, permissions, and publishing sequence differ. Give each run its own evidence directory and review packet.
capstone-evidence/
github-first/
charter-and-map
captured-sources
fixed-proposal
role-reviews
consistency-results
permission-results
publication-readback
recovery-and-handoff
mixed/
same evidence categories, independently captured
These names are an organization example, not supplied archive files. Store actual evidence privately in the approved sandbox. Shared course submissions should use role labels and redacted references, while reviewers retain access to native records.
Assign a test observer before running failures. The contributor performs the attempted action. The observer records initial state, outcome, and resulting state. A reviewer later determines whether the evidence supports the claim. Disclose role overlap instead of implying independent acceptance.
Run Failures in Isolation
Reset to a verified reviewed state between cases. Injecting source drift, access revocation, and a runbook mismatch together obscures which control rejected the proposal. One failure per run gives the reviewer a traceable reason for the result.
- Capture the initial state: source revisions, configuration, delivery state, and actor role.
- Apply one synthetic injection: change one relevant condition through an authorized test route.
- Attempt the bounded action: validation, read, publication, or handoff.
- Record the observation: actual output and resulting source state.
- Repair through review: preserve failure evidence before restoring controls.
- Repeat the positive case: confirm the corrected workflow still delivers permitted work.
A planned failure is still a failure observation. Do not relabel unauthorized publication as a successful test merely because you intended to probe it. The test succeeded at exposing a defect, but the publication boundary failed and requires repair.
Injection and reset card for each case: use a new synthetic proposal or restore a reviewed baseline before the next row. The observer records the precondition and confirms the reset. Never erase the failed attempt from the ledger.
| Case | GitHub-first injection and check | Mixed-workplace injection and check | Reset before next case |
|---|---|---|---|
| Approved change | Submit the fixed PR, obtain both reviews, merge, and reopen main | Publish REQ-17, merge the reviewed diff, publish RUN-04, then reopen all records | Capture final revisions as the next base |
| Stale context | Capture a manifest, then change the protected test base through a separate reviewed PR before validating the old proposal | Capture page versions, then have an authorized editor revise a test page before the prewrite read | Stop, compare versions, capture fresh sources, and review a new fixed package |
| Unauthorized write | Contributor attempts a harmless direct push to protected main and records the server denial | Contributor attempts a REQ-17 edit and Approved transition | Reopen the protected commit, page version, and Jira state, which should be unchanged |
| Conflict | Put sixty days in the draft Issue while the approved file says seven | Put sixty days in the Jira draft while REQ-17 says seven | Product owner reconciles the draft and records the decision before review |
| Partial publication | Stop after approval but before merge or final read-back, leaving the Issue open | Stop after REQ-17 read-back while configuration and RUN-04 still say seven | Keep delivery pending, then obtain an owner-reviewed completion or compensation decision |
| Access denial | Use a test identity excluded from a separate private test repository containing a synthetic source and attempt a read | Use the excluded identity on a separately restricted synthetic page | Restore only approved test access and verify the normal reader still succeeds |
| Recovery | Interrupt an approved test change, then propose a reviewed completion or revert | Use the partial-publication ledger to propose reviewed completion or compensation | Read back each resulting source and reconcile the ledger |
| Handoff | Send MAP-01 and the ledger to a fresh reviewer without the old chat | Send mapped page IDs and ledger to a fresh reviewer without the old chat | Reviewer opens current sources and records the next authorized step |
For every denied case, record the platform response and a second read of the protected record. For the excluded-user case, inspect provider-supported tool traces, retrieval logs, or audit records to check whether protected text reached the task. If such evidence is unavailable, mark this access-safety check Blocked instead of treating a visible denial as proof that no cached excerpt was returned. If a control is unavailable in the plan or an approved test identity is missing, record Blocked rather than simulating a pass.
Interpret a Mixed Result
Illustrative evidence package: local consistency passes, product and operations review the fixed package, requirement publication succeeds, and runbook edit access is denied. Configuration has not yet merged. Jira remains Blocked.
| Claim | Verdict | Reason |
|---|---|---|
| Candidate records agree | Supported by local check | Supplied records passed comparisons |
| Owners accepted intent and operations | Requires native fixed reviews | Role labels alone are insufficient |
| Thirty-day delivery completed | Unsupported | Required publication steps remain pending |
| Permission boundary works for every role | Unsupported | One denied action has limited scope |
| Recovery owner should act | Supported as next step | Partial delivery needs a reviewed decision |
Expected reasoning: keep the run incomplete, verify current sources, and request the appropriate owner decision. Do not finish by weakening permissions or describing the snapshot check as live publication evidence.
Filled mixed-track teaching packet, synthetic and not tenant evidence:
Run: MIXED-042-example
Captured base: REQ-17 v4 = 7 days, RUN-04 v2 = 7 days,
GitHub main base-001 config.json = {"retention_days": 7}, Jira PROP-042 r1 = In Review
Fixed proposal: REQ-17 v5 wording says synthetic exports 30 days,
excluding production data, backups, and legal holds.
GitHub config.json changes retention_days from 7 to 30.
RUN-04 v3 wording says 30 days, no deletion service runs in this lab,
and incomplete publication stays pending.
Review: product owner approved the exact requirement wording at PROP-042 r1.
Operations owner approved the exact config diff and runbook wording at r1.
Publication: publisher reopened REQ-17 v5 and read 30 days.
Maintainer reopened main at merge-002 and read retention_days 30.
Publisher reopened RUN-04 v3 and read 30 days.
Denied action: contributor tried an edit to restricted REQ-17 from v5.
Platform denied the edit, the publisher reread v5 unchanged, and the
observer saved the native denial. No edit was applied and v5 stayed unchanged.
Recovery: after a separate simulated failed RUN-04 attempt, Jira stayed
Blocked. Operations approved a retry against the current version.
Publisher reread v3 after the authorized retry before Jira moved to Done.
Handoff: a new reviewer received MAP-01 and the ledger, reopened the three
sources and Jira, and named the current 30-day state and remaining runtime gap.
Limit: source publication is shown. Actual deletion timing is Not run.
Replace every illustrative version, actor, denial, and read-back with native records before marking a live row Supported. If a plan or role does not permit the test, mark the row Blocked and keep the two-track course incomplete.
Review With an Independent Reader
Ask the reviewer to reconstruct events, not merely read your conclusion. They should locate the approved baseline, fixed proposal, owner decisions, resulting revisions, failed attempts, repair, and remaining gaps without your narration.
Reviewer questions:
Which source governs retention intent in this track?
Which exact package did each owner review?
Did any source change after review?
What was published, and what remains pending?
Which denied action was observed under which role?
Did protected text reach an excluded user's context?
Which repair was reviewed and read back?
Does the fresh handoff reconstruct current state independently?
Score each requirement separately. Use Supported, Failed, Blocked, or Not run with an evidence reference. Consistency, approval, permissions, recovery, and handoff are separate requirements. A collection of green local tests does not offset a failed live publication boundary.
Run ID and track:
Reviewer role and review date:
Case 01 approved change: status ___ evidence ___ gap ___
Case 02 stale context: status ___ evidence ___ gap ___
Case 03 unauthorized write: status ___ evidence ___ gap ___
Case 04 conflict: status ___ evidence ___ gap ___
Case 05 partial publication: status ___ evidence ___ gap ___
Case 06 access denial: status ___ evidence ___ gap ___
Case 07 recovery: status ___ evidence ___ gap ___
Case 08 handoff: status ___ evidence ___ gap ___
Overall decision: Supported / Failed / Blocked / Not run
Next accountable role and action:
Supported means the reviewer located observed evidence for every applicable case. Record Failed for an observed control failure, Blocked for missing access or a missing control, and Not run for an unattempted case. Keep each case’s native reference in its named evidence file.
Course pass gate: complete both the GitHub-first and mixed tracks. In each track, all eight applicable cases above need Supported evidence. A Failed boundary or a missing native read-back blocks the track. A missing paid plan or test identity produces Blocked, not a guessed pass. One completed track earns a documented partial result, not course completion.
Redacted model package, illustrative only:
Track: github-first | Run: G-01 | Reviewer: separate pilot role
Base: protected commit base-001 | Fixed proposal: PROP-042 r1
Approvals: product review ref P-01, operations review ref O-01
Consistency: local check pass, saved output ref C-01
Permission: contributor direct push denied, native event ref D-01
Publication: merged commit merge-002, fresh clone confirms thirty
Exception: backups and legal holds remain excluded
Recovery: interruption case R-01 read back and resolved through review
Handoff: second reader found current base, exception, and next action
Runtime limit: no production deletion or deployment claim
Decision: Supported for synthetic GitHub-first track only
Replace every illustrative reference with an observed sandbox artifact. Repeat the full package for the mixed track with its own source versions and reviews. The reviewer should reject a copied GitHub approval in the mixed package.
Write a Bounded Decision
A useful closing decision names the next pilot, not an unrestricted rollout. For example, choose another synthetic export setting with the same roles and direct lookup route, while leaving real data and automated publication out of scope.
| Decision element | Required detail |
|---|---|
| Scope | One next change and its explicit exclusions |
| Evidence | Supported cases and unresolved failures |
| Controls | Platform-enforced and procedural requirements separately |
| Owners | Accountable role for each remaining gap |
| Runtime gap | Untested deletion/deployment behavior |
| Stop conditions | Missing access, changed authority, unauthorized publication |
Completion check: both run packages survive independent reconstruction, applicable failure cases have observed evidence, and unresolved controls remain visible. If only the GitHub track is complete, report partial course completion rather than assuming the mixed track would behave the same way.
Troubleshooting and Backout
Only happy-path evidence: rerun denial and interruption tests. Overlapping roles: disclose and repeat with separate users. Missing plan controls: stop and obtain an approved sandbox.
Backout: restore baseline through reviewed PRs and Confluence edits, revoke temporary integrations, archive Jira evidence, and perform owner-approved synthetic cleanup after evidence retention. Preserve recovery history.
Create the Rollout Decision
Decision: another synthetic pilot, blocked, or rejected
Evidence: both run packages and failure matrix
Unenforced requirements: procedural controls listed explicitly
Provider review: input scope and retention handling
Owner coverage: product, operations, policy, repository, delivery
Production gaps: runtime tests, secrets, deployment, access review
Next action: one bounded follow-up with accountable role
Review date: assigned by pilot owners
Expected reasoning: synthetic success supports another bounded pilot. Production requires separate approval for real data, deployment, provider handling, and runtime behavior. A successful assistant answer is not deployment authorization.
Primary References
- Repository controls: Protected branches .
- Workplace access: Confluence permissions .
- Delivery controls: Jira permission schemes .
Next Steps
Return to the course hub to review missing controls. Compare your implementation with the framework article before selecting another pilot.


