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

  1. Create isolated runs named GitHub-first and Mixed. Keep revisions and reviews separate.
  2. Restore seven-day baseline through each track’s approved procedure and capture resulting revisions.
  3. Verify denial controls with contributor and excluded-user accounts.
  4. Capture current context and confirm adapter/policy agreement.
  5. 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.

ComparisonGitHub-firstMixed workplace
RequirementProtected repository reviewConfluence owner-reviewed publication
CoordinationIssue/PRJira fixed proposal
Publication unitRepository mergeSeparate page writes and merge
FreshnessProtected commitPage versions plus commit
RecoveryReviewed revert/compensationLedger-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

CaseInjectionRequired observed evidence
Approved changeSubmit reviewed thirty-day proposalConsistent read-back and review
Stale contextChange source after captureRejection, reconciliation, reapproval
Unauthorized writeContributor publishesDenial and unchanged revision
ConflictJira says sixty, Confluence sevenBlock and owner reconciliation
Partial publicationInterrupt after one writePending ledger and recovery
Access denialRemove task read accessNo protected text or publication
RecoveryApproved completion/backoutNew reviewed revisions
HandoffNew session gets map/ledger onlyFresh 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 fileGitHub-first runMixed run
Approved change 01-approved-change.mdReviewed PR and read-backReviewed pages, merge, and ledger
Stale context 02-stale-context.mdChange protected base after captureChange an authority page after capture
Unauthorized write 03-unauthorized-write.mdContributor direct-push denialContributor page edit and transition denial
Conflict 04-conflict.mdIssue disagrees with approved fileJira text disagrees with Confluence
Partial publication 05-partial-publication.mdStop before merge or read-backStop after one page write
Access denial 06-access-denial.mdWithhold a protected repository sourceExclude a user from a restricted page
Recovery 07-recovery.mdReviewed revert or completionLedger-guided compensation
Handoff 08-handoff.mdNew session reads protected filesNew 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.

  1. Capture the initial state: source revisions, configuration, delivery state, and actor role.
  2. Apply one synthetic injection: change one relevant condition through an authorized test route.
  3. Attempt the bounded action: validation, read, publication, or handoff.
  4. Record the observation: actual output and resulting source state.
  5. Repair through review: preserve failure evidence before restoring controls.
  6. 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.

CaseGitHub-first injection and checkMixed-workplace injection and checkReset before next case
Approved changeSubmit the fixed PR, obtain both reviews, merge, and reopen mainPublish REQ-17, merge the reviewed diff, publish RUN-04, then reopen all recordsCapture final revisions as the next base
Stale contextCapture a manifest, then change the protected test base through a separate reviewed PR before validating the old proposalCapture page versions, then have an authorized editor revise a test page before the prewrite readStop, compare versions, capture fresh sources, and review a new fixed package
Unauthorized writeContributor attempts a harmless direct push to protected main and records the server denialContributor attempts a REQ-17 edit and Approved transitionReopen the protected commit, page version, and Jira state, which should be unchanged
ConflictPut sixty days in the draft Issue while the approved file says sevenPut sixty days in the Jira draft while REQ-17 says sevenProduct owner reconciles the draft and records the decision before review
Partial publicationStop after approval but before merge or final read-back, leaving the Issue openStop after REQ-17 read-back while configuration and RUN-04 still say sevenKeep delivery pending, then obtain an owner-reviewed completion or compensation decision
Access denialUse a test identity excluded from a separate private test repository containing a synthetic source and attempt a readUse the excluded identity on a separately restricted synthetic pageRestore only approved test access and verify the normal reader still succeeds
RecoveryInterrupt an approved test change, then propose a reviewed completion or revertUse the partial-publication ledger to propose reviewed completion or compensationRead back each resulting source and reconcile the ledger
HandoffSend MAP-01 and the ledger to a fresh reviewer without the old chatSend mapped page IDs and ledger to a fresh reviewer without the old chatReviewer 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.

ClaimVerdictReason
Candidate records agreeSupported by local checkSupplied records passed comparisons
Owners accepted intent and operationsRequires native fixed reviewsRole labels alone are insufficient
Thirty-day delivery completedUnsupportedRequired publication steps remain pending
Permission boundary works for every roleUnsupportedOne denied action has limited scope
Recovery owner should actSupported as next stepPartial 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 elementRequired detail
ScopeOne next change and its explicit exclusions
EvidenceSupported cases and unresolved failures
ControlsPlatform-enforced and procedural requirements separately
OwnersAccountable role for each remaining gap
Runtime gapUntested deletion/deployment behavior
Stop conditionsMissing 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

Next Steps

Return to the course hub to review missing controls. Compare your implementation with the framework article before selecting another pilot.