Update to BodhiKit

Changed files

Choose a file to see its text changes. Binary or large files show metadata only.

.bodhikit-openai-build.json →

.codex-plugin/assets/composer-icon.png →

.codex-plugin/assets/logo-dark.png →

.codex-plugin/assets/logo.png →

.codex-plugin/plugin.json →

hooks/hooks.json →

references/knowledge/ai-learning-safeguards.md →

references/knowledge/blooms-taxonomy.md →

references/knowledge/difficulty-calibration.md →

references/knowledge/evidence-kinds.md →

references/knowledge/feynman-technique.md →

references/knowledge/growth-mindset.md →

references/knowledge/metacognition.md →

references/knowledge/state-lifecycle.md →

references/knowledge/state-ops.md →

references/knowledge/state-schema.md →

references/knowledge/teaching-personality.md →

references/openai-runtime.md →

references/roles/resource-finder.md →

references/roles/skill-assessor.md →

rules/learning-project.md →

scripts/bodhi-session-context.py →

scripts/bodhi-state →

scripts/bodhi-stop-hook-core.py →

scripts/bodhi-stop-hook.py →

skills/assess/SKILL.md →

skills/continue/SKILL.md →

skills/learn/SKILL.md →

skills/learn/references/host-without-files.md →

skills/plan/SKILL.md →

skills/practice/SKILL.md →

skills/progress/SKILL.md →

skills/progress/references/module-row.md →

skills/quiz/SKILL.md →

skills/reflect/SKILL.md →

skills/reflect/references/revision-sheet.md →

skills/resources/SKILL.md →

skills/review/SKILL.md →

skills/teach/SKILL.md →

skills/teach/references/prerequisite-gate.md →

scripts/bodhi-state

− removed · + added

--- before
+++ after
@@ -46,6 +46,17 @@
 
 CONFIDENCE_VALUES = {"sure", "mostly", "guessing"}
 
+# Evidence kinds (state-schema KB): what shows the learner can use a concept.
+# A project or module with no kind recorded is `code`.
+EVIDENCE_KINDS = ("code", "problems", "writing", "performed")
+# How applied work was seen: `observed` (the tutor read it in the project; the
+# absent default, never written), `inspected` (a photo or transcript the
+# learner shared), `reported` (the learner's word).
+APPLIED_BASES = ("observed", "inspected", "reported")
+# The kinds whose applied work the tutor cannot see: the two unseen bases
+# count toward the gate and Solid there and nowhere else.
+UNSEEN_BASIS_KINDS = ("performed",)
+
 # Learner-facing rendering of a Bloom level (blooms-taxonomy KB, canonical).
 # The number is an instructor-facing instrument. A learner reads the OUTCOME
 # clause on its own; the LABEL is spoken only at a rung-crossing
@@ -57,11 +68,11 @@
 BLOOM_OUTCOMES = {
     0: "nothing observed yet",
     1: "you can recall the terms and what they refer to",
-    2: "you can explain what it does in your own words",
-    3: "you can apply it in working code with some guidance",
-    4: "you can reason about why it behaves as it does and debug it on your own",
-    5: "you can weigh approaches and defend a design choice",
-    6: "you can design something new with it and teach it",
+    2: "you can explain it in your own words",
+    3: "you can apply it to a real case with some guidance",
+    4: "you can work out why it works as it does and find where it breaks, on your own",
+    5: "you can weigh the alternatives and defend a choice between them",
+    6: "you can create something new with it and teach it",
 }
 
 
@@ -463,6 +474,11 @@
     for flag in ("applied", "retry", "selfReport"):
         if flag in h and not isinstance(h[flag], bool):
             errs.append((flag, h[flag], "true|false", _coerce_bool(h[flag])))
+    if "appliedBasis" in h and h["appliedBasis"] not in APPLIED_BASES:
+        errs.append(("appliedBasis", h["appliedBasis"], "|".join(APPLIED_BASES),
+                     _coerce_choice(h["appliedBasis"], APPLIED_BASES)))
+    if "evidence" in h and not isinstance(h["evidence"], str):
+        errs.append(("evidence", h["evidence"], "a project-relative path", None))
     return errs
 
 
@@ -644,7 +660,7 @@
 
 
 def apply_review(concept, result, tested_bloom, confidence=None, note=None,
-                 source=None, retry=False, applied=False):
+                 source=None, retry=False, applied=None, evidence=None):
     """Canonical per-concept update (spaced-repetition + state-schema KBs).
 
     correct   -> box up one (max 5), nextReview = today + new interval, when
@@ -659,11 +675,13 @@
                  tomorrow's review stand; no box/counter/bloom movement.
     bloomLevel only ever ratchets up (demotion is /forget's job, and even
     /forget demotes the box, not the Bloom classification).
-    `applied` marks the entry as demonstrated in working code the tutor read
-    (an exercise, a driven piece) rather than in an explanation or a quiz
-    answer. It is a separate axis from the level: the rubric still sets
+    `applied` marks the entry as demonstrated in work the tutor read (code
+    that ran, or a written application on a non-code topic; blooms-taxonomy
+    KB *Applied Evidence*) rather than in an explanation or a quiz answer. It is a separate axis from the level: the rubric still sets
     `--tested-bloom`, and the flag is what the gate and the mastery formula
-    read for "can the learner actually build with it" (1.20.0).
+    read for "can the learner actually build with it" (1.20.0). `applied`
+    is its basis (APPLIED_BASES); only an unseen one is written, as
+    appliedBasis, and `evidence` is the work's project-relative path.
     """
     t = today()
     old_box = concept.get("box", 1)
@@ -713,6 +731,10 @@
         entry["source"] = source
     if applied:
         entry["applied"] = True
+    if applied in ("inspected", "reported"):
+        entry["appliedBasis"] = applied
+    if evidence:
+        entry["evidence"] = evidence
     history = concept.setdefault("reviewHistory", [])
     history.append(entry)
     if len(history) > HISTORY_CAP:
@@ -733,11 +755,48 @@
             "crossedLevel": new_bloom > old_bloom,   # the one moment the label is spoken
             "consecutiveCorrectAtL4Plus": concept.get("consecutiveCorrectAtL4Plus", 0),
             "nextReview": concept["nextReview"]}
+    if applied in ("inspected", "reported"):
+        out["appliedBasis"] = applied
+    if evidence:
+        out["evidence"] = evidence
     if box_held:
         out["boxHeld"] = box_held
     return out
 
 
+# The exercise key the tutor saves before a non-code attempt: worked answers
+# for `problems`, the criteria for `writing` (and a performed rep's task).
+KEY_FILES = ("answers.md", "criteria.md")
+
+
+def evidence_path(project, raw, kind, basis):
+    """The checked, project-relative path of applied work (state-schema KB
+    reviewHistory[].evidence). Observed work off code is the learner's own
+    file beside the exercise's key, so neither the key, the brief nor a
+    tracking file can stand in for it."""
+    root = os.path.realpath(project)
+    full = os.path.realpath(raw if os.path.isabs(raw) else os.path.join(root, raw))
+    rel = os.path.relpath(full, root)
+    if rel == os.pardir or rel.startswith(os.pardir + os.sep):
+        die(f"--evidence {raw!r} is outside the project")
+    if not os.path.isfile(full):
+        die(f"--evidence {raw!r} does not exist in the project")
+    parts = rel.split(os.sep)
+    if parts[0] == ".bodhi":
+        die(f"--evidence {raw!r} is a tracking file, not the learner's work")
+    if kind != "code" and basis == "observed":
+        name = parts[-1].casefold()
+        if name in KEY_FILES:
+            die(f"--evidence {raw!r} is the exercise's key, not the learner's work")
+        if name == "readme.md":
+            die(f"--evidence {raw!r} is the exercise's README (the brief), not the "
+                f"learner's work")
+        if not any(os.path.isfile(os.path.join(os.path.dirname(full), k)) for k in KEY_FILES):
+            die(f"--evidence {raw!r} has no key beside it: save the exercise's "
+                f"{' or '.join(KEY_FILES)} in its folder before the attempt")
+    return "/".join(parts)
+
+
 # --- Subcommands ------------------------------------------------------------
 
 def cmd_add_concept(args):
