Thanks to visit codestin.com
Credit goes to harperz9.github.io

Zain Dana Harperlearn · study planning and course logistics

Study what you gave it. Prove what you kept.

Learn plans and re-checks learner-authored study sessions from declared objectives and recorded attempts, using spaced review, retrieval prompts, prerequisite gating, misconception tracking, prediction, and self-explanation. It separately runs course logistics while halting at graded work.

The learner supplies the objectives, attempts, feedback, and graded work. Learn schedules, records, re-verifies, and preserves the handoff.

learn · v1.6.0 · published on npm · zero runtime dependencies · Node 20+

Two jobs, held apart on purpose.

Learner-authored material becomes a concept map, spaced-review schedule, retrieval drills, and a small set of graded checkpoints. A separate aid path can explain the same concept several ways, generate extra practice, walk through a worked example, and coach toward the answer.

What keeps those two jobs from collapsing into each other is a hard line at the graded step. An aid-render, an explanation, a hint, a worked example the tutor generated for you, carries a marker that says so, and that marker makes it structurally ineligible to stand in for your own graded work. The course does not trust you to leave the aid out of the submission. It checks.

Coaching has no ceiling. Grading has a floor, and the floor holds.

The loop is spaced review, retrieval, predict, explain, target the gap.

Reading a summary twice feels like learning and mostly is not. learn is built around the study techniques that actually move material into long-term memory, run against your own source content instead of a generic deck.

spaced repetition a scheduler resurfaces each concept right before you would have forgotten it, tuned per item from your own recall history, not a fixed calendar
retrieval practice the retrieval command creates cloze prompts from a learner-supplied draft and an explicit objective; it does not silently invent a complete curriculum
predict, then observe record a prediction as a pending practice attempt, then score that recorded attempt after observing the result
self-explanation, checked turn a learner-written explanation into a thesis artifact that can be evaluated separately; Learn does not itself decide that the explanation is correct
misconception targeting wrong attempts are grouped by objective and ranked by count, preserving the learner-supplied feedback attached to each attempt
concept and prerequisite map every concept in your material is linked to what it depends on, so the course sequences itself instead of assuming you already have the foundation

learn tutor study is a planner, not an interactive tutor session. Given a saved session and an explicit time, it returns what is due, the ranked misconceptions, study order, prerequisite readiness, and the current mastery-gate result.

The floor is quiet, and it does not move.

Every graded step in a course is an assess node, and every assess node halts. The engine stops generating, hands you the checkpoint, and waits. There is no configuration that skips this, because the halt is not a setting, it is the shape of the step. What you submit there, and only what you submit there, is hashed into a run ledger alongside the prior step's hash, so the ledger is a hash chain: altering an earlier answer after the fact breaks every seal after it, not just the one you touched.

An aid-render can help you understand. It can never stand in for the step where you show you did.

The implemented boundary is simpler. Tutor attempts are practice records, and their receipts state that they are not graded-assessment answers. The course runner halts at assessment steps and requires an operator attestation before resuming. Learn does not currently compare graded submissions against a hash bank of generated tutor output, so the site does not claim that control.

A receipt you can re-check does not get to grade its own homework.

A study receipt carries a verified flag and a ledgerVerified flag. Both are written by whoever produced the receipt, which means neither is worth anything on its own. learn tutor reverify ignores them on purpose and re-derives the receipt from its own evidence instead: it walks the hash chain over the witnessed practice entries and recomputes it, and it re-runs the mastery verdict from the recorded attempts under the recorded policy. If either recomputation disagrees with what the receipt claims, the receipt fails, whatever its stored booleans say.

CHAIN_BROKEN the hash chain over the practice entries does not recompute; the failure names the offending entry's sequence number and hash, and a hash-consistent truncation is still caught by attempt accounting
VERDICT_MISMATCH the stored mastery verdict does not re-derive from the recorded attempts under the recorded policy; the failure carries both projections, the one on the receipt and the one recomputed, so the divergence is visible, not asserted
UNVERIFIED a receipt with no chain to walk cannot re-verify, so it is reported unverified, never verified; the absence of evidence is not treated as evidence

