@antoneeo/course-creator 0.1.0-beta.1 → 0.1.0-beta.10

package/skills/course-creator/scripts/sdlc_core.py

@@ -89,6 +89,14 @@ ARCHITECT_PASS_EPOCH = "2026-07-28"
 # row. Same grandfathering discipline as the pass above -- never nag work that
 # predates the rule.
 DESIGN_REVIEW_EPOCH = "2026-07-28"
+# Chronology (F-073): an L3 ANALYSIS started, or an L3 HANDOFF updated, on/after
+# this date is read for undated Diary text and a multi-step `next:`. Advisories,
+# like the two gates above: a fixed epoch cannot protect a late upgrader, so a
+# warning here would redden --strict CI on work written before the upgrade.
+CHRONOLOGY_EPOCH = "2026-10-18"
+NEXT_MAX_CHARS = 240        # this repository's longest `next:` was 214 at the epoch
+ID_SCAN_MAX_REFS = 300      # A3 is skipped above it (one advisory says so, T9)
+ID_SCAN_REFS_PER_CALL = 50  # keeps one git command line far below 32k chars
 def review_log_rel():
     return f"{docs_dir()}/audit/reviews/REVIEW_LOG.md"
 # Component Map 'Where' refs: a dotted token counts as a path only with one of
@@ -834,6 +842,10 @@ def build_registry(root):
         return ""
     stamp = max(str(m.get("updated") or m.get("since") or "").strip() or "0000-00-00"
                 for _p, m in rows)