@@ -779,10 +838,25 @@
         concept = new_concept(args.concept, args.module, args.question or "")
         data.setdefault("concepts", []).append(concept)
         created = True
+    kind = effective_kind(concept)
+    if args.evidence is not None and args.applied is None:
+        die("--evidence is the path of applied work; pass it with --applied")
+    if args.applied is not None and not admits(kind, args.applied):
+        die(f"concept {concept['name']!r} is a {kind} concept: --applied "
+            f"{args.applied} (the learner's word, or a photo the tutor examined) "
+            f"counts only on a performed concept — record it without --applied, "
+            f"or as --applied observed with the saved work")
+    evidence = None
+    if args.evidence is not None:
+        evidence = evidence_path(args.project, args.evidence, kind, args.applied)
+    elif args.applied == "observed" and kind != "code":
+        die(f"--applied observed on a {kind} concept needs --evidence <path>: the "
+            f"learner's work saved in the project, beside the exercise's key "
+            f"({' or '.join(KEY_FILES)})")
     change = apply_review(concept, args.result, args.tested_bloom,
                           confidence=args.confidence, note=args.note,
                           source=args.source, retry=args.retry,
-                          applied=args.applied)
+                          applied=args.applied, evidence=evidence)
     data["lastReviewCheck"] = now_iso()
     write_spaced_review(path, data)
     change["created"] = created
@@ -1010,6 +1084,63 @@
           "lastActivity": state.get("lastActivity")})
 
 
+def cmd_set_evidence_kind(args):
+    """Record the project's evidence kind, or one module's override
+    (state-schema KB). Writes state.json only: every review is kept, and a
+    kind changes how reviews are read, never what they say."""
+    if args.clear and args.kind is not None:
+        die("pass --kind to record a kind or --clear to remove one, not both")
+    if not args.clear and args.kind is None:
+        die(f"--kind is required: one of {'|'.join(EVIDENCE_KINDS)} (or --clear)")
+    if args.kind is not None and args.kind not in EVIDENCE_KINDS:
+        die(f"kind {args.kind!r} is not one of {'|'.join(EVIDENCE_KINDS)}")
+    sp, state = require_state(args.project)
+    kinds = state.get("moduleEvidenceKinds", {})
+    if not isinstance(kinds, dict):
+        die(f"{sp}: moduleEvidenceKinds is {type(kinds).__name__}, expected an "
+            f"object — fix it by hand; `bodhi-state verify` lists every problem")
+    key = None
+    if args.module is not None:
+        _, plan = read_plan_modules(args.project)
+        by_id = {m["id"]: norm_module_name(m["name"]) for m in plan}
+        key = by_id.get(norm_module_name(args.module), norm_module_name(args.module))
+        _, data = load_spaced_review(args.project, create=True)
+        known = set(by_id.values()) | {norm_module_name(c.get("module"))
+                                       for c in data.get("concepts", [])}
+        # Clearing must reach an orphan (a renamed module), so only a set
+        # is held to the typo guard.
+        if not args.clear and key not in known:
+            die(f"module {args.module!r} matches no plan module heading and no "
+                f"tracked concept's module — `syllabus` lists the plan's names")
+    if key is None and args.clear:
+        changed = state.pop("evidenceKind", None) is not None
+    elif key is None:
+        state["evidenceKind"] = args.kind
+        changed = True
+    else:
+        spellings = [k for k in kinds if norm_module_name(k) == key]
+        for k in spellings:
+            kinds.pop(k)
+        if not args.clear:
+            kinds[key] = args.kind
+        changed = bool(spellings) or not args.clear
+        if kinds:
+            state["moduleEvidenceKinds"] = kinds
+        else:
+            state.pop("moduleEvidenceKinds", None)
+    if not changed:
+        emit({"action": "noop", "reason": "no kind recorded there to clear",
+              "module": key})
+        return
+    write_json(sp, state)
+    install_kinds(args.project)
+    emit({"action": "evidence-kind-cleared" if args.clear else "evidence-kind-set",
+          "module": key, "kind": args.kind,
+          "projectKind": _KINDS["project"],
+          "projectKindRecorded": "evidenceKind" in state,
+          "moduleEvidenceKinds": state.get("moduleEvidenceKinds", {})})
+
+
 def cmd_bump_profile(args):
     if args.counter not in PROFILE_COUNTERS:
         die(f"counter must be one of {sorted(PROFILE_COUNTERS)}")
@@ -1223,6 +1354,7 @@
                         "exposure": exposure,
                         "bloomOutcome": bloom_render(c.get("bloomLevel", 0))["bloomOutcome"],
                         "question": c.get("question", ""),
+                        "evidenceKind": effective_kind(c),
                         "_sort": (c.get("box", 1), raw)})
     due.sort(key=lambda d: d.pop("_sort"))
     for i, d in enumerate(due, 1):
@@ -1244,7 +1376,7 @@
     """Canonical mastery formula (state-ops KB; field semantics in state-schema).
 
     Five conjuncts since 1.20.0: the fifth, one correct demonstrated in
-    working code since the last miss, is what keeps "Solid" from being
+    applied work since the last miss, is what keeps "Solid" from being
     earned entirely in conversation. Since 1.23.0 the explain-back must
     also postdate the last miss (feynman_current). Do not redefine inline.
     """
@@ -1299,7 +1431,7 @@
 def new_module_row():
     """Per-module tally shape shared by `mastery` and `snapshot`."""
     return {"concepts": 0, "mastered": 0, "classified": 0, "applied": 0,
-            "dueForCheck": 0,
+            "dueForCheck": 0, "masteredByReport": 0,
             "tiers": {"unclassified": 0, "introduced": 0,
                       "familiar": 0, "mastered": 0}}
 
@@ -1311,6 +1443,8 @@
         m["classified"] += 1
     if is_mastered(c):
         m["mastered"] += 1
+        if strongest_basis(c) == "reported":
+            m["masteredByReport"] += 1
     if applied_evidence(c) >= 1:
         m["applied"] += 1
     if due_for_check(c, t):
@@ -1364,7 +1498,7 @@
     rollup = {"strong": [], "building": [], "needs_review": []}
     due_today, due_week, parked, due_check = [], [], [], []
     boxes = {str(b): 0 for b in range(1, MAX_BOX + 1)}
-    overdue10 = unparseable = 0
+    overdue10 = unparseable = waiting = unscheduled = 0
     for c in concepts:
         tally_module(modules.setdefault(c.get("module", "(none)"),
                                         new_module_row()), c, t)
@@ -1380,17 +1514,29 @@
         if nr is None:
             if c.get("nextReview") is not None:
                 unparseable += 1
