U04 is a guided Preview 0.32 lesson. It prepares two separate child repositories beneath the Academy
attempt root. The Academy root controls the attempt and stores the final binding report; it is not a
codeArbiter project for this lesson.
1
YouActive harness
confirm project boundary
Confirm that this is the Academy attempt root. U04 creates two child repositories under .academy/workspaces/; do not initialize codeArbiter in the Academy root.
Why this matters: It distinguishes the controller repository from the two child repositories before any tool writes state.
Expected result
You know the Academy root controls the attempt and the two child paths are .academy/workspaces/U04-greenfield and .academy/workspaces/U04-brownfield. Next safe step: prepare attempt.
Evidence
Preserve the Academy-root path and the two child paths; no child repository exists yet.
If that does not happen
If you have already initialized codeArbiter in the Academy root, preserve the status and stop; do not delete or rewrite a repository to hide the mistake.
U04 keeps the Academy root as the attempt controller and final-report repository. Do not initialize a
child project in the Academy root. Host-native commands act on
the folder visible in that host. A terminal cd does not switch it, and neither native-terminal nor
codeArbiter commands use !.
Greenfield will use ca-init, then ca-decompose, which generates the three exact reconciliation
inputs under .codearbiter/plans/. After learner review, greenfield alone will use ca-reconcile,
then ca-adr drafts the learner-attributed decision for the learner to review and explicitly
accept. Reconciliation does not author ADRs or advance their status.
Brownfield will use ca-init, then ca-create-context; the accepted walkthrough must use
ca-create-context on the brownfield and must not use ca-decompose on the brownfield. The real
brownfield route does not create the three ca-reconcile plan inputs, so this lesson does not
invent them or run brownfield reconciliation.
Each child follows the same repository boundary: inspect generated changes, explicitly stage
only those changes, review the cached diff, run host-native ca-commit while visibly rooted at that
child, and prove clean status. An unresolved [CONFIRM-NN] stops the attempt.
Prepare creates the greenfield and brownfield child repositories and switches the Academy repository
to the dedicated attempt branch. Do not make either child yourself.
2
You
prepare attempt
From the clean Academy root, run installed Academy Prepare. Native commands never begin with !.
Why this matters: Prepare is the only supported way to create the bounded attempt and its two clean child repositories.
Prepare switches to academy/U04-initialize-projects/<attempt> and creates clean .academy/workspaces/U04-greenfield and .academy/workspaces/U04-brownfield child repositories. Next safe step: inspect root.
Evidence
Preserve Prepare output, the attempt branch, and empty status from both prepared child repositories.
If that does not happen
If Prepare reports an occupied child target or another setup error, preserve its output and correct that named boundary; do not create, delete, or initialize a child path by hand.
3
You
inspect root
Inspect the two prepared child repositories. Do not initialize the Academy root.
Why this matters: It proves the prepared paths are separate children rather than accidental work in the Academy root.
ls -la .academy/workspaces/U04-greenfield .academy/workspaces/U04-brownfield
Linux
ls -la .academy/workspaces/U04-greenfield .academy/workspaces/U04-brownfield
Expected result
The listing shows separate U04-greenfield and U04-brownfield directories under .academy/workspaces; neither is the Academy root. Next safe step: inspect greenfield.
Evidence
Preserve the two-path listing and the empty prepared-child statuses so the later report remains bound to the intended repositories.
If that does not happen
If either child is missing, duplicated, or outside .academy/workspaces, stop and preserve the listing plus all three repository statuses; do not initialize a substitute directory by hand.
Complete and commit greenfield before opening brownfield:
4
YouActive harness
inspect greenfield
Use Open Folder or the workspace switcher to visibly root the host at .academy/workspaces/U04-greenfield. A terminal cd does not change the host root.
Why this matters: The visible host root prevents a greenfield command from being sent to the parent or the brownfield child.
Expected result
The host visibly names .academy/workspaces/U04-greenfield as its project root; merely changing a terminal directory is not sufficient. Next safe step: run greenfield init.
Evidence
Preserve the host's visible root label or breadcrumb naming U04-greenfield; Check can verify repository bytes later, but cannot prove which folder the host displayed.
If that does not happen
If the host still shows the Academy root or U04-brownfield, do not invoke codeArbiter; reopen U04-greenfield with Open Folder or the workspace switcher first.
5
Your host
run greenfield init
Only while visibly rooted at .academy/workspaces/U04-greenfield, run ca-init; a terminal cd does not change the host root.
Why this matters: Initialization belongs in the greenfield child so its governance state starts from the real plugin entry point.
Any OS · Claude Code
/ca:init
Any OS · Codex
$ca-init
Any OS · Pi
/ca-init
Any OS · Pi
/skill:ca-init
Expected result
ca-init scaffolds an uncommitted .codearbiter directory inside U04-greenfield only; the Academy root and brownfield remain untouched. Next safe step: run greenfield decompose.
Evidence
Preserve ca-init output and U04-greenfield git status showing the new .codearbiter paths before decomposition.
If that does not happen
If ca-init ran against another visible root, stop and preserve its output and every affected git status; do not commit or conceal the misplaced initialization.
6
Your host
run greenfield decompose
Only while visibly rooted at .academy/workspaces/U04-greenfield, run ca-decompose; a terminal cd does not change the host root.
Why this matters: Decomposition creates the greenfield planning artifacts that reconciliation will evaluate.
Any OS · Claude Code
/ca:decompose
Any OS · Codex
$ca-decompose
Any OS · Pi
/ca-decompose
Any OS · Pi
/skill:ca-decompose
Expected result
U04-greenfield now contains .codearbiter/plans/01-architecture-breakdown.md, .codearbiter/plans/02-phased-build-plan.md, and .codearbiter/plans/03-task-backlog.md. Next safe step: read greenfield plans.
Evidence
Preserve the ca-decompose transcript and all three generated plan files; Check later reads these exact committed paths.
If that does not happen
If ca-decompose stops for input or any named plan is missing, preserve the transcript and partial files; continue the decompose interview in U04-greenfield instead of inventing a plan or switching repositories.
7
You
read greenfield plans
Read .academy/workspaces/U04-greenfield/.codearbiter/plans/01-architecture-breakdown.md, .academy/workspaces/U04-greenfield/.codearbiter/plans/02-phased-build-plan.md, and .academy/workspaces/U04-greenfield/.codearbiter/plans/03-task-backlog.md.
Why this matters: Reading all three plans makes the later reconciliation a deliberate decision rather than an opaque command.
All three plan files are readable and distinguish architecture, phased delivery, and task backlog decisions that must be settled before reconciliation. Next safe step: choose greenfield reconciliation.
Evidence
Preserve the three plan contents and a short list of every [CONFIRM-NN] or design choice that needs a learner decision.
If that does not happen
If a file cannot be read or contains incomplete generated content, stop and return to ca-decompose in the visibly rooted greenfield host; do not repair generated structure from the Academy root.
8
YouActive harness
choose greenfield reconciliation
Review the three greenfield plan inputs, resolve decisions or stop on [CONFIRM-NN], then use Open Folder or the workspace switcher to visibly return to .academy/workspaces/U04-greenfield. A terminal cd does not change the host root.
Why this matters: Reconciliation must use learner-resolved decisions and stop on unresolved confirmation markers.
Expected result
Each plan decision has an explicit learner answer, no unresolved [CONFIRM-NN] remains, and the host is visibly rooted at U04-greenfield. Next safe step: run greenfield reconcile.
Evidence
Preserve the learner-attributed decisions and the resolved three plan files; this is judgment evidence that Check cannot infer from command invocation alone.
If that does not happen
If any decision is unclear or [CONFIRM-NN] remains, stop before ca-reconcile; preserve the question and answer it explicitly in the greenfield conversation.
9
Your host
run greenfield reconcile
Only after the three plans and learner decisions exist, while visibly rooted at .academy/workspaces/U04-greenfield, run ca-reconcile; a terminal cd does not change the host root.
Why this matters: Running reconcile only after its inputs exist keeps the plan-to-decision flow truthful.
Any OS · Claude Code
/ca:reconcile
Any OS · Codex
$ca-reconcile
Any OS · Pi
/ca-reconcile
Any OS · Pi
/skill:ca-reconcile
Expected result
ca-reconcile records the reviewed greenfield governance with no unresolved [CONFIRM-NN]. Next safe step: record greenfield ADR.
Evidence
Preserve ca-reconcile output and the final plan and governance files that will be reviewed in the unstaged diff.
If that does not happen
If reconciliation reports an unresolved variance or confirmation, preserve the transcript and stop; return to the named greenfield decision instead of staging partial governance.
10
Your host
record the proposed greenfield ADR
While visibly rooted at .academy/workspaces/U04-greenfield, state the exact learner-selected greenfield decision and explicit learner attribution, then invoke ca-adr. The host assigns the number and writes the proposed ADR; do not ask ca-reconcile to author it.
Why this matters: ca-adr, not ca-reconcile, owns an accepted Architecture Decision Record and requires explicit learner attribution.
Any OS · Claude Code
/ca:adr Use local storage for U04 greenfield state
Any OS · Codex
$ca-adr Use local storage for U04 greenfield state
Any OS · Pi
/ca-adr Use local storage for U04 greenfield state
Any OS · Pi
/skill:ca-adr Use local storage for U04 greenfield state
Expected result
ca-adr writes the next numbered proposed greenfield ADR under .codearbiter/decisions/ with the learner-attributed decision. Next safe step: accept greenfield ADR.
Evidence
Preserve the proposed ADR path and learner-attributed decision with the reconciled plan and governance files.
If that does not happen
If the decision or attribution is not exact, stop before accepting the ADR. Correct the learner decision in the greenfield conversation; do not ask ca-reconcile to create or revise the ADR.
11
YouActive harness
explicitly accept the greenfield ADR
Review the proposed greenfield ADR in the active ca-adr conversation. Only after confirming its decision and attribution, explicitly accept that ADR; the host must not advance its status on its own.
Why this matters: ADR status transitions are an explicit learner decision, not an automatic result of reconciliation or drafting.
Expected result
The reviewed learner-attributed ADR is accepted under .codearbiter/decisions/. Next safe step: inspect greenfield changes.
Evidence
The accepted ADR path, status, decision, and explicit learner attribution.
If that does not happen
If the ADR title, decision, or attribution is wrong, leave it proposed and correct it with the learner before accepting. Do not silently edit or auto-advance its status.
12
You
inspect greenfield changes
Inspect greenfield status and unstaged governance diff before staging.
Why this matters: An unstaged inspection lets the learner see exactly what the greenfield plugin flow produced.
Greenfield status and the unstaged diff show only the intended .codearbiter governance and generated .gitignore change; nothing is staged yet. Next safe step: stage greenfield changes.
Evidence
Preserve the pre-stage status and full .codearbiter/.gitignore diff as the review record for the greenfield commit boundary.
If that does not happen
If status names unrelated or unexpected paths, preserve the full status and diff and stop; identify their owner before altering, staging, or discarding them.
13
You
stage greenfield changes
After review, stage only greenfield generated governance changes.
Why this matters: Selective staging keeps generated greenfield governance files separate from unrelated parent or child work.
Only reviewed U04-greenfield .codearbiter and .gitignore changes are staged, and diff --cached --name-only prints those exact paths. Next safe step: review greenfield commit boundary.
Evidence
Preserve the cached name list proving the greenfield index contains only generated governance and its .gitignore boundary.
If that does not happen
If an unexpected path is staged, preserve the cached name list, unstage only that path, and return to the unstaged review; do not run ca-commit with a mixed boundary.
14
You
review greenfield commit boundary
Review the full cached diff, then use Open Folder or the workspace switcher to keep the host visibly rooted at .academy/workspaces/U04-greenfield.
Why this matters: Cached-diff review proves the exact greenfield commit boundary before the commit gate runs.
diff --cached --check reports no whitespace errors, and the full cached diff is the exact greenfield governance the learner intends to commit. Next safe step: run greenfield commit gate.
Evidence
Preserve the clean cached-check output and reviewed cached diff; together they define the exact bytes offered to the greenfield commit gate.
If that does not happen
If the cached check reports an error or the diff contains an unapproved change, preserve the output and stop; correct and restage the greenfield file before requesting ca-commit.
15
Your host
run greenfield commit gate
Only after learner review while visibly rooted at .academy/workspaces/U04-greenfield, run ca-commit; a terminal cd does not change the host root.
Why this matters: The child-local commit gate records the reviewed greenfield governance change in its own history.
Any OS · Claude Code
/ca:commit
Any OS · Codex
$ca-commit
Any OS · Pi
/ca-commit
Any OS · Pi
/skill:ca-commit
Expected result
ca-commit creates a new child commit in U04-greenfield containing the reviewed staged governance and does not commit either the parent or brownfield. Next safe step: confirm greenfield clean.
Evidence
Preserve the successful ca-commit transcript and resulting greenfield commit hash; the later binding must use this committed HEAD.
If that does not happen
If the gate stops or requests remediation, preserve its findings and the staged diff; remediate in U04-greenfield and rerun ca-commit instead of bypassing the gate or using raw git commit.
16
You
confirm greenfield clean
After greenfield ca-commit succeeds, confirm its status is empty.
Why this matters: A clean greenfield status is required before its committed facts can bind the parent report.
Windows
git -C .academy\workspaces\U04-greenfield status --short
macOS
git -C .academy/workspaces/U04-greenfield status --short
Linux
git -C .academy/workspaces/U04-greenfield status --short
Expected result
git status --short prints nothing, so the U04-greenfield working tree is clean after its new child commit. Next safe step: inspect brownfield.
Evidence
Preserve the empty status output and the committed HEAD from the preceding gate; the parent report binds that committed HEAD, tree, and context.
If that does not happen
If any greenfield path is printed, preserve the status and stop before opening brownfield; return to the greenfield review or commit gate that left it dirty.
Then create and commit the real brownfield context without synthetic plan documents:
17
YouActive harness
inspect brownfield
After greenfield is committed and clean, use Open Folder or the workspace switcher to visibly root the host at .academy/workspaces/U04-brownfield. A terminal cd does not change the host root.
Why this matters: Switching deliberately to brownfield keeps its existing-source workflow distinct from greenfield decomposition.
Expected result
The greenfield remains committed and clean while the host visibly names .academy/workspaces/U04-brownfield as its new project root. Next safe step: run brownfield init.
Evidence
Preserve the clean greenfield status and the host's visible U04-brownfield root label so the route transition is auditable.
If that does not happen
If greenfield is dirty or the host displays any root other than U04-brownfield, stop; preserve both statuses and switch folders visibly before invoking codeArbiter.
18
Your host
run brownfield init
Only while visibly rooted at .academy/workspaces/U04-brownfield, run ca-init; a terminal cd does not change the host root.
Why this matters: Brownfield initialization starts governance in the existing child, never in the Academy root.
Any OS · Claude Code
/ca:init
Any OS · Codex
$ca-init
Any OS · Pi
/ca-init
Any OS · Pi
/skill:ca-init
Expected result
ca-init scaffolds an uncommitted .codearbiter directory inside U04-brownfield only while preserving its existing source files. Next safe step: run brownfield create context.
Evidence
Preserve ca-init output and brownfield status showing new governance beside, not replacing, the prepared source.
If that does not happen
If ca-init targets another root or changes existing brownfield source, stop and preserve the transcript and status; do not commit, reset, or mask those changes.
19
Your host
run brownfield create context
Only while visibly rooted at .academy/workspaces/U04-brownfield, run ca-create-context; a terminal cd does not change the host root. Keep this route bound to existing source and do not use ca-decompose on the brownfield. ca-create-context does not create the three ca-reconcile plan inputs.
Why this matters: Create-context is the genuine brownfield route and does not invent greenfield plan artifacts.
Any OS · Claude Code
/ca:create-context
Any OS · Codex
$ca-create-context
Any OS · Pi
/ca-create-context
Any OS · Pi
/skill:ca-create-context
Expected result
ca-create-context derives brownfield governance from existing source, including .codearbiter/CONTEXT.md, and creates none of the three greenfield reconciliation plan files. Next safe step: inspect brownfield changes.
Evidence
Preserve the ca-create-context transcript, generated root governance paths, and absence of .codearbiter/plans/01-architecture-breakdown.md, 02-phased-build-plan.md, and 03-task-backlog.md.
If that does not happen
If the host proposes ca-decompose, synthetic reconciliation plans, or context unrelated to the existing source, stop and preserve the transcript; rerun ca-create-context only from the visible brownfield root.
20
You
inspect brownfield changes
Inspect brownfield status and unstaged governance diff before staging.
Why this matters: Inspecting the brownfield diff exposes the exact context artifacts before they become committed evidence.
Brownfield status and the unstaged diff show only intended .codearbiter context derived from the prepared source; existing source is unchanged and nothing is staged yet. Next safe step: stage brownfield changes.
Evidence
Preserve the pre-stage brownfield status and full .codearbiter diff as the review record for the context-creation boundary.
If that does not happen
If status names source edits, reconciliation plans, or unrelated paths, preserve the full status and diff and stop; do not stage or discard them as generated context.
21
You
stage brownfield changes
After review, stage only brownfield generated governance changes.
Why this matters: Selective staging confines the brownfield commit to generated governance state.
Only reviewed U04-brownfield .codearbiter changes are staged, and diff --cached --name-only prints those exact governance paths. Next safe step: review brownfield commit boundary.
Evidence
Preserve the cached name list proving the brownfield index contains only context-creation governance.
If that does not happen
If an existing source file or any unexpected path is staged, preserve the cached name list, unstage only that path, and return to the brownfield unstaged review.
22
You
review brownfield commit boundary
Review the full cached diff, then use Open Folder or the workspace switcher to keep the host visibly rooted at .academy/workspaces/U04-brownfield.
Why this matters: Cached-diff review catches an incorrect brownfield boundary before a durable child commit.
diff --cached --check reports no whitespace errors, and the full cached diff is the exact brownfield governance the learner intends to commit. Next safe step: run brownfield commit gate.
Evidence
Preserve the clean cached-check output and reviewed cached diff; together they define the exact bytes offered to the brownfield commit gate.
If that does not happen
If the cached check reports an error or the diff contains source edits, plans, or another unapproved change, preserve the output and stop; correct the brownfield index before ca-commit.
23
Your host
run brownfield commit gate
Only after learner review while visibly rooted at .academy/workspaces/U04-brownfield, run ca-commit; a terminal cd does not change the host root.
Why this matters: The brownfield child must pass its own commit gate so its history is independently verifiable.
Any OS · Claude Code
/ca:commit
Any OS · Codex
$ca-commit
Any OS · Pi
/ca-commit
Any OS · Pi
/skill:ca-commit
Expected result
ca-commit creates a new child commit in U04-brownfield containing the reviewed staged context and does not commit either the parent or greenfield. Next safe step: confirm brownfield clean.
Evidence
Preserve the successful ca-commit transcript and resulting brownfield commit hash; the later binding must use this committed HEAD.
If that does not happen
If the gate stops or requests remediation, preserve its findings and the staged diff; remediate in U04-brownfield and rerun ca-commit instead of bypassing it or using raw git commit.
24
You
confirm brownfield clean
After brownfield ca-commit succeeds, confirm its status is empty.
Why this matters: A clean brownfield status proves no uncommitted state is hidden behind the parent binding.
Windows
git -C .academy\workspaces\U04-brownfield status --short
macOS
git -C .academy/workspaces/U04-brownfield status --short
Linux
git -C .academy/workspaces/U04-brownfield status --short
Expected result
git status --short prints nothing, so the U04-brownfield working tree is clean after its new child commit. Next safe step: inspect project evidence.
Evidence
Preserve the empty status output and the committed HEAD from the preceding gate; the parent report binds that committed HEAD, tree, and context.
If that does not happen
If any brownfield path is printed, preserve the status and stop before binding; return to the brownfield review or commit gate that left it dirty.
Only after both child commits are clean may the Academy parent bind them. The canonical writer derives
the report from committed child state, so no learner or agent has to guess headings, labels, field
order, or terminal newline.
25
You
inspect project evidence
Only after both child ca-commit gates succeed and both statuses are empty, inspect committed heads, trees, context digests, and statuses.
Why this matters: The parent report may bind only committed child heads and trees, so inspect those immutable facts first.
Windows
git -C .academy\workspaces\U04-greenfield status --short
git -C .academy\workspaces\U04-brownfield status --short
git -C .academy\workspaces\U04-greenfield rev-parse HEAD HEAD^{tree}
git -C .academy\workspaces\U04-brownfield rev-parse HEAD HEAD^{tree}
(Get-FileHash .academy\workspaces\U04-greenfield\.codearbiter\CONTEXT.md -Algorithm SHA256).Hash.ToLowerInvariant()
(Get-FileHash .academy\workspaces\U04-brownfield\.codearbiter\CONTEXT.md -Algorithm SHA256).Hash.ToLowerInvariant()
macOS
git -C .academy/workspaces/U04-greenfield status --short
git -C .academy/workspaces/U04-brownfield status --short
git -C .academy/workspaces/U04-greenfield rev-parse HEAD 'HEAD^{tree}'
git -C .academy/workspaces/U04-brownfield rev-parse HEAD 'HEAD^{tree}'
shasum -a 256 .academy/workspaces/U04-greenfield/.codearbiter/CONTEXT.md .academy/workspaces/U04-brownfield/.codearbiter/CONTEXT.md
Linux
git -C .academy/workspaces/U04-greenfield status --short
git -C .academy/workspaces/U04-brownfield status --short
git -C .academy/workspaces/U04-greenfield rev-parse HEAD 'HEAD^{tree}'
git -C .academy/workspaces/U04-brownfield rev-parse HEAD 'HEAD^{tree}'
sha256sum .academy/workspaces/U04-greenfield/.codearbiter/CONTEXT.md .academy/workspaces/U04-brownfield/.codearbiter/CONTEXT.md
Expected result
Both status commands print nothing, followed by each child's committed HEAD, committed tree, and context digest from .codearbiter/CONTEXT.md. Next safe step: write binding report.
Evidence
Preserve the six binding values and both empty statuses exactly as printed; they are the source facts the canonical writer must bind.
If that does not happen
If either status is nonempty or any HEAD, tree, or digest is missing, preserve all output and return to that child; do not generate a parent report from partial or uncommitted state.
26
You
write binding report
After both children are committed and clean, run the supported canonical writer from the Academy root. Never hand-author verifier-sensitive report bytes.
Why this matters: The supported writer derives canonical report bytes from live child repositories instead of trusting a hand-written claim.
The writer creates .codearbiter/reports/academy/U04-initialization.md with canonical generated bytes bound to both clean committed children. Next safe step: inspect report.
Evidence
Preserve the canonical report at its exact path plus each child's committed HEAD, committed tree, and context digest that it records.
If that does not happen
If the writer reports a dirty, uncommitted, or wrong-layout child, preserve the message and return only to that child; do not hand-author the report.
27
You
inspect report
Inspect the canonical parent report before staging.
Why this matters: Inspecting the generated report verifies its binding facts before it enters the parent commit.
The report displays Greenfield, Brownfield, and Route evidence sections with the exact child paths, HEADs, trees, CONTEXT-SHA256 digests, and route artifacts. Next safe step: stage report.
Evidence
Preserve the displayed canonical report and compare every binding field to the immediately preceding child evidence.
If that does not happen
If a field is absent or differs from the inspected child evidence, preserve the report and child outputs, then rerun the canonical writer after fixing the child state; do not edit the report.
28
You
stage report
After review, stage only the canonical parent report.
Why this matters: Staging only the canonical report prevents child content or unrelated parent files from entering the binding commit.
Only .codearbiter/reports/academy/U04-initialization.md is staged in the Academy parent, and diff --cached --name-only prints exactly that path. Next safe step: review commit boundary.
Evidence
Preserve the one-line cached name list naming only .codearbiter/reports/academy/U04-initialization.md.
If that does not happen
If any other parent path is staged, preserve the cached list and unstage only the unexpected path; leave both child histories untouched.
29
YouActive harness
review commit boundary
Confirm only the report is staged and both children are clean. Then use Open Folder or the workspace switcher to return to the Academy root.
Why this matters: The parent cached diff must contain only the report while both child repositories remain clean.
Expected result
The parent index contains only U04-initialization.md, both child statuses remain empty, and the host visibly shows the Academy root. Next safe step: run commit gate.
Evidence
Preserve the single staged report path, both empty child statuses, and the visible Academy-root label presented to the parent commit gate.
If that does not happen
If another parent path is staged, either child is dirty, or the host shows a child root, stop; preserve the cached list and statuses and correct only that boundary before ca-commit.
30
Your host
run commit gate
Only at the visibly confirmed Academy root, run ca-commit; do not run it in either child.
Why this matters: The Academy-root commit gate preserves the separation between parent evidence and child governance history.
Any OS · Claude Code
/ca:commit
Any OS · Codex
$ca-commit
Any OS · Pi
/ca-commit
Any OS · Pi
/skill:ca-commit
Expected result
ca-commit creates a new Academy-parent commit whose only changed path is .codearbiter/reports/academy/U04-initialization.md; child histories do not change. Next safe step: confirm clean.
Evidence
Preserve the successful parent ca-commit transcript, new parent commit hash, and its one-path diff naming only the canonical U04 report.
If that does not happen
If the parent gate stops, preserve its findings and staged report; remediate from the Academy root and rerun ca-commit without recommitting either child.
31
You
confirm clean
Confirm parent, greenfield, and brownfield status are empty.
Why this matters: Three clean statuses prove the complete evidence topology is settled before acceptance.
Windows
git status --short
git -C .academy\workspaces\U04-greenfield status --short
git -C .academy\workspaces\U04-brownfield status --short
macOS
git status --short
git -C .academy/workspaces/U04-greenfield status --short
git -C .academy/workspaces/U04-brownfield status --short
Linux
git status --short
git -C .academy/workspaces/U04-greenfield status --short
git -C .academy/workspaces/U04-brownfield status --short
Expected result
All three status commands print nothing: the Academy parent, U04-greenfield, and U04-brownfield working trees are clean. Next safe step: recognize the accepted result.
Evidence
Preserve the three empty status outputs and current parent and child HEADs as the final clean-state record.
If that does not happen
If any command prints a path, preserve all three outputs and return only to the repository that is dirty; do not reset or rewrite either committed child history.
At success, greenfield has committed initialized context, the exact three
.codearbiter/plans/ artifacts, and at least one accepted ADR. Brownfield has committed initialized
context from its existing source and does not contain a synthetic three-plan reconciliation set.
Both child worktrees are clean before their heads, trees, and committed context digests are bound.
The parent commit changes only .codearbiter/reports/academy/U04-initialization.md.
The U04 Check will prove these repository facts. It will not prove that a host command
ran, that a learner made a good decision, or that anything was pushed or published.
Check validates committed repository facts. It does not prove that a host command ran, that a learner
made a good decision, or that anything was pushed or published.
32
You
check status
From the clean Academy root, run installed Academy Check after committing the canonical parent report.
Why this matters: Check validates durable child and parent facts, not an unobservable claim that a host command was invoked.
Check prints checkpoint U04-initialize-projects: passed and records progress only after it sees the clean committed parent report and both committed child states. Next safe step: preserve the completed attempt.
Evidence
Preserve Check output and the committed child HEADs, trees, context digests, and parent report it validated.
If that does not happen
If Check names a child or parent fact that does not match, preserve its output and return only to that boundary; do not infer success from a command exit alone.
U04 Reset deliberately refuses until Academy can archive both child histories. Preserve failures and
return to the exact child whose review or commit gate stopped. Do not reset, rewrite, or delete child
history to make status look clean.
33
You
reset retry
If you need to recover, invoke installed Academy Reset only to read its preservation diagnostic. U04 Reset intentionally refuses until Academy can archive both child histories.
Why this matters: Reset must refuse rather than discard child history until a supported archival path exists.
Reset reports that it is unavailable until Academy can archive both child repository histories and leaves all three repositories unchanged. Next safe step: preserve state and correct the named child or parent boundary.
Evidence
Preserve the Reset diagnostic plus parent and child status before and after it; their equality proves no history was rewritten.
If that does not happen
Use the status, cached-diff, and commit cards for the named repository. Do not delete, reset, or rewrite either committed child history to make status look clean.
The action manifest preserves actor, surface, timing, expected result, evidence, recovery, and next
safe step. Its verifier reads real codeArbiter layout from committed
child heads: decompose plans live under .codearbiter/plans/; context-creation documents remain in
their real root locations. The canonical writer and Check use the same byte renderer, so the report
that you inspect is the report Check verifies.
