U01 is a guided, runnable lesson in Preview 0.32. The website remains the primary lesson surface.
Academy CLI prepares the reviewed attempt, checks its local evidence boundary, and creates a
non-destructive numbered retry when recovery is needed.
Complete P08 first. In your personal fork, keep the repository root open in a native terminal and
the selected codeArbiter harness. A command typed directly in a native terminal
has no !. A shell command passed through a harness begins with exactly one !. A host-native
codeArbiter command belongs to the harness and has no !. The action cards label each case.
1
YouBrowser
Confirm the fork-first lesson boundary
Open the reviewed immutable Preview 0.32 U01 boundary manifest before using any command. U01 is public only in your personal fork with origin as the fork, upstream fetch-only, and origin as the effective push remote.
Why this matters: The scenario and sprint can create commits, a fork branch, and a pull request; keeping upstream non-pushable is the exercise's safety boundary.
Expected result
You are in a clean forked checkout that completed P08 and can safely create a U01 attempt.
Evidence
The public Preview 0.32 manifest lists U01, while the Prepare preflight independently validates the live fork topology.
If that does not happen
If origin can push to arbiterForge or the topology is incomplete, stop and return to P08. Do not rewrite remotes or bypass the safety check for this lesson.
On a prepared U01 attempt, you will prove that a sprint did not self-authorize its work. The learner
reads the proposed specification, decides whether its scope is acceptable, then reads and explicitly approves the derived plan before autonomy can begin. The completed attempt preserves the derived specification, plan, append-only sprint log, and one bounded operator guide.
This is a documentation-only sprint. Its allowed final commit contains four paths: the spec, plan,
sprint log, and docs/academy-sprint-summary.md. The real sprint lane then pushes only the learner
fork branch and opens a pull request. It never pushes directly to upstream or merges. It does not
change product code, tests, dependencies, or remotes.
Run one installed Academy Prepare command from the clean forked repository root. It creates a numbered academy/U01-autonomous-sprint attempt with the reviewed scenario and brief.
Why this matters: Prepare installs only reviewed scenario bytes after validating the fork/upstream push boundary, so the sprint begins from an inspectable base.
Academy reports the numbered attempt branch and preparation commit; training_scenarios/U01-autonomous-sprint.json and U01-sprint-brief.json are committed on that branch.
Evidence
The Academy output names academy/U01-autonomous-sprint/N and its preparation commit; git status --short is empty afterward.
If that does not happen
If remote validation or preparation fails, preserve the error and return to P08. Do not copy scenario files or create an academy attempt branch yourself.
Prepare must run in the forked checkout that passed P08’s remote safety work. It creates the numbered
attempt from reviewed fixture bytes; do not recreate that branch or scenario manually.
3
You
Inspect the prepared scenario
After Prepare reports the numbered attempt, use one command surface to inspect the installed scenario file. A native terminal command has no !. A harness shell command begins with exactly one !.
Why this matters: The scenario declares the bounded target, approval-required starting condition, and the future operator-guide evidence without claiming that the current public toolchain installed it.
The prepared attempt shows autonomous_sprint, academy-sprint, approval-required, and docs/academy-sprint-summary.md.
Evidence
Retain the scenario file, U01-sprint-brief.json, and the numbered attempt branch name.
If that does not happen
If the file is absent, do not create it by hand. Confirm that Prepare succeeded on the U01 attempt branch, then use Reset only after preserving the failed attempt.
The scenario is installed by the reviewed Academy fixture. Its named deliverable and approval-required
starting condition explain the exact boundary the prepared attempt now contains.
The next actions run only on the numbered attempt that Prepare just created. They do not authorize
an autonomous sprint on an ordinary checkout.
4
Your host
Use the host-native sprint command on the prepared attempt
On the prepared U01 attempt, run this codeArbiter command in the selected harness. It is not a shell command, so it never begins with !. The real sprint lane requires explicit learner approval of both its proposed specification and its derived plan before autonomous work begins; it ends by pushing the learner fork branch and opening a pull request.
Why this matters: An autonomous sprint may execute only after its specification and plan gates. It cannot self-authorize the scope of an Academy exercise or merge its own pull request.
Any OS · Claude Code
/ca:sprint academy-sprint
Any OS · Codex
$ca-sprint academy-sprint
Any OS · Pi
/ca-sprint academy-sprint
Any OS · Pi
/skill:ca-sprint academy-sprint
Expected result
The host presents the proposed specification, then its derived plan, before autonomous work begins; after its commit gate it opens a pull request from the learner fork and never merges it.
Evidence
Preserve the proposed specification, derived plan, operator guide, and appended sprint-log decision record. Check validates repository facts, not host invocation, approval, or pull-request creation.
If that does not happen
If the host cannot find the sprint command, do not replace it with shell syntax. Confirm the supported host installation and prepared attempt first.
5
YouActive harness
Make the sprint specification decision
Read the proposed specification before answering the host. Approve only the bounded academy-sprint operator guide with explicit acceptance criteria, no product-code, test, dependency, or remote changes, and the real sprint terminal: push only the learner fork branch, open a pull request, never merge. Decline or revise vague scope.
Why this matters: The learner, not the autonomous process, owns the scope decision that permits later execution.
Expected result
The host either records an explicit approved specification and proceeds, or stops with the requested revision still visible.
Evidence
Check inspects the prepared brief, final spec, plan, guide, append-only log, exact commit paths, and clean worktree. It does not verify the approval itself.
If that does not happen
If the proposal changes boundaries you did not intend, decline it. Preserve the proposal and use Reset only after you have reviewed the failed attempt.
6
YouActive harness
Make the sprint plan decision
After approving the bounded specification, read the derived plan before answering the host. Approve only a plan that preserves the academy-sprint operator-guide scope, acceptance criteria, no product-code, test, dependency, or remote changes, and the fork-only pull-request terminal. Decline or revise a plan that expands those boundaries.
Why this matters: The learner owns the plan approval that permits autonomous execution; approving a specification alone is not enough.
Expected result
The host either records an explicit approved plan and begins autonomous execution, or stops with the requested plan revision visible.
Evidence
Check inspects final repository facts. It does not verify either approval or a host conversation.
If that does not happen
If the plan changes boundaries you did not intend, decline it. Preserve the proposed specification and derived plan, then use Reset only after reviewing the failed attempt.
7
You
Inspect the governed artifact paths
On the prepared attempt after the sprint has stopped or completed, inspect the four named artifact paths in a native terminal. This is an observation command, so it has no !.
Why this matters: The verifier-owned evidence boundary is explicit before the lesson becomes publicly runnable.
ls -l .codearbiter/specs/academy-sprint.md .codearbiter/plans/academy-sprint.md .codearbiter/sprint-log.md docs/academy-sprint-summary.md
Linux
ls -l .codearbiter/specs/academy-sprint.md .codearbiter/plans/academy-sprint.md .codearbiter/sprint-log.md docs/academy-sprint-summary.md
Expected result
A completed exercise exposes the spec, plan, append-only sprint log, and operator guide for review. Their presence alone is not a passing result.
Evidence
Retain the paths and review result. The predicate also requires their scope, one commit, preserved log prefix, and a clean worktree.
If that does not happen
If any artifact is absent or the worktree is not the prepared attempt, stop. Do not create substitute files to imitate evidence.
The sprint specification and plan gates are where the learner sets authority. Check can verify the resulting
repository evidence, but it cannot prove that a person understood the proposal, made a good judgment
call, typed a host command, or created the pull request.
Success is a reviewable boundary: a prepared attempt, a bounded
specification and plan, an append-only sprint record, and one operator guide in the same committed
packet. The real sprint lane opens a pull request from the learner fork after its commit gate. It is
not a public release claim, proof that a pull request exists, or permission to merge.
Check accepts one linear learner commit containing exactly those four paths. It checks the
prepared brief, exact headings and scope, a preserved sprint-log prefix, the required guide topics,
and a clean worktree. It does not authenticate approval.
Run one installed Academy Check command from the prepared attempt. The reviewed profile evaluates the bounded four-artifact packet described by this lesson.
Why this matters: The installed release accepts only the reviewed sprint-evidence contract and fails closed for altered scope or unsafe remotes.
Academy Check reports pass only when the prepared brief, exact artifact scope, safe remote topology, one learner commit, and clean worktree all match; otherwise it reports a nonzero failure.
Evidence
The Check result and the committed four-path packet are local evidence. They do not prove host invocation, approval, or pull-request creation.
If that does not happen
Do not edit progress or release data to change the result. Inspect the reported repository boundary, preserve the attempt, then Reset for a numbered retry if needed.
Check verifies repository-derived evidence rather than a transcript supplied by the learner. It does not prove that
a host command ran, that a learner approved a proposal knowingly, or that an autonomous process
reasoned well. It does not prove that a pull request was created.
Separate the sprint’s specification approval and plan approval from its later implementation activity. Autonomous
execution may begin only after both explicit gates.
Treat a failed Check as evidence to inspect, not an invitation to rewrite history or manufacture
artifact content. Preserve the attempt and use Reset only after returning safely to main.
9
You
Return to main only after the attempt is clean
On a clean checked attempt, return to main from a native terminal. This is a direct shell command, so it has no !.
Why this matters: Leaving evidence intact keeps an incomplete training run inspectable without treating it as public completion.
Windows
$status = git status --short
if ($status) {
Write-Error "The U01 attempt is dirty. Inspect it before switching branches."
exit 1
}
git switch main
macOS
status="$(git status --short)"
if [ -n "$status" ]; then
printf '%s\n' "The U01 attempt is dirty. Inspect it before switching branches." >&2
exit 1
fi
git switch main
Linux
status="$(git status --short)"
if [ -n "$status" ]; then
printf '%s\n' "The U01 attempt is dirty. Inspect it before switching branches." >&2
exit 1
fi
git switch main
Expected result
git status --short prints nothing before main becomes the active branch.
Evidence
The numbered attempt remains reachable for later review.
If that does not happen
If status shows changes, stop and inspect them. Do not discard, amend, rebase, force-update, or delete the attempt branch to make it look clean.
10
Academy
Reset safely to a numbered retry
After returning to main with the failed attempt preserved, run one installed Academy Reset command. Reset archives no history destructively and creates the next numbered U01 attempt from the reviewed base.
Why this matters: A retry must preserve the prior evidence while creating an independent, inspectable scenario branch.
Academy reports academy/U01-autonomous-sprint/N+1 and a new preparation commit; the earlier attempt branch remains reachable.
Evidence
Both numbered attempt refs are reachable and git status --short is empty on the new attempt.
If that does not happen
Do not simulate Reset with destructive Git commands. If Reset refuses because the current attempt is dirty or still active, inspect and preserve it before retrying.
U02 is published in Preview 0.32. Continue through its published Academy lesson rather than using
unpublished source exercises as a substitute for a guided route.
The scenario supplies an approval-required documentation scope, the required operator-guide title,
and three topics. The checkpoint compares that prepared brief with the final spec, plan, guide, and
append-only sprint log. It accepts one clean descendant commit with no extra paths.
This guide uses the shared action manifest and renderer, records each actor and execution surface,
and keeps the website-first lesson boundary intact.