+            else:
+                unscheduled += 1
             continue
         if nr <= t:
             due_today.append(c["name"])
             if (t - nr).days >= 10:
                 overdue10 += 1
-        elif nr <= t + datetime.timedelta(days=7):
-            due_week.append(c["name"])
+        else:
+            # Scheduled later than today: nothing to do for it yet. Since
+            # 1.23.0 a correct before the due date holds the box, so a
+            # learner who only teaches sees no movement; this count is what
+            # /progress names so a flat dashboard reads as "waiting", not
+            # "stuck".
+            waiting += 1
+            if nr <= t + datetime.timedelta(days=7):
+                due_week.append(c["name"])
     finalize_module_rows(modules)
+    for name, row in modules.items():
+        row["evidenceKind"] = kind_of_module(name)
     return {"modules": modules, "rollup": rollup, "dueToday": due_today,
             "dueThisWeek": due_week, "parked": parked, "boxes": boxes,
-            "dueForCheck": due_check,
+            "dueForCheck": due_check, "waiting": waiting,
+            "unscheduled": unscheduled,
             "overdue10": overdue10, "unparseable": unparseable}
 
 
@@ -1405,6 +1551,7 @@
            "blockedOnFeynman": blocked_on_feynman(concepts),
            "blockedOnApplied": blocked_on_applied(concepts),
            "masteredDueForCheck": r["dueForCheck"]}
+    out["solidByReport"], out["solidBasis"] = solid_by_report(concepts)
     if r["parked"]:
         out["parked"] = r["parked"]
     emit(out)
@@ -1491,6 +1638,9 @@
     "1 review, 0% recall"). The gap for a concept's first review runs from
     its `introduced` date. `delayedSuccessRate` drops the same-day bucket,
     which is immediate post-instruction performance, not retention.