A verifier that cannot fail on a known-bad receipt is not a verifier. doctor re-checks that one at runtime: it must pass a clean receipt and reject a tampered chain, a hand-edited verdict, and a chainless receipt.

A failed proof is a lesson, not a dead end.

A proof-surface packet is a verified-claim record: a claim, its scope, its sources with hashes, and a MATCH, DRIFT, or UNVERIFIABLE verdict. learn tutor prooflesson turns one into something you study from, without turning it into an answer sheet. It preserves the packet's own evidence surface, source references and never their bodies, and derives three things around it.

explanation scaffold numbered prompts that ask you to derive the reasoning yourself; the packet's own decision reasoning is never dumped into the lesson, so the lesson coaches the derivation instead of handing it over
retrieval questions recall prompts built from the packet's own fields, including ‘what evidence would falsify this claim,’ so the drill rehearses the actual claim and its sources rather than a paraphrase
verifier binding the lesson's verdict, the packet id, and the source hashes are bound into the lesson; the lesson's verdict is copied from the packet and from nowhere else, so a lesson claiming MATCH from a DRIFT packet is impossible by construction and a forged verdict enum is rejected up front

When the proof attempt failed, the lesson also names why it failed. A DRIFT or UNVERIFIABLE packet yields a typed misconception record, contradicted for drift, overclaim for an unverifiable claim that still cited sources, missing_evidence for one that cited none, and its prompt asks you why the proof did not hold. A MATCH packet yields no misconception, because there is nothing there to correct. The lesson receipt is hash-chained the same way a study receipt is, and tutor reverify covers it: a tampered entry is CHAIN_BROKEN, a flipped verdict or edited lesson body is VERDICT_MISMATCH.

The lesson's verdict always equals the packet's. A wrong proof teaches you where you were wrong; it never gets promoted to right.

Zero-dependency Node package with explicit interop seams.

learn runs on Node's standard library with no third-party runtime dependency. Course workflows, tutor sessions, schedules, and run ledgers are JSON on disk, so their recorded state is inspectable with a text editor. Optional interop modules can prepare Gather, Crucible, or Telos artifacts without making those projects owners of Learn's core behavior.

telos the predict-then-observe step hands your prediction to the telos engine and renders or runs the real thing, so the checkpoint is a live comparison, not a static answer key
gather source material that already carries a provenance receipt, a paper, a transcript, a scanned chapter, imports straight into a course with that receipt intact, so the course cites where its content came from
crucible a self-explanation is registered as a claim against the source concept and measured, so ‘checked’ means a re-derivable verdict, MATCH, DRIFT, or UNVERIFIABLE, not a tutor's approval

Clocks are injected wherever a review time or a ledger timestamp is recorded, so a run is deterministic and replayable from the same inputs. The scheduler, the misconception classifier, and the three interop seams are all swappable behind a small interface, so a peer system can plug in without learn's core ever importing it directly.

Everything the tutor loop produces lands as a named artifact that can be kept and re-checked: mastery, study, proof-lesson, and schedule-derivation receipts. The MCP server exposes advisory tools plus two local write operations: learn_tutor_plan creates a session and learn_tutor_record appends learner-supplied practice. It does not actuate a live course site; real course runs remain on the operator-driven CLI.

Current state. How to run it.

Version 1.6.0 is published as @harperz9/learn. It installs the learn command, requires Node 20 or newer, and has no third-party runtime dependencies. A tutor session and a course workflow are JSON records on disk.

$ npm install -g @harperz9/learn
$ learn tutor plan mysession --topic derivatives --objectives power-rule,chain-rule
tutor plan mysession: 2 objective(s)

$ learn tutor record mysession --objective power-rule --prompt "Differentiate x^4" --answer "4x^3" --correct true
tutor record mysession: 1 practice attempt(s)

$ learn tutor study mysession --now 2026-08-28T12:00:00Z
tutor study mysession: due list, misconception count, order, readiness, and mastery status

$ learn run course.json --id course-run   # course logistics; assessment nodes halt for the learner
run course-run: halted @step 2

Use the tutor commands to plan and record your own practice. Use the workflow runner only with a course workflow you have reviewed; live browser attachment is explicit through --native.

GitHub → HarperZ9/learn  ·  ← all flagships  ·  the index