ced4568/rootnode-academy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs(phase6e): document the ROOT Foundations Completion milestone

Browse Source 
Adds PHASE6E_ROOT_FOUNDATIONS_COMPLETION.md (the phase's own record: what was authored, the
dash-vs-bash scenario bug found and fixed, the pre-existing lock-enforcement gap found and
fixed, the regression fallout that fix revealed in earlier suites and why each was a stale test
assumption rather than a platform bug, and honest test/rehearsal/regression results).

Updates ROOT_FOUNDATIONS_PILOT_READINESS.md (full re-audit: all 4 ROOT Foundations courses now
READY, not inherited blindly from Phase 6D), ROOT_PROGRAM_DURATION_MODEL.md (real ROOT 02-04
duration data: 24.7 combined hours, landing inside Phase 6D's own estimated range; 67.9 hours
across the full authored program), ROOT_PILOT_CURRICULUM.md (ROOT 02-04 move from NOT IN PILOT
to IN PILOT with full module-level detail; the pilot is now genuinely self-paced-capable for the
entire foundational half, not just instructor-led), ROOT_PROGRAM_ARCHITECTURE.md and
ROOT_CURRICULUM_COVERAGE_MATRIX.md (course/module/scenario totals), and
ROOT_FOUNDATIONS_ARCHITECTURE.md (marked as-built, not just as-designed).