+    `byKind` and `byBasis` split the same counts by the concept's evidence
+    kind and by the entry's applied-work basis (`notApplied` without one).
+    A practice rep's entry is graded on its debrief, so it counts here.
     """
     def new_bucket():
         return {"correct": 0, "incorrect": 0, "partial": 0}
@@ -1503,7 +1653,16 @@
     self_reports = 0
     legacy_no_box = 0
     delayed = new_bucket()
+    by_kind, by_basis = {}, {}
+
+    def tally(groups, key, res, is_delayed):
+        g = groups.setdefault(key, {"all": new_bucket(), "delayed": new_bucket()})
+        g["all"][res] += 1
+        if is_delayed:
+            g["delayed"][res] += 1
+
     for c in data.get("concepts", []):
+        kind = effective_kind(c)
         # After a truncation the first retained gap runs from the last
         # archived review, not from `introduced` (review finding 6).
         prev = (parse_date(archived_summary(c).get("through"))
@@ -1523,14 +1682,18 @@
             if h.get("retry"):
                 relearning += 1
                 continue
+            is_delayed = False
             if prev is not None:
                 bucket = bucket_for_gap((d - prev).days)
                 if bucket:
                     by_gap[bucket][res] += 1
                     if bucket != "same-day":
                         delayed[res] += 1
+                        is_delayed = True
             prev = d
             totals[res] += 1
+            tally(by_kind, kind, res, is_delayed)
+            tally(by_basis, entry_basis(h) or "notApplied", res, is_delayed)
             bb = h.get("boxBefore")
             if isinstance(bb, int) and 1 <= bb <= MAX_BOX:
                 by_box[str(bb)][res] += 1
@@ -1542,6 +1705,12 @@
         out["reviews"] = n
         out["successRate"] = round(bucket["correct"] / n, 2) if n else None
         return out
+    def rates(g):
+        n, dn = sum(g["all"].values()), sum(g["delayed"].values())
+        return {"reviews": n,
+                "successRate": round(g["all"]["correct"] / n, 2) if n else None,
+                "delayedReviews": dn,
+                "delayedSuccessRate": round(g["delayed"]["correct"] / dn, 2) if dn else None}
     total_n = sum(totals.values())
     delayed_n = sum(delayed.values())
     return {
@@ -1556,6 +1725,9 @@
         "selfReportsExcluded": self_reports,
         "entriesWithoutBoxBefore": legacy_no_box,
         "entriesSkipped": skipped,
+        "byKind": {k: rates(by_kind[k]) for k in EVIDENCE_KINDS if k in by_kind},
+        "byBasis": {b: rates(by_basis[b]) for b in APPLIED_BASES + ("notApplied",)
+                    if b in by_basis},
     }
 
 
@@ -1577,7 +1749,23 @@
     feynman = 0
     mastered = 0
     applied = 0
+    # By kind and basis: counts only, keyed by vocabulary, never by a name.
+    by_kind, by_basis = {}, {}
+
+    def basis_row(basis):
+        return by_basis.setdefault(basis, {"appliedCorrects": 0, "solid": 0})
+
     for c in data.get("concepts", []):
+        row = by_kind.setdefault(effective_kind(c), {"concepts": 0, "applied": 0, "mastered": 0})
+        row["concepts"] += 1
+        row["applied"] += applied_evidence(c) >= 1
+        row["mastered"] += is_mastered(c)
+        for h in c.get("reviewHistory", []):
+            basis = applied_correct_basis(h) if isinstance(h, dict) else None
+            if basis:
+                basis_row(basis)["appliedCorrects"] += 1
+        if is_mastered(c):
+            basis_row(strongest_basis(c))["solid"] += 1
         b = c.get("box", 1)
         if isinstance(b, int) and 1 <= b <= MAX_BOX:
             boxes[str(b)] += 1
@@ -1609,6 +1797,8 @@
         "sessionTypeCounts": session_types,
         "retention": retention_summary(data),
         "calibration": calibration,
+        "byKind": {k: by_kind[k] for k in EVIDENCE_KINDS if k in by_kind},
+        "byBasis": {b: by_basis[b] for b in APPLIED_BASES if b in by_basis},
     }
     state = state_if_present(args.project)
     if state is not None:
@@ -1637,7 +1827,8 @@
         emit({"concept": args.concept, "tracked": False,
               "firstExposure": True, "pretestApplies": True,
               "isReteach": False, "dueForReview": False, "reviews": 0,
-              "currentModule": state.get("currentModule")})
+              "currentModule": state.get("currentModule"),
+              "evidenceKind": kind_of_module(state.get("currentModule"))})
         return
     history = [h for h in c.get("reviewHistory", []) if not h.get("deferred")]
     # First exposure: never classified by a v3 writer AND no real review has
@@ -1668,6 +1859,7 @@
         "dueForReview": nr is not None and nr <= t,
         "reviews": len(history) + (c.get("reviewHistoryArchived", 0) or 0),
         "currentModule": state.get("currentModule"),
+        "evidenceKind": effective_kind(c),
     })
 
 
@@ -1677,6 +1869,357 @@
     return out[:limit].rstrip("-") or "session"
 
 
+# --- syllabus (1.24.0) ------------------------------------------------------
+# The plan says the order; the review file says the evidence; state.json says
+# the position. No skill could join the three reliably in prose: /plan view
+# read every phase file and showed order with no performance, /progress
+# showed per-module tiers with no order (its modules come from the review
+# file), and "where am I and how did I do" needs both. One read-only call.
+
+PHASE_FILE_RE = re.compile(r"^phase-(\d+)\.md$")
+# `### Module 1.2 — name` is canonical; `### Module 7 — name` (one number,
+# counted across the course) is what the OpenAI build's /learn wrote in a
+# real session, and a plan the reader cannot see empties /plan, /progress and
+# /continue's position line. The id is the number(s) as written.
+MODULE_HEADING_RE = re.compile(r"^###\s+Module\s+(\d+)(?:\.(\d+))?\s*(?:[—–:-]+\s*)?(.*?)\s*$")
+PLAN_UNREADABLE = ("plan/ has phase files but no `### Module N.M — name` (or "
+                   "`### Module N — name`) headings; /plan, /progress and the "
+                   "position line read an empty plan")
+MODULE_LINE_RE = re.compile(
+    r"^\s*(?:[-*]\s+)?\*\*(Status|Target Bloom(?:'s)?(?: level)?|Concepts|Key terms?)\s*:?\*\*\s*:?\s*(.+?)\s*$",
+    re.IGNORECASE)
+MODULE_STATUS_WORDS = {"skipped": "skipped", "completed": "done", "done": "done",
+                       "complete": "done"}
+MODULE_STATUS_RE = re.compile(r"\b(skipped|completed|complete|done)\b", re.IGNORECASE)
+
+
+def norm_module_name(s):
+    """Join key for a module name: a `Module 1.2 — ` or `Module 2 — ` prefix
+    dropped, whitespace collapsed, case folded. Concept rows carry whatever
+    `--module` was passed, so the join tolerates the executor's spelling —
+    including a plan renumbered from `Module 2` to `Module 0.2` after rows
+    were written."""
+    if not isinstance(s, str):
+        return ""
+    stripped = re.sub(r"^\s*module\s+\d+(?:\.\d+)?\s*[—–:-]*\s*", "", s, flags=re.IGNORECASE)
+    if stripped.strip():
+        s = stripped
+    return re.sub(r"\s+", " ", s).strip().casefold()
+
+
+# --- Evidence-kind resolver -------------------------------------------------
+# The kind reaches the applied-work counters through this per-process table,
+# installed once by main() (one process serves one --project), not through a
+# parameter on every reader. Uninstalled, everything reads as code: the
+# strictest reading, since code admits only observed work.
+_KINDS = {"project": "code", "modules": {}}
+
+
+def read_kinds(project):
+    """(project kind, {normalized module name: kind}) from state.json. Never
+    fails a reader: a missing or unreadable file, or a kind outside
+    EVIDENCE_KINDS, reads as code (verify reports the bad value)."""
+    try:
+        with open(state_path(project), encoding="utf-8") as f:
+            state = json.load(f)
+    except (OSError, ValueError):
+        return "code", {}
+    if not isinstance(state, dict):
+        return "code", {}
+    kind = state.get("evidenceKind")
+    modules = state.get("moduleEvidenceKinds")
+    modules = modules if isinstance(modules, dict) else {}
+    return (kind if kind in EVIDENCE_KINDS else "code",
+            {norm_module_name(name): k if k in EVIDENCE_KINDS else "code"
+             for name, k in modules.items()})
+
+
+def install_kinds(project):
+    _KINDS["project"], _KINDS["modules"] = read_kinds(project)
+
+
+def kind_of_module(module):
+    return _KINDS["modules"].get(norm_module_name(module), _KINDS["project"])
+
+
+def effective_kind(c):
+    """A concept's evidence kind: its module's override, else the project's."""
+    return kind_of_module(c.get("module"))
+
+
+def applied_basis(h):
+    """How an applied entry's work was seen. Absent is `observed`; a value
+    outside APPLIED_BASES reads as `reported`, the strictest."""
+    b = h.get("appliedBasis")
+    if b is None:
+        return "observed"
+    return b if b in APPLIED_BASES else "reported"
+
+
+def admits(kind, basis):
+    """Whether applied work on `basis` counts toward the gate and Solid for a
+    concept of `kind`: observed work everywhere, unseen work only where the
+    tutor cannot see it."""
+    return basis == "observed" or kind in UNSEEN_BASIS_KINDS
+
+
+def _coerce_choice(x, choices):
+    """The lossless vocabulary repair: case and surrounding spaces."""
+    if isinstance(x, str) and x not in choices and x.strip().casefold() in choices:
+        return x.strip().casefold()
+    return None
+
+
+def parse_bloom_target(val):
+    """`3`, `3 (Apply)`, `Apply` → 3; anything else None."""
+    m = re.search(r"\b([1-6])\b", val)
+    if m:
+        return int(m.group(1))
+    low = val.casefold()
+    for lvl, label in BLOOM_LABELS.items():
+        if label and label.casefold() in low:
+            return lvl
+    return None
+
+
+def read_plan_modules(project):
+    """The plan's module order from plan/phase-*.md (state-schema KB *plan/*):
+    `### Module <N>.<M> — <name>` headings in phase-number order, with the
+    optional `**Status:**`, `**Target Bloom's:**`, `**Concepts:**` and
+    `**Key terms:**` lines of each section. Returns (phases, modules) or (None, []) with no plan/."""
+    pdir = os.path.join(project, ".bodhi", "plan")
+    if not os.path.isdir(pdir):
+        return None, []
+    files = []
+    try:
+        names = os.listdir(pdir)
+    except OSError:
+        names = []
+    for f in names:
+        m = PHASE_FILE_RE.match(f)
+        if m:
+            files.append((int(m.group(1)), f))
+    phases, modules = [], []
+    for n, f in sorted(files):
+        try:
+            # A plan is prose the learner pastes into; one Latin-1 byte must
+            # not take `snapshot` (and with it /continue) down. Replace, skip
+            # nothing readable.
+            with open(os.path.join(pdir, f), encoding="utf-8", errors="replace") as fh:
+                text = fh.read()
+        except OSError:
+            continue
+        title = next((ln[2:].strip() for ln in text.splitlines()
+                      if ln.startswith("# ")), f"Phase {n}")
+        cur, count, fenced = None, 0, False
+        for line in text.splitlines():
+            if line.lstrip().startswith("```"):
+                fenced = not fenced
+                continue
+            if fenced:
+                continue
+            m = MODULE_HEADING_RE.match(line)
+            if m:
+                mid = f"{m.group(1)}.{m.group(2)}" if m.group(2) else m.group(1)
+                cur = {"phase": n, "id": mid, "name": m.group(3) or f"Module {mid}",
+                       "file": f, "declaredStatus": None, "targetBloom": None,
+                       "plannedConcepts": [], "keyTerms": []}
+                modules.append(cur)
+                count += 1
+                continue
+            if line.startswith("## ") or line.startswith("# "):
+                cur = None
+            if cur is None:
+                continue
+            ml = MODULE_LINE_RE.match(line)
+            if not ml:
+                continue
+            key, val = ml.group(1).casefold(), ml.group(2)
+            if key == "status":
+                sw = MODULE_STATUS_RE.search(val)
+                cur["declaredStatus"] = MODULE_STATUS_WORDS.get(sw.group(1).casefold()) if sw else None
+            elif key.startswith("target bloom"):
+                cur["targetBloom"] = parse_bloom_target(val)
+            elif key == "concepts":
+                cur["plannedConcepts"] = [x.strip() for x in val.split(",") if x.strip()]
+            elif key.startswith("key term"):
+                cur["keyTerms"] = [x.strip(" `*") for x in val.split(",") if x.strip(" `*")]
+        phases.append({"phase": n, "title": title, "file": f, "modules": count})
+    return phases, modules
+
+
+def plan_position(state, plan):
+    """Index of the current module in the plan's order: state.json
+    currentModule by name or id, else currentModuleIndex, else None. The
+    second and third cases carry a warning. Shared by `syllabus` and
+    `snapshot` (whose `project.position` is what /continue's check-in
+    prints), so "Module 3 of 8" has one home."""
+    warnings = []
+    cur_name = norm_module_name(state.get("currentModule"))
+    cur_id = re.sub(r"(?i)^\s*module\s+", "", str(state.get("currentModule") or "")).strip()
+    cur_phase = str(state.get("currentPhase") or "").strip()
+    matches = [i for i, m in enumerate(plan)
+               if cur_name and (norm_module_name(m["name"]) == cur_name or m["id"] == cur_id)]
+    if matches:
+        # A spiral revisit may declare the same name in a later phase; the
+        # phase the state names breaks the tie, else the first occurrence.
+        in_phase = [i for i in matches if str(plan[i]["phase"]) == cur_phase]
+        return (in_phase or matches)[0], warnings
+    if plan:
+        idx = state.get("currentModuleIndex")
+        if isinstance(idx, str) and idx.strip().isdigit():
+            idx = int(idx)
+        if isinstance(idx, int) and not isinstance(idx, bool) and 0 <= idx < len(plan):
+            if cur_name:
+                warnings.append(f"state.json currentModule {state.get('currentModule')!r} "
+                                f"is not a plan module; position taken from "
+                                f"currentModuleIndex {idx}")
+            return idx, warnings
+        warnings.append("state.json names no plan module as current; every "
+                        "undeclared module reads as upcoming")
+    return None, warnings
+
+
+def position_row(plan, idx):
+    """The learner-facing position: 1-based index over all plan modules."""
+    if idx is None:
+        return None
+    return {"index": idx + 1, "of": len(plan),
+            "module": plan[idx]["name"], "phase": plan[idx]["phase"]}
+
+
+def summary_tier(tiers):
+    """The /progress rendering rule in code: a mixed module reads at its
+    lowest occupied tier above `unclassified`; all-unclassified is None."""
+    for key in ("introduced", "familiar", "mastered"):
+        if tiers.get(key, 0) > 0:
+            return key
+    return None
+
+
+def cmd_syllabus(args):
+    """Plan order × review evidence × state position, one read-only call.
+    Every module the plan declares, in order, with its status (declared
+    `skipped`/`done`, else `done`/`current`/`upcoming` from the position the
+    plugin already tracks), the review file's module row, the earliest next
+    review and today's due count. Modules on either side that the other side
+    does not know are reported, never dropped: `untracked` names plan modules
+    no concept was tracked under (not reached yet, or a spelling the review
+    file does not use); `unplanned` carries the rows of tracked modules the
+    plan does not declare, so no evidence disappears from a dashboard."""
+    state = state_if_present(args.project, {})
+    _, data = load_spaced_review(args.project, create=True)
+    t = today()
+    concepts = data.get("concepts", [])
+    warnings = []
+
+    phases, plan = read_plan_modules(args.project)
+    if phases is None:
+        warnings.append("no .bodhi/plan/ directory — a pre-1.7.0 monolithic "
+                        "plan.md is not read; /housekeep migrate converts it")
+        phases = []
+    elif not plan:
+        warnings.append(PLAN_UNREADABLE)
+
+    # Evidence per tracked module, by join key — the same tally `mastery`
+    # and `snapshot` use, re-keyed so "schema design" and "Schema Design"
+    # are one module here (the rollup keys by the raw spelling).
+    tracked = {}
+    for c in concepts:
+        raw = c.get("module", "(none)")
+        entry = tracked.setdefault(norm_module_name(raw),
+                                   {"module": raw, "aliases": [], "row": new_module_row(),
+                                    "nextDue": None, "dueToday": 0, "parked": 0})
+        if raw != entry["module"] and raw not in entry["aliases"]:
+            entry["aliases"].append(raw)
+        tally_module(entry["row"], c, t)
+        if c.get("parked") is True:
+            entry["parked"] += 1
+            continue
+        nr = parse_date(c.get("nextReview"))
+        if nr is None:
+            continue
+        if nr <= t:
+            entry["dueToday"] += 1
+        if entry["nextDue"] is None or nr < entry["nextDue"]:
+            entry["nextDue"] = nr
+    finalize_module_rows({k: e["row"] for k, e in tracked.items()})
+
+    def evidence(entry):
+        if entry is None:
+            return {"tracked": False, "concepts": 0, "classified": 0, "applied": 0,
+                    "mastered": 0, "masteredByReport": 0, "dueForCheck": 0, "masteryPct": None,
+                    "tiers": new_module_row()["tiers"], "summaryTier": None,
+                    "nextDue": None, "dueToday": 0, "parked": 0}
+        row = entry["row"]
+        out = {"tracked": True, "trackedAs": entry["module"]}
+        if entry["aliases"]:
+            out["trackedAlso"] = entry["aliases"]
+        out.update({k: row[k] for k in ("concepts", "classified", "applied", "mastered",
+                                        "masteredByReport", "dueForCheck", "masteryPct",
+                                        "tiers")})
+        out["summaryTier"] = summary_tier(row["tiers"])
+        out["nextDue"] = iso(entry["nextDue"]) if entry["nextDue"] else None
+        out["dueToday"] = entry["dueToday"]
+        out["parked"] = entry["parked"]
+        return out
+
+    cur_idx, pos_warnings = plan_position(state, plan)
+    warnings.extend(pos_warnings)
+
+    modules, matched_keys = [], set()
+    for i, m in enumerate(plan):
+        key = norm_module_name(m["name"])
+        entry = tracked.get(key) or tracked.get(m["id"])
+        if entry is not None:
+            matched_keys.add(norm_module_name(entry["module"]))
+        if m["declaredStatus"]:
+            status, source = m["declaredStatus"], "declared"
+        elif cur_idx is None:
+            status, source = "upcoming", "unknown-position"
+        elif i < cur_idx:
+            status, source = "done", "plan-order"
+        elif i == cur_idx:
+            status, source = "current", "plan-order"
+        else:
+            status, source = "upcoming", "plan-order"
+        row = {"index": i + 1, "phase": m["phase"], "id": m["id"], "name": m["name"],
+               "status": status, "statusSource": source,
+               "targetBloom": m["targetBloom"], "plannedConcepts": m["plannedConcepts"],
+               "keyTerms": m["keyTerms"], "file": m["file"]}
+        if m["targetBloom"] is not None:
+            tb = bloom_render(m["targetBloom"])
+            row["targetBloomLabel"] = tb["bloomLabel"]
+            row["targetBloomOutcome"] = tb["bloomOutcome"]
+        row["evidence"] = evidence(entry)
+        row["evidenceKind"] = kind_of_module(m["name"])
+        modules.append(row)
+
+    untracked = [m["name"] for m in modules if not m["evidence"]["tracked"]]
+    unplanned = [{"module": e["module"], **{k: v for k, v in evidence(e).items()
+                                            if k not in ("tracked", "trackedAs")},
+                  "evidenceKind": kind_of_module(e["module"])}
+                 for k, e in tracked.items() if k not in matched_keys]
+
+    emit({
+        "project": state.get("projectName"),
+        "evidenceKind": _KINDS["project"],
+        "plan": phases is not None and bool(plan),
+        "phases": phases,
+        "position": position_row(plan, cur_idx),
+        "currentPhase": state.get("currentPhase"),
+        "overallCompletion": state.get("overallCompletion", 0),
+        "counts": {"modules": len(plan),
+                   "done": sum(1 for m in modules if m["status"] == "done"),
+                   "skipped": sum(1 for m in modules if m["status"] == "skipped"),
+                   "upcoming": sum(1 for m in modules if m["status"] == "upcoming")},
+        "modules": modules,
+        "untracked": untracked,
+        "unplanned": unplanned,
+        "warnings": warnings,
+    })
+
+
 def cmd_revision_brief(args):
     """What today's revision sheet is about (1.18.0). Read-only.
 
@@ -1704,6 +2247,7 @@
             **bloom_render(c.get("bloomLevel", 0)),
             "question": c.get("question", ""),
             "feynmanPassed": c.get("feynmanPassed", False),
+            "evidenceKind": effective_kind(c),
         })
     # the sheet is named after the taught concept when there is one
     studied.sort(key=lambda d: (0 if "teach" in d["sourcesToday"] else 1,
@@ -1752,10 +2296,13 @@
     feynman = sum(1 for c in concepts if c.get("feynmanPassed") is True)
     classified = sum(1 for c in concepts if c.get("bloomLevel", 0) > 0)
     applied = sum(1 for c in concepts if applied_evidence(c) >= 1)
+    by_report, solid_basis = solid_by_report(concepts)
 
     calibration = calibration_summary(data)
     calibration.pop("overconfidentEvents", None)
     calibration.pop("underconfidentEvents", None)
+    _, plan = read_plan_modules(args.project)
+    plan_idx, _ = plan_position(state, plan)
 
     emit({
         "project": {
@@ -1765,10 +2312,14 @@
             "currentPhase": state.get("currentPhase"),
             "currentModule": state.get("currentModule"),
             "currentModuleIndex": state.get("currentModuleIndex"),
+            "position": position_row(plan, plan_idx),
             "lastActivity": state.get("lastActivity"),
             "overallCompletion": state.get("overallCompletion", 0),
             "initialBloomLevel": state.get("initialBloomLevel", {}),
             "currentBloomLevel": state.get("currentBloomLevel", {}),
+            "evidenceKind": _KINDS["project"],
+            # /continue proposes a kind once when none was ever recorded.
+            "evidenceKindRecorded": state.get("evidenceKind") in EVIDENCE_KINDS,
         },
         "cadence": {
             "totalSessions": state.get("totalSessions", 0),
@@ -1783,6 +2334,8 @@
             "dueToday": len(r["dueToday"]), "dueTodayConcepts": r["dueToday"],
             "dueThisWeek": len(r["dueThisWeek"]), "dueThisWeekConcepts": r["dueThisWeek"],
             "overdue10dPlus": r["overdue10"],
+            "waitingForReviewDay": r["waiting"],
+            "unscheduled": r["unscheduled"],
             "boxDistribution": r["boxes"],
             "retentionRollup": {k: len(v) for k, v in r["rollup"].items()},
             "retentionConcepts": r["rollup"],
@@ -1798,6 +2351,8 @@
             "blockedOnFeynman": blocked_on_feynman(concepts),
             "blockedOnApplied": blocked_on_applied(concepts),
             "masteredDueForCheck": r["dueForCheck"],
+            "solidByReport": by_report,
+            "solidBasis": solid_basis,
         },
         "calibration": calibration,
         "bloomScale": bloom_scale(),
@@ -1813,10 +2368,7 @@
     through any number of later misses. Deferred entries are scheduling
     notes, not observations, and are skipped; archived entries are carried
     by archivedSummary."""