+    return _render_registry(root, rows, stamp)
+
+
+def _render_registry(root, rows, stamp):
     lines = ["# Handoff — workstream registry",
              f"Date: {stamp} (UTC)",
              "",
@@ -867,6 +879,35 @@ def parse_registry_rows(text):
     return ids
 
 
+def is_generated_registry(text):
+    # "Ours" = written by ANY family entry point: the header is WRITTEN with
+    # entry_script(), so recognition must not hard-code one distribution's
+    # script name (a registry generated by mkt_check.py is just as generated).
+    return bool(re.search(r"GENERATED by \S+ index - do not edit by hand", text))
+
+
+def generated_registry_rows(text):
+    """Workstream rows of a generated registry, ignoring the project notes
+    (free text that may carry tables of its own)."""
+    return parse_registry_rows(text.split("\n## Project-wide notes", 1)[0])
+
+
+def build_empty_registry(root, existing):
+    """The generated registry once the last source is gone (F1, found by F-068).
+
+    Only for a registry that is already ours: a hand-written handoff with no
+    sources is a project that never converted, and stays untouched. The Date is
+    kept while the view is already empty -- re-running index on a clean tree
+    must not change it -- and becomes today's when rows are being dropped:
+    there is no source left whose `updated:` could date the closure."""
+    m = re.search(r"Date:\s*(\d{4}-\d{2}-\d{2})", existing)
+    if m and not generated_registry_rows(existing):
+        stamp = m.group(1)
+    else:
+        stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    return _render_registry(root, [], stamp)
+
+
 def registry_conversion_blockers(root):
     """What stops `index` from writing over a hand-written handoff.md.
 
@@ -879,10 +920,7 @@ def registry_conversion_blockers(root):
     if not hand.is_file():
         return []
     text = read_text(hand)
-    # "Already ours" = written by ANY family entry point: the header is WRITTEN
-    # with entry_script(), so recognition must not hard-code one distribution's
-    # script name (a registry generated by mkt_check.py is just as generated).
-    if re.search(r"GENERATED by \S+ index - do not edit by hand", text):
+    if is_generated_registry(text):
         return []
     blockers = []
     known = {str(m.get("workstream")).strip() for _p, m in list_workstreams(root)}
@@ -1015,10 +1053,21 @@ def cmd_index(root):
 def rc_registry(root):
     """Write the generated workstream registry, or refuse and say why (F-028)."""
     ws = list_workstreams(root)
+    hand = ai_path(root, "audit", "handoff.md")
     if not ws:
-        return 0                # no sources: a hand-written handoff is untouched
+        # No sources: a hand-written handoff is untouched; a generated one is
+        # emptied, or the last closed workstream would stay listed forever.
+        if not hand.is_file():
+            return 0
+        existing = read_text(hand)
+        if not is_generated_registry(existing):
+            return 0
+        empty = build_empty_registry(root, existing)
+        if norm_text(existing) != norm_text(empty):
+            hand.write_text(empty, encoding="utf-8")
+            print(f"[ok] workstream registry emptied (no open workstreams): {hand}")
+        return 0
     blockers = registry_conversion_blockers(root)
-    hand = ai_path(root, "audit", "handoff.md")
     if blockers:
         print(f"[ERROR] {docs_dir()}/audit/handoff.md NOT regenerated -- it still holds "
               "state no source accounts for:")
@@ -1060,6 +1109,298 @@ def section_body(text, aliases):
     return None
 
 
+def section_lines(text, aliases):
+    """(heading_line, body) for the first matching `## ` section, or None: the
+    body NOT stripped, so body line n is file line heading_line + n, and an
+    indented first line keeps its indentation. The readers below use it; a
+    stripped body would shift every line number and move `  - DATE` to column 0."""
+    lines = (text or "").splitlines()
+    for i, line in enumerate(lines):
+        if any(line.startswith(a) for a in aliases):
+            body = []
+            for nxt in lines[i + 1:]:
+                if nxt.startswith("## "):
+                    break
+                body.append(nxt)
+            return i + 1, "\n".join(body)
+    return None
+
+
+# ---------------------------------------------------------------- chronology
+# One grammar for a dated entry (F-073), read by the validator and by any
+# consumer that lists events (F-072's chronology): both call these readers, so
+# they cannot disagree on what an event is. The readers return openers only --
+# date, label, line -- and format nothing for display.
+
+DIARY_SECTION = next(s for s in ANALYSIS_SECTIONS if s[0] == "## Diary")
+_ISO = r"\d{4}-\d{2}-\d{2}"
+# At column 0: optional list marker, optional `###`/`####`, optional bold, then
+# the ISO date and a word boundary. The date FIRST is the rule; markup is
+# tolerated so the dated forms already written stay readable with no migration.
+ENTRY_OPENER = re.compile(r"^(?:([-*]) |(#{3,4}) )?(\*\*)?(" + _ISO + r")\b(.*)$")
+_LABEL_SEP = re.compile(r"^(?:\*\*)?\s*(?:[—–:-])?\s*")
+_REQUEST_HEADING = re.compile(r"^### (R\d+) [—–-] (" + _ISO + r") [—–-] (.+)$")
+_ADR_BODY_DATE = re.compile(r"^\**Date:\**\s*(" + _ISO + r")\b", re.M)
+_ADR_NAME_DATE = re.compile(r"^ADR_(" + _ISO + r")_", re.I)
+UNIT_ID_RE = re.compile(r"\b([A-Z]-\d{3,})\b")
+
+
+def _entry_label(bold, rest):
+    rest = _LABEL_SEP.sub("", rest, count=1)
+    if bold and "**" in rest:
+        rest = rest.split("**", 1)[0]
+    else:
+        rest = re.split(r"(?<=[.!?])\s", rest, maxsplit=1)[0]
+    return rest.strip(" .:—–-*")[:120]
+
+
+def _opener_at(lines, i):
+    """The match when lines[i] opens an entry. It must also START A BLOCK -- the
+    line above is blank, absent or a heading, or the line is itself a list item
+    or a heading -- so a hard-wrapped prose line that happens to begin with a
+    date is never an event. (A separator after the date is NOT required: real
+    openers read `DATE (qualifier)` and `DATE word`.)"""
+    m = ENTRY_OPENER.match(lines[i])
+    if not m:
+        return None
+    prev = lines[i - 1] if i else ""
+    if not prev.strip() or prev.startswith("#") or m.group(1) or m.group(2):
+        return m
+    return None
+
+
+def entry_openers(body):
+    """[(date, label, line)] -- one per dated entry opener; line is 1-based
+    within `body`. An undated paragraph belongs to the entry above it. Comments
+    are blanked first, exactly as `undated_diary_lines` does, so an entry
+    written under the template's comment is an event to both."""
+    lines = _blank_comments(body).splitlines()
+    out = []
+    for i in range(len(lines)):
+        m = _opener_at(lines, i)
+        if m:
+            out.append((m.group(4), _entry_label(m.group(3), m.group(5)), i + 1))
+    return out
+
+
+def _blank_comments(text):
+    # comments become blank lines, so line numbers still point at the file's lines
+    return re.sub(r"<!--.*?-->", lambda m: "\n" * m.group(0).count("\n"), text or "",
+                  flags=re.S)
+
+
+def undated_diary_lines(body):
+    """[(line, text)] a Diary body cannot date: text before the first opener,
+    and any `### ` heading that is not an opener. `####` and deeper headings are
+    sub-structure of an entry and stay legal. Comments are ignored."""
+    lines = _blank_comments(body).splitlines()
+    out, seen_opener = [], False
+    for i, line in enumerate(lines):
+        if _opener_at(lines, i):
+            seen_opener = True
+        elif line.startswith("### "):
+            out.append((i + 1, line.strip()))
+        elif not seen_opener and line.strip():
+            out.append((i + 1, line.strip()))
+    return out
+
+
+def request_entries(text):
+    """(entries, unparsed) for a request record: entries are
+    [(rid, date, label, line)]; a `### ` heading that does not match
+    `### R<n> — YYYY-MM-DD — <label>` is returned in unparsed as (line, text),
+    never dropped."""
+    entries, unparsed = [], []
+    for i, line in enumerate((text or "").splitlines()):
+        if not line.startswith("### "):
+            continue
+        m = _REQUEST_HEADING.match(line.rstrip())
+        if m:
+            entries.append((m.group(1), m.group(2), m.group(3).strip(), i + 1))
+        else:
+            unparsed.append((i + 1, line.rstrip()))
+    return entries, unparsed
+
+
+def adr_date(name, text):
+    """An ADR's date: `**Date:** YYYY-MM-DD` in the body, else the
+    `ADR_YYYY-MM-DD_*` file name, else None."""
+    m = _ADR_BODY_DATE.search(text or "") or _ADR_NAME_DATE.match(name or "")
+    return m.group(1) if m else None
+
+
+def _meta_date(meta, key):
+    return parse_iso(str(meta.get(key) or "").strip().strip("'\"")[:10])
+
+
+def chronology_advisories(root):
+    """A1 (undated Diary text) and A2 (`next:` is not one step), as advisory
+    strings. Gated on `level: L3` and on a date the file carries -- never an
+    mtime -- so L1/L2 work and anything written before the epoch see nothing."""
+    epoch = parse_iso(CHRONOLOGY_EPOCH)
+    out = []
+    for p, meta, text in list_analyses(root):
+        started = _meta_date(meta, "start_date")
+        if str(meta.get("level", "")).upper() != "L3" or not started or started < epoch:
+            continue
+        section = section_lines(text, DIARY_SECTION)
+        if section is None:
+            continue
+        head, body = section
+        rel = "solutions/" + p.name
+        lines = undated_diary_lines(body)
+        preface = [(n, t) for n, t in lines if not t.startswith("### ")]
+        if preface:
+            out.append(f"{rel}: line {head + preface[0][0]}: Diary text '{preface[0][1][:60]}' "
+                       "comes before the first dated entry -- open entries with "
+                       "**YYYY-MM-DD — label.**, and write the current state as the latest "
+                       "dated entry")
+        for n, t in lines:
+            if t.startswith("### "):
+                out.append(f"{rel}: line {head + n}: Diary heading '{t[:60]}' is not a dated "
+                           "entry -- open entries with **YYYY-MM-DD — label.**")
+    for p, meta in list_workstreams(root):
+        updated = _meta_date(meta, "updated")
+        if str(meta.get("level", "")).upper() != "L3" or not updated or updated < epoch:
+            continue
+        nxt = str(meta.get("next") or "").strip()
+        if len(nxt) > NEXT_MAX_CHARS:
+            out.append(f"audit/{p.name}: next: is {len(nxt)} chars (> {NEXT_MAX_CHARS}): one "
+                       "next step here, the state goes to the Diary as a dated entry")
+    return out
+
+
+def _open_units(root):
+    """{id: {analysis name}} for the tree's open L3 units: an L3 ANALYSIS that is
+    PLANNED or IN_PROGRESS, or a request record (L3 only, r26) whose `analysis:`
+    is absent from the tree or names such an open ANALYSIS. A closed unit's
+    record, kept forever, does not count."""
+    units, present, open_names = {}, set(), set()
+    for p, meta, _ in list_analyses(root):
+        present.add(p.name)
+        if (str(meta.get("level", "")).upper() == "L3"
+                and meta.get("status") in ("PLANNED", "IN_PROGRESS")):
+            m = UNIT_ID_RE.search(str(meta.get("id") or ""))
+            if m:
+                open_names.add(p.name)
+                units.setdefault(m.group(1), set()).add(p.name)
+    req = ai_path(root, "audit", "requests")
+    if req.is_dir():
+        for p in sorted(req.glob("REQUEST_*.md")):
+            meta = load_frontmatter(read_text(p).splitlines())
+            name = str(meta.get("analysis") or "").strip().strip("'\"`")
+            m = UNIT_ID_RE.search(str(meta.get("unit") or meta.get("id") or ""))
+            if m and name and (name not in present or name in open_names):
+                units.setdefault(m.group(1), set()).add(name)
+    return units
+
+
+def _git_out(root, *args, timeout=30):
+    r = subprocess.run(["git", *args], cwd=str(root), capture_output=True, text=True,
+                       encoding="utf-8", errors="replace", timeout=timeout)
+    return r.stdout if r.returncode == 0 else None
+
+
+def ids_on_other_refs(root, max_refs=ID_SCAN_MAX_REFS):
+    """[(id, mine, theirs, [refs])] -- an open unit's id that another ref (heads,
+    remotes, tags) uses for a DIFFERENT analysis. Identity is the ANALYSIS file
+    name, declared by the ANALYSIS or announced by a request record's
+    `analysis:`. One `git grep` over local refs, fixed arguments only (T8);
+    as fresh as the last fetch. [] with no open L3 unit or no git; None when
+    skipped -- above `max_refs` refs, or git failed or timed out -- so the
+    caller can say the check did not run instead of reporting it clean."""
+    mine = _open_units(root)
+    if not mine or not git_available(root):
+        return []
+    try:
+        head = (_git_out(root, "rev-parse", "HEAD") or "").strip()
+        listing = _git_out(root, "for-each-ref",
+                           "--format=%(objectname) %(objecttype) %(*objecttype) %(refname)",
+                           "refs/heads", "refs/remotes", "refs/tags")
+        if listing is None:
+            return None
+        refs = []
+        for line in listing.split("\n"):
+            parts = line.split(" ")
+            if len(parts) == 3:                     # %(*objecttype) empty: not a tag
+                parts.insert(2, "")
+            if len(parts) != 4:
+                continue
+            sha, kind, peeled, ref = parts
+            # only refs that resolve to a commit can be grepped (a tag on a blob
+            # would fail the whole batch); the tree's own commit is not "another
+            # ref"; symbolic HEADs repeat a branch
+            if "commit" not in (kind, peeled) or ref.endswith("/HEAD") or sha == head:
+                continue
+            refs.append(ref)
+        if not refs:
+            return []
+        if len(refs) > max_refs:
+            return None
+        # Pathspecs are relative to cwd=root, so a docs root inside a monorepo
+        # subdirectory is found. -z keeps a path with ':' or non-ASCII intact
+        # (quotePath off); -n plus the fence lines confine hits to frontmatter.
+        docs = docs_dir()
+        chunks = []
+        for i in range(0, len(refs), ID_SCAN_REFS_PER_CALL):   # command-line length
+            r = subprocess.run(
+                ["git", "-c", "core.quotePath=false", "grep", "-z", "-n", "-I", "-E",
+                 r"^(id|unit|analysis):|^---\s*$", *refs[i:i + ID_SCAN_REFS_PER_CALL],
+                 "--", f"{docs}/solutions/ANALYSIS_*.md", f"{docs}/audit/requests/REQUEST_*.md"],
+                cwd=str(root), capture_output=True, text=True, encoding="utf-8",
+                errors="replace", timeout=60)
+            if r.returncode not in (0, 1):                     # 1 = no match
+                return None
+            chunks.append(r.stdout)
+    except Exception:
+        return None
+    per = {}
+    for line in "".join(chunks).split("\n"):     # not splitlines: \x1c.. are content
+        parts = line.split("\0")
+        if len(parts) != 3 or ":" not in parts[0] or not parts[1].isdigit():
+            continue
+        ref, path = parts[0].split(":", 1)          # a ref name cannot hold ':'
+        content = parts[2].rstrip("\r")
+        st = per.setdefault((ref, path), {"fences": 0, "kv": {}})
+        if int(parts[1]) == 1 and content.strip() == "---":
+            st["fences"] = 1                        # frontmatter opens on line 1
+        elif st["fences"] == 1 and content.strip() == "---":
+            st["fences"] = 2                        # ...and closes here
+        elif st["fences"] == 1:
+            key, _, val = content.partition(":")
+            st["kv"].setdefault(key, val.strip())
+    found = {}
+    for (ref, path), st in per.items():
+        kv = st["kv"]
+        fname = path.replace("\\", "/").rsplit("/", 1)[-1]
+        name = fname if fname.startswith("ANALYSIS_") else kv.get("analysis", "").strip("'\"`")
+        m = UNIT_ID_RE.search(kv.get("id") or kv.get("unit") or "")
+        if not (m and name) or m.group(1) not in mine or name in mine[m.group(1)]:
+            continue
+        short = re.sub(r"^refs/(heads|remotes|tags)/", "", ref)
+        found.setdefault((m.group(1), name), [])
+        if short not in found[(m.group(1), name)]:
+            found[(m.group(1), name)].append(short)
+    return sorted((fid, ", ".join(sorted(mine[fid])), theirs, sorted(refs_))
+                  for (fid, theirs), refs_ in found.items())
+
+
+def id_advisories(root):
+    """A3 as advisory strings, for every entry point's `check`."""
+    hits = ids_on_other_refs(root)
+    if hits is None:
+        return [f"id check skipped (more than {ID_SCAN_MAX_REFS} refs, or git grep failed "
+                "or timed out) -- choose a new unit's id after fetching, as the first id "
+                "free on every ref"]
+    out = []
+    for fid, mine, theirs, refs in hits:
+        more = f" (+{len(refs) - 1} more)" if len(refs) > 1 else ""
+        out.append(f"id {fid} ({mine}) is also used by {theirs} on {refs[0]}{more}: choose "
+                   "the first id free on every ref -- if this is the same unit under its "
+                   "old name, ignore it")
+    return out
+
+
 def design_review_due(meta):
     """True when an L3 ANALYSIS owes a design-review row (review.md moment 1):
     implementation has started or finished, and it began on/after the gate
@@ -1354,10 +1695,10 @@ def cmd_validate(root, strict=False, hybrid=False):
                               "doing the work it triggers")
         # comment-stripped, anchored: a '<!-- TODO: the ## Capability Ledger -->'
         # must not read as the section being present
-        # Hybrid: the design lives in devPNT and its §4.5 gate owns this slot
-        # (the Hybrid ownership matrix: "run ONE of them, never both"), and its log
-        # rows are keyed on e_isp_/e_tdd_ doc_keys, not on this filename -- so
-        # firing here would be a permanent, unfixable false positive.
+        # Hybrid: the design lives in devPNT, and the agent review of it (the
+        # same review.md review, run before the proposal) logs a row keyed on
+        # its e_isp_/e_tdd_ doc_key, not on this filename -- so firing here
+        # would be a permanent, unfixable false positive.
         if not hybrid and design_review_due(meta) and not review_logged(root, p.name):
             advisories.append(f"{rel}: L3 in implementation with no design-review row in "
                               f"{review_log_rel()} -- the design was reviewed by nobody but its "
@@ -1496,6 +1837,12 @@ def cmd_validate(root, strict=False, hybrid=False):
                                 "workstream — decide which file owns it")
             else:
                 seen[wid] = p.name
+    elif hand.is_file():
+        text = read_text(hand)
+        if is_generated_registry(text) and generated_registry_rows(text):
+            errors.append(f"{docs_dir()}/audit/handoff.md lists workstreams no HANDOFF_*.md "
+                          "source exists for any more: run 'sdlc_check.py index' to drop "
+                          "the closed rows")
     if hand.is_file():
         m = re.search(r"(?:Date|Data):\s*(\d{4}-\d{2}-\d{2})", read_text(hand))
         if not m:
@@ -1509,6 +1856,7 @@ def cmd_validate(root, strict=False, hybrid=False):
             except ValueError:
                 warnings.append("audit/handoff.md: date not parseable")
 
+    advisories.extend(chronology_advisories(root))   # A1, A2 (F-073)
     for a in advisories:
         print(f"[note]  {a}")
     for w in warnings:
@@ -1869,15 +2217,30 @@ def print_orient_hook_note(root):
         pass  # detection must never break check
 
 
-def cmd_check(root, strict=False, hybrid=False):
+def cmd_check(root, strict=False, hybrid=False, extra_validate=None, extra_sections=()):
+    """An overlay adds its checks through the two hooks, never after the call:
+    the summary line is the verdict, so every check that can fail runs before
+    it. `extra_validate()` folds into the validate stage; each
+    (title, fn) in `extra_sections` gets its own banner and summary rc."""
     print("===== validate =====")
     rc_v = cmd_validate(root, strict=strict, hybrid=hybrid)
+    if extra_validate is not None:
+        rc_v = max(rc_v, extra_validate())
+    # A3 (F-073): check only -- it reads git refs, and validate stays file-local.
+    # Advisory: printed, never part of any rc.
+    for a in id_advisories(root):
+        print(f"[note]  {a}")
     print("\n===== stale =====")
     rc_s = cmd_stale(root, hybrid=hybrid)
-    print(f"\ncheck: {'CLEAN' if not (rc_v or rc_s) else 'NOT CLEAN'} "
-          f"(validate rc={rc_v}, stale rc={rc_s})")
+    rcs = [("validate", rc_v), ("stale", rc_s)]
+    for title, fn in extra_sections:
+        print(f"\n===== {title} =====")
+        rcs.append((title, fn()))
+    failed = any(rc for _, rc in rcs)
+    print(f"\ncheck: {'NOT CLEAN' if failed else 'CLEAN'} "
+          f"({', '.join(f'{title} rc={rc}' for title, rc in rcs)})")
     print_orient_hook_note(root)
-    return 1 if (rc_v or rc_s) else 0
+    return 1 if failed else 0
 
 
 # --------------------------------------------------------------------- gate
@@ -2235,6 +2598,13 @@ def _is_pass(verdict):
     return re.search(r"\bPASS\b", (verdict or "").upper()) is not None
 
 
+def _is_not_due(verdict):
+    """A review ruled not due (review.md, a delta that only restates judged
+    work): logged so a skip stays visible, but it is neither a review nor a
+    finding, so it stays out of every count below (F-071)."""
+    return (verdict or "").strip().upper().startswith("NOT DUE")
+
+
 def _print_read_cost():
     """The cost side, printed with the benefit and NEVER without it: a catch
     rate with no cost term justifies unbounded doctrine, and a cost term with
@@ -2275,6 +2645,8 @@ def cmd_benefit(root):
         _print_read_cost()
         return 0
     rows, unparsed = parse_review_log(read_text(log))
+    not_due = [r for r in rows if _is_not_due(r["verdict"])]
+    rows = [r for r in rows if not _is_not_due(r["verdict"])]
     # `tier` carries the MOMENT in Standalone (design / closure) and the
     # reviewer WEIGHT in Hybrid (deep / light / code / guide / vision). A
     # Hybrid row is a real review whose moment this column does not state, so
@@ -2299,9 +2671,11 @@ def cmd_benefit(root):
                     unstated_code += n
     classified = moments["design"] + moments["closure"]
     print("rows parsed: %d   rows unparsed: %d%s"
-          % (len(rows), len(unparsed),
+          % (len(rows) + len(not_due), len(unparsed),
              ("  -> " + "; ".join("line %d: %s" % u for u in unparsed[:5]))
              if unparsed else ""))
+    print("reviews ruled not due (logged, counted in no figure below): %d"
+          % len(not_due))
     print("reviews with a stated moment: %d   moment not stated by `tier`: %d%s"
           % (len(classified), sum(unstated.values()),
              ("  (" + ", ".join("%s x%d" % (t, n) for t, n

package/skills/course-creator/scripts/shared_files.py

@@ -51,8 +51,16 @@ SHARED_FILES = (
     "scripts/test_plan.py",
     "scripts/test_drift.py",
     "scripts/test_migrate.py",
+    "scripts/test_chronology.py",
     "scripts/test_merge_safety.py",
     "scripts/test_audit_refs.py",
+    # the docs site (F-072): generator, its battery and its page
+    "scripts/docs_site.py",
+    "scripts/test_docs_site.py",
+    "docs_site/index.html",
+    "docs_site/app.js",
+    "docs_site/style.css",
+    "docs_site/strings.js",
     # domain-neutral doctrine
     "review.md",
     "routing.md",

package/skills/course-creator/scripts/shared_manifest.json

@@ -1,27 +1,34 @@
-{
-  "_comment": "Generated by shared_files.py --update. IDENTICAL in every distribution of the family: if two copies of this file differ, the spine has diverged. Never edit by hand.",
-  "files": {
-    "LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
-    "NOTICE": "8414f424f7c1db19d89d74286fd2d6b1acdd9eedde910fa57a16d6835602e4bd",
-    "dispatch.md": "febdfdda36405438b6bde6e95ed38ea7bc2c6639d557ef435fb9411432e868f7",
-    "guides.md": "651c150ad3014edbbbc1908dfdca2404db2a877e3d0cbf5cc7921d9be31c187f",
-    "memory.md": "5907be5f99b18eb66ffda2c25815f4fa266fff4b3767f4c142d601b146271167",
-    "review.md": "ea86123d1dace3e9e55b6c2c5f149f2e43818e1e552779a68a77100a2c8563df",
-    "routing.md": "2f90556cb8516599b9fd6ebf0b5f61dffc107ff186a4c14aed0e483b82cf91d2",
-    "scripts/entry_point.py": "4a560d4d41db989d3426182f1b24270cbb934b3db0f3246c700578a4ed93089b",
-    "scripts/knowledge.py": "a1be56e7ad55d53bd221cf47e21dd398d9c0643cf62666067ba54feee5d4c8de",
-    "scripts/sdlc_core.py": "c9a8f3dc6ebe5363c20ee6183f6f78241c3aa45ba3d9ec6bd9c515395c586e51",
-    "scripts/shared_files.py": "e0d48e3dd2fe4cb11c11c2e6f874908e6211451403e6d0cac7af583c4d4fd467",
-    "scripts/test_audit_refs.py": "a6f06e73f4c9469dd64bed283024b6b37294e6c26f171d8cbdbdfd03771a6884",
-    "scripts/test_docs_root.py": "19753e0316c0df63ed321d24b411a9ff36eea2058421fd69fc57e507d75566d0",
-    "scripts/test_domain_rules.py": "33542b5dc2bb77c05ece55cf0446065cc4226c763ef5e040aa77364f226937bb",
-    "scripts/test_drift.py": "c7b7121a8a308b0f3fe12c0c0c346444e632b7aaeff47dc8818b621e5c20cb38",
-    "scripts/test_merge_safety.py": "ed52bed751386e47fd680942c2315f1a1fcc83206a9e2146acc40fff6967ccf4",
-    "scripts/test_migrate.py": "c129823bf4feb0614acd975351632a6ae62d7896a0ef32724419a8e9335e3110",
-    "scripts/test_plan.py": "4c011a63aa834b55e9c5d13fb4ea76b131b742356001364b0a508435ba013e27",
-    "scripts/test_project_memory.py": "4f3c463a7a52c5a0d3ff88dc71dcbe7ebc9b5add69ada5948365d204054df36d",
-    "scripts/test_session_start.py": "203fa72b87fb263663ce7fcd737460530b75fd5e76e883f25cd849e6cca98275",
-    "scripts/test_skill_invariants.py": "efbfdb4b0e272ba97de41bbab046a0de437d75cbc67316c605b03314b61fa3e9",
-    "vision.md": "191696a8283b2873fea6e57d16fbb3b4f24b82bf0c79bcfd77d52141a9ca2a5b"
-  }
-}
+{
+  "_comment": "Generated by shared_files.py --update. IDENTICAL in every distribution of the family: if two copies of this file differ, the spine has diverged. Never edit by hand.",
+  "files": {
+    "LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+    "NOTICE": "8414f424f7c1db19d89d74286fd2d6b1acdd9eedde910fa57a16d6835602e4bd",
+    "dispatch.md": "d127057198415f81b921c74e3234a47d5794a2af662eeadaf3dff3cc1739ebc8",
+    "docs_site/app.js": "52236c7904ba4628ae21410b6f41983d4608c99ef9e3f5cf285f2000ebfe4d77",
+    "docs_site/index.html": "2b64167470f754e46fa4bb4e73a3d2c34ee632d91fe2f17705a58d18b5018af5",
+    "docs_site/strings.js": "6f8720c156396bc6553b41a706502d6cbb59b1417c0ba5e5fb6d0f55f480abbb",
+    "docs_site/style.css": "851c0ff7c75efdcc481add7dae225fb6f83f03dcb5449f446e0d61bbfe4cb7e7",
+    "guides.md": "651c150ad3014edbbbc1908dfdca2404db2a877e3d0cbf5cc7921d9be31c187f",
+    "memory.md": "5907be5f99b18eb66ffda2c25815f4fa266fff4b3767f4c142d601b146271167",
+    "review.md": "c94618c02e34823ef29cb8d90d7288764dc3c72dc136905c8516e226385aa463",
+    "routing.md": "2f90556cb8516599b9fd6ebf0b5f61dffc107ff186a4c14aed0e483b82cf91d2",
+    "scripts/docs_site.py": "cc542da4b5702f986d89c6af06b15423c9a0d03168611caf3796a6eb850a9b93",
+    "scripts/entry_point.py": "4a560d4d41db989d3426182f1b24270cbb934b3db0f3246c700578a4ed93089b",
+    "scripts/knowledge.py": "ac50bffcbfd9c7d7c098e4a40995f66f18884202a5511d602961c9dcd9afa498",
+    "scripts/sdlc_core.py": "b66b10956685a31203b9f757e0c2d88c8f30e4fc9447ced14108627aafd668e5",
+    "scripts/shared_files.py": "bc3b311ca5c736070e9970428429226ca0a9186e010c265b556512b6df191e73",
+    "scripts/test_audit_refs.py": "a6f06e73f4c9469dd64bed283024b6b37294e6c26f171d8cbdbdfd03771a6884",
+    "scripts/test_chronology.py": "5cffc2711282452fe1148a95e46b0b31940809aed3a63950329d9b3e868d0cda",
+    "scripts/test_docs_root.py": "19753e0316c0df63ed321d24b411a9ff36eea2058421fd69fc57e507d75566d0",
+    "scripts/test_docs_site.py": "8ccfcdb638c5fcc1a557fd150c02840e91aa3d93df57963b97dbcaf882177965",
+    "scripts/test_domain_rules.py": "33542b5dc2bb77c05ece55cf0446065cc4226c763ef5e040aa77364f226937bb",
+    "scripts/test_drift.py": "c7b7121a8a308b0f3fe12c0c0c346444e632b7aaeff47dc8818b621e5c20cb38",
+    "scripts/test_merge_safety.py": "8b9241077bf7ecd6dd335907c640044ab38968ff4c9fdc464450e732cb77adf4",
+    "scripts/test_migrate.py": "c129823bf4feb0614acd975351632a6ae62d7896a0ef32724419a8e9335e3110",
+    "scripts/test_plan.py": "4c011a63aa834b55e9c5d13fb4ea76b131b742356001364b0a508435ba013e27",
+    "scripts/test_project_memory.py": "2cb85cef01161d881a11d84cfe9ebb72915104e8d1822e4de739f7d00ae6cd59",
+    "scripts/test_session_start.py": "203fa72b87fb263663ce7fcd737460530b75fd5e76e883f25cd849e6cca98275",
+    "scripts/test_skill_invariants.py": "17dbccaac688b75e04c44eaaf0ee5b78e85ce2aa4697fc7a52041f3175fe0735",
+    "vision.md": "a19a7d7d5044215b726b66f74e422c9cdedcc856c0a53151f20a6d9840b8f6c4"
+  }
+}