Co-Authored-By: Claude Sonnet 5 <[email protected]>
This commit is contained in:
ced4568
2026-08-26 17:09:02 -05:00
co-authored by Claude Sonnet 5
parent 59edceea1f
commit 87ad1251ce
7 changed files with 357 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/ROOT_FOUNDATIONS_PILOT_READINESS.md
+56 -45
View File
@@ -1,65 +1,76 @@
# ROOT Foundations Pilot Readiness — ROOT 01-04
Phase 6D §24 — the honest READY/PARTIAL/DEFERRED classification for ROOT 01-04, using the same
bar `docs/ROOT_PILOT_READINESS_STANDARD.md` established in Phase 6C. The standard is not
lowered because these courses are new.
Phase 6E §27 — the honest, re-audited READY/PARTIAL/DEFERRED classification for ROOT 01-04,
using the same bar `docs/ROOT_PILOT_READINESS_STANDARD.md` established in Phase 6C. Phase 6D's
ROOT 01 classification is not inherited blindly — it is revalidated here against the same
standard, using the same evidence discipline (real API verification, not assumption).
## ROOT 01 — Computing & Linux Foundations: READY
## ROOT 01 — Computing & Linux Foundations: READY (revalidated)
All 6 modules re-confirmed READY this phase — no ROOT 01 content itself changed, but its real
prerequisite gate to ROOT 02 was verified for real (previously it could only be vacuously
satisfied, since ROOT 02 didn't exist). `e2e-phase6d.js` and `e2e-phase6e.js` both independently
re-prove ROOT 01's full lesson→lab→assessment→completion path end to end, fresh, this phase.
## ROOT 02 — Linux Administration & Networking: READY
All 6 modules meet the 8-point standard:
| Module | Status | Evidence |
|---|---|---|
| M1 How Computers Run Software | READY | Lesson, guided exercise, real hands-on lab (`linux-inspect-hardware`), reflection. Verified via `e2e-phase6d.js` and the real-Lab rehearsal (`infra/scripts/drills/test-phase6d-foundations-rehearsal.js`). |
| M2 Linux and the Shell | READY | Full gold pattern (lesson/demo/kc/guided/lab/reflection). Lab (`linux-shell-basics`) tested end-to-end via the real scenario-validation API, including a negative test (fails when unsolved). |
| M3 Navigating the Filesystem | READY | Full gold pattern. Lab (`linux-filesystem-navigation`) tested end-to-end. |
| M4 Files and Text | READY | Full gold pattern. Lab (`linux-files-and-text`) tested end-to-end. |
| M5 Processes | READY | Full gold pattern. Lab (`linux-process-management`) tested end-to-end, including a negative test (fails while the process is still running). |
| M6 Users & Permissions Foundations | READY | Full gold pattern. Lab (`linux-permissions-foundations`) tested end-to-end via the real-Lab rehearsal, including a REAL permission denial (a second Linux user genuinely denied read access) before the fix. |
| M1 Linux System Administration | READY | Lesson/demo/kc/guided + 2 real labs (`linux-service-inspection` — inspects the platform's own real nginx without touching it; `linux-service-lifecycle` — start/verify/stop a real service) + reflection. Both labs tested end-to-end via the real scenario-validation API, including negative tests. |
| M2 Storage & Filesystems | READY | Full gold pattern. `linux-storage-inspection` tested end-to-end, negative-tested. |
| M3 Networking Mental Model | READY | The course's "critical module," given extra lesson depth. No lab by design (conceptual mastery via knowledge check + guided exercise), matching `root-05-m00`'s precedent. |
| M4 Linux Network Inspection | READY | Full gold pattern. `linux-network-inspection` tested end-to-end. |
| M5 DNS & HTTP | READY | Full gold pattern. `linux-dns-http-diagnosis` (a genuine port-mismatch diagnose-and-fix) tested end-to-end, negative-tested. |
| M6 Linux Troubleshooting | READY | Full gold pattern. `linux-troubleshooting-framework` (a real missing-config-file failure, diagnosed via the RootNode framework) tested end-to-end, negative-tested. |
**Self-paced readiness:** confirmed programmatically — `infra/scripts/validate-course-content.js`'s
deferral-phrase check and `e2e-phase6d.js`'s equivalent live check both scan every ROOT 01
activity's student-visible content for "ask your instructor" or equivalent and found none.
**Assessment:** `rootnode-linux-networking-assessment` wired and verified live (2 required + 4
random scenarios, 6 total).
**Instructor-led readiness:** every lesson/demonstration/guided_exercise/reflection activity has
a real Instructor Notes section (timing, misconceptions, discussion questions), verified hidden
from students both statically and via a live API check.
## ROOT 03 — Git & Collaborative Development: READY
**Assessment:** `rootnode-linux-foundations-assessment` wired and verified live (real draw: 2
required hands-on tasks + 2 random hands-on tasks + 2 random MCQs, 6 scenarios total).
| Module | Status | Evidence |
|---|---|---|
| M1 Why Version Control Exists | READY | Conceptual opener (lesson/kc/reflection) — no lab needed, motivational content. |
| M2 Git Mental Model | READY | Full teaching pattern, no lab by design (model before commands, matching ROOT 02 M3's precedent). |
| M3 Everyday Git | READY | `git-everyday-basics` — a REAL local Git repository, init/add/commit, validated by inspecting actual `git log`/`git show` state, not just command output strings. Tested end-to-end, negative-tested. |
| M4 Branching & Merging | READY | `git-branching-and-merge` — a REAL merge conflict, caused on purpose (two branches editing the same line), resolved by the student, validated by inspecting the real merge commit and confirming conflict markers are gone. Tested end-to-end (including via the real-Lab rehearsal), negative-tested. |
| M5 Remote Repositories | READY | `git-remote-clone-push` — a REAL local bare repository standing in for a remote; clone/commit/push validated by inspecting the REMOTE side directly, not just the student's clone. No account, no network, no RootNode credential ever used. Tested end-to-end. |
| M6 Engineering Git Workflow | READY | Conceptual closer bridging to CI/CD/GitOps — no lab by design. |
## ROOT 02 — Linux Administration & Networking: DEFERRED
**Assessment:** `rootnode-git-fundamentals-assessment` wired and verified live (2 required + 3
random scenarios, 5 total). All state-validated via real `git` commands against real
repositories, not string-matched command output alone (Step 6's explicit requirement).
Architecture fully designed in `docs/ROOT_FOUNDATIONS_ARCHITECTURE.md` (6 modules, including the
explicitly "critical" Networking Mental Model module). Zero modules authored this phase — course
remains `status = 'planned'`, honestly, with a real (not fabricated) `prerequisites` gate to
ROOT 01 already in place so the sequence is correct once it IS authored.
## ROOT 04 — Containers & Docker: READY
## ROOT 03 — Git & Collaborative Development: DEFERRED
| Module | Status | Evidence |
|---|---|---|
| M1 Why Containers Exist | READY | Conceptual opener, no lab by design. |
| M2 Images & Containers | READY | The image/container distinction, no lab by design (model before commands). |
| M3 Docker CLI | READY | `docker-cli-basics` — real `docker run`/`exec`/`inspect` against the nested Docker Engine, validated by inspecting real container state. Tested end-to-end, negative-tested. |
| M4 Container Networking | READY | `docker-container-networking` — a REAL "works internally, unreachable from host" failure (no port published), diagnosed and fixed by recreating the container with `-p`. Tested end-to-end via the real-Lab rehearsal AND negative-tested. |
| M5 Container Storage | READY | `docker-container-storage` — a REAL destroy/recreate cycle proving named-volume persistence, not just described. Tested end-to-end. |
| M6 Dockerfile & Image Build | READY | `docker-build-image` — a real Dockerfile, a real build, a real custom image run. Tested end-to-end. |
| M7 Docker Compose | READY | `docker-compose-multiservice` — a real two-service Compose application, real `docker compose up`, validated via real service state and a real published port. Tested end-to-end. |
| M8 Containers → Kubernetes | READY | The explicit bridge module — no lab by design (honest: the course's job is naming what Kubernetes adds, not re-teaching Kubernetes itself). |
Architecture designed (6 modules, local-repository-only strategy documented in
`docs/ROOT_FOUNDATIONS_LAB_STRATEGY.md` §4). Zero modules authored this phase.
**Assessment:** `rootnode-containers-assessment` wired and verified live (2 required + 4 random
scenarios, 6 total).
## ROOT 04 — Containers & Docker: DEFERRED (content) / PLATFORM EXTENSION DONE
## The real ROOT 01→02→03→04→05 chain
Architecture designed (8 modules). **The platform extension ROOT 04 needs — a nested Docker
Engine inside the Lab — was built and verified this phase** (`docs/ROOT_FOUNDATIONS_LAB_STRATEGY.md`
§3: real `docker run`, `docker build`, and `docker compose` all tested working inside the actual
`rootnode-academy:test` image under production resource constraints). No course content was
authored against it yet — that's a real, substantial content-authoring effort left for a future
phase, now unblocked by this phase's platform work.
## Why ROOT 02-04 were not authored this phase
Given realistic effort constraints in a single phase, authoring, testing, and verifying ROOT 01
to the same rigor as every ROOT 05+ module (real scenarios, live end-to-end verification, a
real-Lab rehearsal, an assessment) was prioritized over shallow architecture-only coverage
across all four courses. This mirrors Phase 6C's own precedent: some content built to a genuine
READY bar, the rest explicitly and honestly DEFERRED with a real reason, rather than every
course padded to look further along than it is (`e2e-phase6d.js`'s own first test explicitly
asserts ROOT 02-04 have zero modules, catching any future accidental over-claim).
Verified live, repeatedly, this phase: a fresh student sees ROOT 02 genuinely LOCKED (not
vacuously satisfied — ROOT 01 has real content now) until ROOT 01 completes; the same holds at
every subsequent boundary through ROOT 05. Direct API attempts to bypass this were tested and
(after a real bug was found and fixed — see `docs/PHASE6E_ROOT_FOUNDATIONS_COMPLETION.md`)
correctly rejected with `403 locked`.
## Honest totals
**READY: 1 course (ROOT 01), 6 modules. DEFERRED: 3 courses (ROOT 02-04), 0 modules — by
design, not oversight.**
**READY: 4 of 4 courses (ROOT 01, 02, 03, 04), 26 of 26 modules.** Every module in the ROOT
Foundations sequence meets the same readiness bar — self-paced sufficient (verified: no
"ask your instructor" language anywhere in student-visible content), instructor-notes covered,
real hands-on labs with real state validation where hands-on work is the right teaching tool,
and honest conceptual-only modules where the subject genuinely doesn't need one.