-    seed = archived_summary(c)
-    return _evidence_counts(c.get("reviewHistory", []),
-                            seed.get("appliedEvidence", 0) or 0,
-                            seed.get("evidenceAt3Plus", 0) or 0)[1]
+    return _evidence_counts(c.get("reviewHistory", []), archived_summary(c))["at3plus"]
 
 
 EXPOSURE_RANK = {"seeded": 0, "quizzed-only": 1, "demonstrated": 2,
@@ -1828,22 +2380,49 @@
     return s if isinstance(s, dict) else {}
 
 
-def _evidence_counts(entries, applied=0, at3plus=0):
-    """(applied corrects, level-3+ corrects) since the most recent miss over
-    `entries`, continuing from the seeds — the one loop behind
-    applied_evidence, evidence_at_3_plus and archive_history."""
+def built_by_of(summary):
+    """The unseen bases archived work was built on (archivedSummary.builtBy)."""
+    b = summary.get("builtBy")
+    return [x for x in b if x in ("inspected", "reported")] if isinstance(b, list) else []
+
+
+# archivedSummary key that seeds each count (state-schema KB).
+ARCHIVE_SEEDS = {"observed": "appliedEvidence", "inspected": "appliedInspected",
+                 "reported": "appliedReported", "at3plus": "evidenceAt3Plus"}
+
+
+def entry_basis(h):
+    """The basis of an applied entry, else None: the one place the `applied`
+    flag is read for counting (t_single_applied_reader), so no reader can
+    count unseen work as observed."""
+    return applied_basis(h) if h.get("applied") is True else None
+
+
+def applied_correct_basis(h):
+    """The basis of an applied correct, else None."""
+    return entry_basis(h) if h.get("result") == "correct" else None
+
+
+def _evidence_counts(entries, seed):
+    """Applied corrects per basis and level-3+ corrects, since the most
+    recent miss over `entries`, continuing from an archivedSummary `seed` —
+    the one loop behind applied_evidence, evidence_at_3_plus and
+    archive_history. Raw counts: which bases a concept admits is the
+    reader's question, asked through admits()."""
+    counts = {k: seed.get(key, 0) or 0 for k, key in ARCHIVE_SEEDS.items()}
     for h in entries:
         if not isinstance(h, dict) or h.get("deferred"):
             continue
         result = h.get("result")
         if result == "incorrect":
-            applied = at3plus = 0
+            counts = dict.fromkeys(counts, 0)
         elif result == "correct":
-            if h.get("applied") is True:
-                applied += 1
+            basis = applied_correct_basis(h)
+            if basis:
+                counts[basis] += 1
             if (h.get("bloomLevel") or 0) >= 3:
-                at3plus += 1
-    return applied, at3plus
+                counts["at3plus"] += 1
+    return counts
 
 
 def archive_history(c, archived):
@@ -1853,9 +2432,8 @@
     zero applied evidence, and to measure the first retained gap from
     `introduced`). Accumulates across repeated truncations."""
     prev = archived_summary(c)
-    applied, at3plus = _evidence_counts(
-        archived, prev.get("appliedEvidence", 0) or 0, prev.get("evidenceAt3Plus", 0) or 0)
-    summary = {"appliedEvidence": applied, "evidenceAt3Plus": at3plus}
+    counts = _evidence_counts(archived, prev)
+    summary = {"appliedEvidence": counts["observed"], "evidenceAt3Plus": counts["at3plus"]}
     dates = [h.get("date") for h in archived
              if isinstance(h, dict) and parse_date(h.get("date"))]
     through = dates[-1] if dates else prev.get("through")
@@ -1870,30 +2448,54 @@
     # recomputed from the seeds, so only these two are worth carrying.
     graded = [h for h in archived if isinstance(h, dict) and not h.get("deferred")
               and h.get("result") in ("correct", "incorrect", "partial")]
+    # `built` is the floor observed work sets; work on an unseen basis is
+    # kept as builtBy, so a later kind change can still admit or refuse it.
     exposure = prev.get("exposure")
-    if any(h.get("applied") is True and h.get("result") == "correct" for h in graded):
+    bases = {applied_correct_basis(h) for h in graded}
+    if "observed" in bases:
         exposure = "built"
     elif exposure != "built" and any(h.get("source") in INSTRUCTIONAL_SOURCES for h in graded):
         exposure = "taught"
     if exposure in ("taught", "built"):
         summary["exposure"] = exposure
+    for basis in ("inspected", "reported"):
+        if counts[basis]:
+            summary[ARCHIVE_SEEDS[basis]] = counts[basis]
+    built_by = [b for b in ("inspected", "reported") if b in bases or b in built_by_of(prev)]
+    if built_by:
+        summary["builtBy"] = built_by
     c["reviewHistoryArchived"] = (c.get("reviewHistoryArchived", 0) or 0) + len(archived)
     c["archivedSummary"] = summary
 
 
 def applied_evidence(c):
-    """Correct results demonstrated in working code (`applied: true`) SINCE
-    THE LAST MISS, the same reset as evidence_at_3_plus. The level says how
-    well the learner can *talk about* a concept; this says whether they have
-    *built* with it. Every recorded level before 1.20.0 came from an
+    """Correct results demonstrated in applied work (`applied: true`: code
+    that ran, or a written application on a non-code topic) SINCE THE LAST
+    MISS, the same reset as evidence_at_3_plus. The level says how well the
+    learner can *talk about* a concept; this says whether they have *used* it. Every recorded level before 1.20.0 came from an
     explanation or a quiz answer, so the gate and the mastery formula could
     be satisfied without the learner ever writing a line: the learner
     finding that motivated the flag. Deferred entries are skipped; archived
     entries are carried by archivedSummary."""
-    seed = archived_summary(c)
-    return _evidence_counts(c.get("reviewHistory", []),
-                            seed.get("appliedEvidence", 0) or 0,
-                            seed.get("evidenceAt3Plus", 0) or 0)[0]
+    counts = _evidence_counts(c.get("reviewHistory", []), archived_summary(c))
+    kind = effective_kind(c)
+    return sum(counts[b] for b in APPLIED_BASES if admits(kind, b))
+
+
+def strongest_basis(c):
+    """The best-seen basis among the applied corrects this concept's kind
+    admits since the last miss — observed, then inspected, then reported —
+    or None. A Solid resting on `reported` is Solid by the learner's
+    account, and every surface that shows it says so."""
+    counts = _evidence_counts(c.get("reviewHistory", []), archived_summary(c))
+    kind = effective_kind(c)
+    return next((b for b in APPLIED_BASES if counts[b] and admits(kind, b)), None)
+
+
+def solid_by_report(concepts):
+    """(names Solid on the learner's word alone, {Solid name: strongest basis})."""
+    basis = {c["name"]: strongest_basis(c) for c in concepts if is_mastered(c)}
+    return [n for n, b in basis.items() if b == "reported"], basis
 
 
 def last_miss(c):
@@ -1953,11 +2555,13 @@
     graded = [h for h in c.get("reviewHistory", []) if isinstance(h, dict)
               and not h.get("deferred")
               and h.get("result") in ("correct", "incorrect", "partial")]
-    floor = archived_summary(c).get("exposure")
-    if floor == "built" or any(h.get("applied") is True and h.get("result") == "correct"
-                               for h in graded):
+    summary = archived_summary(c)
+    kind = effective_kind(c)
+    bases = [applied_correct_basis(h) for h in graded] + built_by_of(summary)
+    if summary.get("exposure") == "built" or any(b and admits(kind, b) for b in bases):
         return "built"
-    if floor == "taught" or any(h.get("source") in INSTRUCTIONAL_SOURCES for h in graded):
+    if summary.get("exposure") == "taught" or any(h.get("source") in INSTRUCTIONAL_SOURCES
+                                                  for h in graded):
         return "taught"
     if not graded and not c.get("reviewHistoryArchived"):
         return "seeded"
@@ -2035,7 +2639,7 @@
     # seeded module a continuation session before it was ever taught and
     # the gate never fired on the journey it exists for (review finding 2b).
     in_module = [c for c in concepts
-                 if c.get("module", "").strip().lower() == current.strip().lower()]
+                 if norm_module_name(c.get("module", "")) == norm_module_name(current)]
     started = [c for c in in_module if any(
         not h.get("deferred") and h.get("result") in ("correct", "incorrect", "partial")
         for h in c.get("reviewHistory", []) if isinstance(h, dict))]
@@ -2051,7 +2655,14 @@
         return
     seeded_only = len(in_module)
 
-    # First session on a new module: identify prerequisites.
+    # First session on a new module: identify prerequisites. A plan may
+    # declare `none` — a module that builds on nothing tracked. Read as a
+    # concept name it matched nothing and reported a vacuous "clear".
+    if args.prereqs and re.match(r"\s*none\b", args.prereqs, re.IGNORECASE):
+        emit({"fires": False,
+              "reason": "the plan declares no prerequisites for this module",
+              "currentModule": current, "prerequisiteSource": "declared"})
+        return
     if args.prereqs:
         names = [n.strip().lower() for n in args.prereqs.split(",") if n.strip()]
         prereqs = [c for c in concepts
@@ -2075,7 +2686,7 @@
                   "currentModule": current})
             return
         prereqs = [c for c in concepts
-                   if c.get("module", "").strip().lower() == str(prior).strip().lower()]
+                   if norm_module_name(c.get("module", "")) == norm_module_name(str(prior))]
         source = "prior-module"
 
     report = []
@@ -2086,6 +2697,7 @@
                        "box": c.get("box", 1), "lastReviewed": c.get("lastReviewed"),
                        "evidenceAt3Plus": evidence_at_3_plus(c),
                        "appliedEvidence": applied_evidence(c),
+                       "evidenceKind": effective_kind(c),
                        "status": status, "reason": reason})
     gaps = [r for r in report if r["status"] == "gap"]
     stale = [r for r in report if r["status"] == "stale-reconfirm"]
@@ -2226,6 +2838,14 @@
                 state[singular] = state.pop(plural)
                 changes.append(f"renamed {plural} -> {singular}")
                 state_changes += 1
+        kinds = state.get("moduleEvidenceKinds")
+        for holder, key in [(state, "evidenceKind")] + [
+                (kinds, name) for name in (kinds if isinstance(kinds, dict) else {})]:
+            fixed = _coerce_choice(holder.get(key), EVIDENCE_KINDS)
+            if fixed is not None:
+                changes.append(f"evidence kind {holder[key]!r} -> {fixed!r}")
+                holder[key] = fixed
+                state_changes += 1
 
     srp = sr_path(args.project)
     sr = load_json(srp) if os.path.exists(srp) else None
@@ -2286,6 +2906,7 @@
 def cmd_verify(args):
     """Schema sanity check. Used by dev/check.sh and the Stop hook."""
     errors, warnings = [], []
+    module_kinds, tracked_modules = {}, set()
     project = args.project
     bdir = os.path.join(project, ".bodhi")
     if not os.path.isdir(bdir):
@@ -2331,6 +2952,22 @@
             if isinstance(dates, list) and len(dates) != len(set(dates)):
                 warnings.append("state.json sessionDates has duplicates — "
                                 "run `bodhi-state normalize`")
+            # Evidence kinds: readers treat a bad value as code, so it is an
+            # error only here, where it can be seen.
+            kinds = state.get("moduleEvidenceKinds")
+            if kinds is not None and not isinstance(kinds, dict):
+                errors.append(f"state.json moduleEvidenceKinds is "
+                              f"{type(kinds).__name__}, expected an object of "
+                              f"module name -> kind")
+                kinds = None
+            module_kinds = kinds or {}
+            for label, k in [("evidenceKind", state.get("evidenceKind"))] + [
+                    (f"moduleEvidenceKinds {name!r}", k) for name, k in module_kinds.items()]:
+                if k is not None and k not in EVIDENCE_KINDS:
+                    fix = _coerce_choice(k, EVIDENCE_KINDS)
+                    errors.append(f"state.json {label} {k!r} not "
+                                  f"{'|'.join(EVIDENCE_KINDS)} — readers treat it as code"
+                                  + (" — run `bodhi-state normalize`" if fix else ""))
         except (json.JSONDecodeError, OSError) as e:
             errors.append(f"state.json unreadable: {e}")
         except Exception as e:  # drift the checks above did not anticipate
@@ -2392,6 +3029,8 @@
                     for k in ("bloomLevel", "feynmanPassed", "consecutiveCorrectAtL4Plus"):
                         if k not in c:
                             errors.append(f"concept {name!r} missing v3 field {k!r}")
+                if isinstance(c.get("module"), str):
+                    tracked_modules.add(c["module"])
                 rh = c.get("reviewHistory", [])
                 if not isinstance(rh, list):
                     rh = []
@@ -2402,6 +3041,11 @@
                         errors.append(shape_error_text(name, f"reviewHistory {field}",
                                                        actual, expected, repair)
                                       + ("" if repair is not None else " — fix it by hand"))
+                    if "appliedBasis" in h and h.get("applied") is not True:
+                        warnings.append(f"concept {name!r} reviewHistory "
+                                        f"{h.get('date')!r} has appliedBasis "
+                                        f"{h['appliedBasis']!r} without applied: "
+                                        f"true — the basis is ignored")
                     if h.get("date") is not None and parse_date(h.get("date")) is None:
                         warnings.append(f"concept {name!r} reviewHistory date "
                                         f"{h.get('date')!r} is not an ISO date — "
@@ -2440,6 +3084,30 @@
         warnings.append("spaced-review.json missing while state.json exists — "
                         "the review schedule may have been deleted")
 
+    # Phase files nothing can parse: syllabus would read an empty plan.
+    phases, plan = read_plan_modules(project)
+    if phases and not plan:
+        warnings.append(PLAN_UNREADABLE)
+
+    # A module override joins on the normalized module name. Neither case
+    # below can be repaired by a subcommand, so neither blocks the Stop hook.
+    overridden = {norm_module_name(name) for name in module_kinds}
+    known = {norm_module_name(m["name"]) for m in plan} | {
+        norm_module_name(raw) for raw in tracked_modules}
+    for name in module_kinds:
+        if norm_module_name(name) not in known:
+            warnings.append(f"state.json moduleEvidenceKinds {name!r} matches no plan "
+                            f"module and no tracked concept (a renamed module?) — its "
+                            f"kind reaches nothing; record it under the current name")
+    by_id = {m["id"]: m for m in plan}
+    for raw in sorted(tracked_modules):
+        m = by_id.get(norm_module_name(raw))
+        if m and norm_module_name(raw) not in overridden \
+                and norm_module_name(m["name"]) in overridden:
+            warnings.append(f"concepts filed under plan id {raw!r} do not get module "
+                            f"{m['name']!r}'s evidence kind — the kind joins on the "
+                            f"module name")
+
     pp = find_profile(project)
     if pp:
         try:
@@ -2503,7 +3171,8 @@
 
 READ_ONLY_COMMANDS = {cmd_due, cmd_mastery, cmd_calibration, cmd_retention,
                       cmd_export_anonymized, cmd_session_brief, cmd_snapshot,
-                      cmd_gate_check, cmd_verify, cmd_revision_brief}
+                      cmd_gate_check, cmd_verify, cmd_revision_brief,
+                      cmd_syllabus}
 
 def main():
     p = argparse.ArgumentParser(prog="bodhi-state", description=__doc__,
@@ -2532,10 +3201,17 @@
     s.add_argument("--question", default="")
     s.add_argument("--note", default=None, help="short lastResult note")
     s.add_argument("--source", default=None, help="which skill produced this review")
-    s.add_argument("--applied", action="store_true",
-                   help="the outcome was demonstrated in working code the tutor "
-                        "read (exercise, driven piece), not an explanation or "
-                        "quiz answer; feeds the gate and the mastery formula")
+    s.add_argument("--applied", nargs="?", const="observed", default=None,
+                   choices=APPLIED_BASES,
+                   help="the outcome was demonstrated in applied work, not an "
+                        "explanation or quiz answer. Bare = observed: work the "
+                        "tutor read (code that ran; off code, a saved file, with "
+                        "--evidence). inspected (a photo the tutor examined) and "
+                        "reported (the learner's word) only on a performed "
+                        "concept. Feeds the gate and the mastery formula")
+    s.add_argument("--evidence", default=None,
+                   help="project-relative path of the applied work; required for "
+                        "observed work off code, beside the exercise's key")
     s.add_argument("--retry", action="store_true",
                    help="successive-relearning retry: history entry only, no "
                         "box/counter/bloom movement (the original demotion stands)")
@@ -2596,6 +3272,17 @@
     s.add_argument("--completion", type=int, default=None)
     s.set_defaults(fn=cmd_touch_state)
 
+    s = sub.add_parser("set-evidence-kind",
+                       help="record the project's evidence kind, or one module's "
+                            "(state.json only; every review is kept)")
+    s.add_argument("--kind", default=None, help="|".join(EVIDENCE_KINDS))
+    s.add_argument("--module", default=None,
+                   help="a plan module's name or id, or a tracked module; omit for the project")
+    s.add_argument("--clear", action="store_true",
+                   help="remove the kind: the project reads as code, a module "
+                        "takes the project's")
+    s.set_defaults(fn=cmd_set_evidence_kind)
+
     s = sub.add_parser("profile-add-project",
                        help="append a schema-complete activeProjects entry "
                             "(creates .bodhi-profile.projects.json if missing)")
@@ -2669,6 +3356,10 @@
                        help="single-call dashboard rollup for /progress: position, cadence, due, mastery, calibration (read-only)")
     s.set_defaults(fn=cmd_snapshot)
 
+    s = sub.add_parser("syllabus",
+                       help="plan order × review evidence × position: every plan module in order with status and module evidence (read-only)")
+    s.set_defaults(fn=cmd_syllabus)
+
     s = sub.add_parser("revision-brief",
                        help="today's studied concepts + the revision sheet file to write (read-only)")
     s.set_defaults(fn=cmd_revision_brief)
@@ -2698,6 +3389,7 @@
     profile = find_profile(args.project)
     if profile:
         acquire_lock(os.path.dirname(profile), shared=shared)
+    install_kinds(args.project)
     args.fn(args)