cjm-context-graph-projection

Projection and navigation core for context graphs: bounded, ranked, provenance-carrying reads (schema / state / relevance / show) over any cjm-substrate context graph, with a CLI driver. The agent-facing read layer of the self-hosting graph arc.

Modules

• cjm_context_graph_projection.__init__
• cjm_context_graph_projection.aboutpage — The ABOUT PAGE: the author's identity, background and how the site is made -- never an offer
• cjm_context_graph_projection.agentlayer — The post page's AGENT LAYER (design 39c51c15 (7), amendment 23a49667, under the redesign build
• cjm_context_graph_projection.archive — Retiring an archive source, restoring it from git, and moving a page's path between holders
• cjm_context_graph_projection.artifacts — Observed-source ARTIFACTS (design 9a7224a7, work item 4765b699): files the graph VERSIONS
• cjm_context_graph_projection.authoring — The B write surface: AUTHOR a verbatim-text slot on-graph, emit the canonical artifact.
• cjm_context_graph_projection.bench — THE SCALE HARNESS: synthetic tiers of a graph and its journals, the canonical verbs run at each.
• cjm_context_graph_projection.categories — A post's CATEGORIES: the one reader every renderer calls (design ce17606b (1) under the category
• cjm_context_graph_projection.categorypages — CATEGORY PAGES (design a62f2499 under the category model 0f7fcdcb (5), work item 779c7a79).
• cjm_context_graph_projection.claims — The claims the site may make about the user's work, and the deliverables that back them
• cjm_context_graph_projection.cli — The cjm-context-graph CLI — first driver of the projection core.
• cjm_context_graph_projection.code_edges — Orphaned code-target edge detector: journaled links whose endpoint no longer resolves.
• cjm_context_graph_projection.codefold — The code lane as a FOLD over the source journal (design amendment 2cc81d3b to 8f6f2343).
• cjm_context_graph_projection.codesource — The code lane's ELEMENT regime: a captured module's source is its element records (design abfc2829,
• cjm_context_graph_projection.cohesion — Module cohesion audit over the code graph — the read-only cohesion ORACLE (N+1).
• cjm_context_graph_projection.comments — The post page's comments (design 39c51c15 (1), rulings 98d33f9e (2) + 86f4a34d, under the
• cjm_context_graph_projection.conceptjudge — The concept judge (ruling ad37f62a (2), under design amendment 25a58e0e (6) and the path model ae698640).
• cjm_context_graph_projection.conceptreview — The concept reviews (ruling ad37f62a (1), (2)): the vocabulary the drafts propose, and the
• cjm_context_graph_projection.config — Graph-sibling config discovery — the DEFAULT_* hardcodes retired to DATA
• cjm_context_graph_projection.contradictions — The standing dedup query: slots whose ACTIVE assertions disagree.
• cjm_context_graph_projection.conventions — Structural convention audit over the code/notebook graph (the enforcement nbdev lacks).
• cjm_context_graph_projection.coverage — The Tutorials matrix: its vocabulary as graph data and the task x stage projection
• cjm_context_graph_projection.derivedblocks — Derived blocks leave the RENDER; the post navigation replaces them (design 253ac996, amendment
• cjm_context_graph_projection.devgraph — Build the dev graph's nodes + edges from its sources (the dev-graph DRIVER).
• cjm_context_graph_projection.display — Graph-carried display rules: the presentation vocabulary (DEC 16bcd96e).
• cjm_context_graph_projection.evidence — The evidence (design 7f315830; build fbf7fc0e): traffic as dated, sourced observations on a URL
• cjm_context_graph_projection.explorer_page — The graph EXPLORER client page — the first client of the serve data API.
• cjm_context_graph_projection.facetjudge — The facet judge (design eefda2dd under the category model 0f7fcdcb and amendment 3c5cff97).
• cjm_context_graph_projection.facetreview — The facet review and the public build's facet gate (design eefda2dd (5), (7)).
• cjm_context_graph_projection.factlayer — Shared fine-tier reads over the fact-layering schema (slots + assertions).
• cjm_context_graph_projection.filing — Filing reconciler: propose PART_OF program anchors for unfiled work items.
• cjm_context_graph_projection.gitfold — Ingested sources' times from git history (design amendment 19edbe97 to 8f6f2343; leg C 7ddcea72).
• cjm_context_graph_projection.homepage — The HOME PAGE: a projected map of the site under its role and what it holds (design e55201e2,
• cjm_context_graph_projection.hybrid_page — The HYBRID graph explorer client — GPU physics canvas + DOM overlay (check-in 1233ab46).
• cjm_context_graph_projection.inbound — The inbound links (design 7f315830 (6), ruling a3c02fb1): who links the site, observed twice --
• cjm_context_graph_projection.journal — The write journal: the durable, replayable source of truth for born-on-graph writes.
• cjm_context_graph_projection.judgeengine — The judge verb family's shared engine (design eefda2dd (8), capture e0b6f945 condition 1).
• cjm_context_graph_projection.judging — Judged related posts (design e09e262b, answering ruling 98d33f9e (1); the spike 245fb5b3).
• cjm_context_graph_projection.lens — Lenses: graph-carried, parameterized views (DEC f1b02b95 — tier 2 of the
• cjm_context_graph_projection.library — The Library's provenance (design 5de7fae9, design leg 4a4ef27e).
• cjm_context_graph_projection.librarypage — The Library's pages: the index a Lens with the library view layout projects, and a work page
• cjm_context_graph_projection.linkaudit — Link liveness audit — the derived worklist for the EXTERNAL links a note carries
• cjm_context_graph_projection.listing — Structured enumeration: every node of a LABEL / assertion of a PREDICATE / edge of a RELATION.
• cjm_context_graph_projection.memorysource — The memory notes on the element source unit (design c9b29de5, work item 40a35288).
• cjm_context_graph_projection.module_ops — Module-edit ops — create / rename / delete / regroup a module as graph edge ops.
• cjm_context_graph_projection.notes_outline — The OUTLINE PASS of the notes lane — the first of the standalone lecture resource's passes
• cjm_context_graph_projection.notes_place — The PLACEMENT PASS of the notes lane — the second of the standalone lecture resource's
• cjm_context_graph_projection.notesource — The archive's graph-sourced cutover: the notes source journal and its fold (work item 79703485;
• cjm_context_graph_projection.onboarding — Project the MEMORY onboarding surface from the graph's ASSERTED lead structure.
• cjm_context_graph_projection.oracle — The version oracle: a programmatic Procedure that keeps version slots fresh.
• cjm_context_graph_projection.paths — The path model (design ae698640, the walk 57287d1b, the refactor leg ad9bef5a): artifacts,
• cjm_context_graph_projection.perf — THE INSTRUMENT's projection half: one timing event per CLI invocation, and the perf read.
• cjm_context_graph_projection.postpage — The post page's projected parts (the post page of de808eae (2); its rest designed as 39c51c15
• cjm_context_graph_projection.projection — The projection core: schema / show / relevance / state over a context graph.
• cjm_context_graph_projection.propose — Triage proposals: an agent DRAFTS the update for a stale deliverable (work item bb015d12).
• cjm_context_graph_projection.prose_refs — Prose-ref drift: id-shaped tokens in asserted prose vs the edge layer.
• cjm_context_graph_projection.pull_transcript — The transcript pull verb: harness-transcript messages onto the session spine.
• cjm_context_graph_projection.purenotes — The pure-notes lane (ruling a7262fe7; work item fdafeed9): a typed deliverable whose
• cjm_context_graph_projection.readiness — The readiness frontier: which work-items are READY vs BLOCKED — derived, never stored.
• cjm_context_graph_projection.readme — README-as-projection (v1, STRUCTURAL-ONLY): generate a repo's README FROM THE GRAPH.
• cjm_context_graph_projection.reads — The content-access READS ledger: which nodes each read delivered into context.
• cjm_context_graph_projection.rebuilddiff — A live graph against its own rebuild, property for property (design 8f6f2343, finding fbce0173).
• cjm_context_graph_projection.reconcile — M2b shadow-phase RECONCILE — surface + (explicitly) absorb out-of-band .md edits.
• cjm_context_graph_projection.refactor — Refactoring-candidate identification over the code graph (the IDENTIFY half of move).
• cjm_context_graph_projection.refactor_ops — move — relocate a symbol between modules (the EXECUTE half of refactor-candidates).
• cjm_context_graph_projection.registers — Register drift-check: each hub note's member-cache vs the active role assertions.
• cjm_context_graph_projection.relive — The LIVE half of the code fold (design amendment 2cc81d3b, build B2 of leg B 0e3508fd).
• cjm_context_graph_projection.relocate — The relocation of removed pages into repositories (design 3d5ee659 for the relocation item
• cjm_context_graph_projection.rename_ops — Symbol rename — the Ext-B increment: scoped identifier substitution INTO bodies.
• cjm_context_graph_projection.render — Render projection results for a consumer: agent (JSON) or human (markdown).
• cjm_context_graph_projection.review — The review frontier: which APPROVED deliverables have stale upstream — derived, never stored.
• cjm_context_graph_projection.rolereview — The role review (ruling 6a203252; design ad9bef5a (4), amendment 25a58e0e (3)-(4)).
• cjm_context_graph_projection.runtime — Open a context graph for reading/writing (domain-neutral runtime wiring).
• cjm_context_graph_projection.scratchpad_export — Scratchpad session .md exporter — the projection lens (increment iv of the
• cjm_context_graph_projection.sectionroles — Section roles (design ad9bef5a (1), amendment 25a58e0e (2)-(4), ruling 6a203252).
• cjm_context_graph_projection.seeds — Hand-seeded load-bearing slots + the rename-stable repo-key machinery.
• cjm_context_graph_projection.series — Series born on-graph: the node, its membership and its ORDER as journaled intent
• cjm_context_graph_projection.serve — A served, read-only graph EXPLORER data API over the read verbs — the richer-viz INSTRUMENT.
• cjm_context_graph_projection.sessioncost — session-cost: what one session's graph work cost, DERIVED — never stored (work item
• cjm_context_graph_projection.site — The public site's BUILD: one verb, run where the graph is (ruling 941f7f13; DEC 98293e72 (2)).
• cjm_context_graph_projection.sitefeeds — The site's FEEDS, written by the build after the render (design 0efb5497 (3b) under the web
• cjm_context_graph_projection.sitelinks — In-body site links, RESOLVED through site_path facts (DEC 72d669c5 (1); the step, 9ee4e346).
• cjm_context_graph_projection.sitelisting — The site's PROJECTED LISTING: one component for every listing (design 0efb5497 + amendment
• cjm_context_graph_projection.sitepages — The site's PROJECTED pages: every series page from its Series, every topic page from its Lens
• cjm_context_graph_projection.sitetheme — The site's THEME, projected from the design system its profile is bound to (leg C of the
• cjm_context_graph_projection.source_state — The code SOURCE journal's write side: every live module's source is its element records
• cjm_context_graph_projection.sourcemoves — Which rows a moved source accounts for (design amendment a9176261 to 19edbe97 (6)).
• cjm_context_graph_projection.sources — The post page's sources (design 39c51c15 (3), amendment 722a8232, under the redesign build
• cjm_context_graph_projection.standing — A page's STANDING (design amendment cbd5f154 to the disposition pass 9a21e345, amended by
• cjm_context_graph_projection.structure — M2a GRADIENT — structural memory authoring: create a note / add a section, born on-graph.
• cjm_context_graph_projection.tutorialspage — The Tutorials page: a Lens whose view layout is coverage-matrix projects the task x stage
• cjm_context_graph_projection.viz — A minimal READ-ONLY visualization: the readiness frontier + its dependency DAG, as HTML.
• cjm_context_graph_projection.workbench — Workbench lens layer: the front-door / pin-tree / session-feed derived views.
• cjm_context_graph_projection.worklist — The propose/confirm worklist: candidate fixes that need a human decision.
• cjm_context_graph_projection.write — The write surface: assert a slot value, decide a conclusion.
• cjm_context_graph_projection.writes — THE WRITE ORDER ON A PROJECTION GRAPH: plan -> append -> apply -> advance (design detail

API

cjm_context_graph_projection.aboutpage

• about_body function
• background_ref function — The background: the one ref of the selection's one subgraph clause. Any other shape
• body_of function
• load_author_extras function
• load_portrait function — The displayed portrait (site-author.portrait, 2fba772c (4)): a derivative of the photo,
• load_site_config function
• plan_about_page function — Plan the About page: the opening, the portrait, the background under its approval, the

cjm_context_graph_projection.agentlayer

• agent_plan function — The agent layer's plan: each licensed post's JSON-LD and llms.txt. A page's title and
• based_on function — What the post draws on, as structured data (design 37f82f72 (5)): a work typed by its form,
• build_lines function — What the build knows and the author never types: how the links work, the licenses from the
• check_jsonld function — After the render: every planned post page carries exactly one JSON-LD object, equal to the
• check_llms_fragments function — After the anchors (design b82d2a98 (2)), failing closed: every fragment a .llms.md links
• directory_author function — The page's author as Quarto merges it: its own front matter, else the nearest directory's
• jsonld_script function
• llms_index function — llms.txt (amendment 23a49667 (2), 465ab923): the author's intro, the build's own lines,
• llms_path function
• load_index_copy function — llms.txt's intro copy: the summary is the site's one sentence (site-summary, amendment
• map_outside_code function — The ONE walker of the markdown layer's code regions (design b82d2a98 (3)), shared by the
• plain function — A description in llms.txt or JSON-LD is text: the page's link is the only link there, and a
• post_jsonld function — A post's structured data (39c51c15 (7), amendment 23a49667 (4)): a draft has no
• profile_jsonld function — The About page's ProfilePage, its Person the site author (design ff0c6338 (8)): the name and
• read_jsonld function
• restore_llms_anchors function — The markdown layer carries the ids its page carries (design b82d2a98 (1)): each anchor
• rewrite_llms_links function — Keep an agent in the markdown layer (amendment 23a49667 (3)): every internal link in a
• rewrite_markdown_links function — Rewrite each link target resolve maps, outside fenced code and inline code spans.
• state_category_links function — The markdown layer STATES a category, never links the category listing's filtered view
• write_llms_txt function — Write llms.txt over Quarto's flat list -- only when every link names a .llms.md the

cjm_context_graph_projection.archive

• archive_round_trip function — THE ROUND-TRIP INVARIANT, the archive cutover's gate (design 56c9c332; work item f86be52f).
• git_blob function
• git_head function
• is_retired function — A retired node is never listed, linked to or rendered, under any profile.
• path_owners function — The page each site_path value now belongs to: follow the supersession chain UP from the
• restore_retired function — Rebuild each retired archive source from git, under its original path and slug. A missing
• retire_source function — Retire an archive source (journaled retire-source). LIVE, the source must be committed
• retired_sources function — What the ingest restores before replay: every archive source a retire op names.
• transfer_site_path function — Move a page's ACTIVE site_path to another node (journaled transfer-path): the target

cjm_context_graph_projection.artifacts

• ArtifactFold class — The artifact lane folded over the source journal: one node per live artifact identity,
• ArtifactKind class — One kind of observed artifact: where its files sit, how a file reads canonically (and
• append_artifact function — Append an artifact record, skipping a capture identical to the key's latest state.
• append_artifact_retire function — Append an artifact-retire record ending a key's life.
• apply_artifacts_live function — THE SAME FOLD a rebuild runs, committed in place: artifact nodes the fold no longer
• artifact_check function — Every live artifact against its file: DRIFT = the file's canonical text is not the
• capture_artifact function — Capture the file's current version (validated, canonical) or retire its key, then the
• fold_artifacts function
• latest_artifact_ops function — The LATEST capture per live key (last record wins; a retire ends the key).
• uncaptured_artifacts function — Every file a kind's pattern matches, in every on-graph repo, that no record holds.

cjm_context_graph_projection.authoring

• add_symbol function — Mint a NEW top-level CodeSymbol into a module, then emit its canonical artifact.
• add_text function — Mint a NEW CodeText region (imports/constants/docstring/__all__) into a module, then emit.
• author function — Author a node's verbatim-text slot, then emit its canonical artifact to disk.
• emit_artifact function — Emit a container's canonical artifact FROM THE GRAPH (graph -> .py / .md).
• emit_post function — Emit a born post to the PUBLIC website clone — GATED on publish_state=published.
• file_section_raws function — Each of a note's sections' raw span as the FILE currently decomposes (the other
• graph_section_raws function — Each of a note's sections' on-graph raw span, keyed by anchor (the divergence/
• note_approval function — A born Note's approval, the one reading every public consumer of a born Note shares
• read_node function — Deliver a node's verbatim CONTENT — the read DUAL of author/emit.
• read_slot function — Read a node's current verbatim-slot text (the --editor pop / preview input).
• reharvest_note_relations function — Re-run the relationship harvest on an EDITED note and apply the edge DIFF (finding cbde404c).
• section_divergence function — Read-only: detect, at SECTION grain, where a note's .md has drifted from the graph.

cjm_context_graph_projection.bench

• BenchRefusal class — A harness precondition failed (no bench directory, a path outside it, a missing lane).
• VisibilityProbe class — 7v's reader (ruling 110c662f (2), design detail 2c4bad75 (4)): ONE read-only connection to
• assemble_tier function — Build tier xK: a fresh db holding the snapshot's rows plus copies 1 .. k-1 (plain row
• bench_config function — The harness's settings as DATA; bench_dir has no default (a path on one machine is
• build function — Snapshot (once), stage the copies the tiers need (missing or from another snapshot, in
• compose_steps function — A COMPOSED role's steps (ruling 110c662f (6), design detail 2c4bad75 (2)): RECORDED op
• env_python function — The interpreter of the env an app runs in (design detail 4389a579: a gesture driver runs
• extract_ingest_workload function — A recorded session's transcript INGEST as a workload (design detail 2c4bad75 (3)): its
• extract_workload function — A recorded session as a WORKLOAD (design detail 2f5033bf (2)): its reads-ledger requests
• family_ops function — Ops in a tier's family as it stands: the cold segments counted at assembly (immutable),
• inside function — The path guard (design detail 3bd8673d (3)): every write resolves inside the bench.
• invert_request function — A recorded request back to its argv by the verb's OWN parser (design detail 2f5033bf (2)):
• lane_dir function — The lane's directory under the bench directory, refused if the lane's own graph or
• load function — THE CONCURRENT REPLAY MODE (design detail 2f5033bf (2)): at each tier, clients replay
• load_settings function — The concurrent replay mode's settings as DATA: the bench config's load object.
• measure function — Run one invocation under the limits: its peak RSS is the process tree's (the graph
• memory_ceiling_kb function — The machine guard (design detail 2f5033bf (2)): a load must never push the machine into
• placeholders_of function — The default targets of the canonical verbs, read off the snapshot once.
• rekeyer function — The copy's id map, applied to any value: a string has every UUID token replaced by
• render_bench function — Render a bench result: tables for a person, the result as JSON for an agent.
• resolve_lane function — A lane: the graph a tier copies and the journal families beside it. The invoking graph
• roster function — A named load's CLIENTS (ruling 110c662f (1), design detail 2c4bad75 (1) / (2)): its role
• run function — Run the canonical verbs against each tier: real CLI invocations with the tier's db,
• snapshot function — Copy 0: the live db through SQLite's backup API (a consistent snapshot under a live
• stage_copy function — Re-key copy copy of the snapshot once: its rows (nodes, edges -- no indexes, the
• status function — What the bench holds for a lane: the snapshot, the staged copies, the built tiers.
• tree_rss_kb function — The tree's resident set, read from /proc (statm + each task's children). An invocation's
• verb_parser function — One verb's subparser, read off the parser's subcommands.
• verb_specs function — The canonical verbs for a lane: the configured verbs replace the default list (the

cjm_context_graph_projection.categories

• chip_vocab function — Each live facet entry's chip text and its place in the chip order.
• load_post_categories function — Every post's chips from the graph (a post with none is absent), each chip's place in the
• majority function — A collection page's chips (design ce17606b (4)): what most of it is about -- the
• post_chips function

cjm_context_graph_projection.categorypages

• category_page_min function — The index Lens's active category_page_min (a62f2499 (3)): one positive integer.
• category_slug function
• describe_categories function — The description verb (amendment e38d403c (5)): the document, or one landed review -- the
• description_basis function
• description_criteria function
• description_document function
• description_stale function
• description_state function — Every category page the PUBLIC build earns, in the index's order, with the posts it lists
• entry_record function
• index_body function
• index_hubs function — The category pages the index links, in its order (the home page's map entry, 5c3c2662 (5)).
• parse_descriptions function — Each section's entry, basis and description (whitespace collapsed to single spaces). A
• plan_category_pages function — Plan the category index and every category page, and the redirect stub of every entry
• plan_category_paths function — The site_path each live facet entry should hold (a62f2499 (1)): /categories/<slug>/,
• plan_descriptions function — Check every section against the graph (a live facet entry, its record unchanged since the

cjm_context_graph_projection.claims

• claims_report function — The claims over the live graph: every claim Entity with its state and its CURRENT backing
• load_claim_states function — Every claim's active state(s); more than one is a conflict the report refuses.
• load_claims function — The claim Entities in display order.
• load_supports function — The support edges (deliverable -> claim) with their kind and note.
• project_claims function — The pure projection (no graph access): see the module docstring for the rules.
• public_view function — The public profile's filter (676bac8e (4)): building and retired claims, and supports
• record_support function — Write one SUPPORTS edge with its kind (journaled supports), or retract it. A pair has

cjm_context_graph_projection.cli

• build_parser function — The CLI's parser, built once per invocation -- factored out of main so the scale
• main function
• render function — The read-delivery seam: tap the reads ledger, then delegate to the real

cjm_context_graph_projection.code_edges

• classify_orphaned_links function — Pure: the journaled links the next replay will silently drop.
• orphaned_edges function — The derived orphan report over journal link ops + the current graph.

cjm_context_graph_projection.codefold

• CodeFold class — The projected code corpus as a fold over source-journal records (see module docstring).
• fold_source_journal function — Fold every record of the source journal, in append order (the rebuild's code lane).

cjm_context_graph_projection.codesource

• CodeSourceError class — A captured module whose element state does not compose, or does not decompose back to itself.
• ElementFold class — The element records folded to state: modules, elements, every id a record has named.
• ElementState class — A journaled element's content and placement.
• LatestSources class — latest_source_ops' answer over both regimes: (repo_key, module_path) -> the module's latest
• ModuleState class — A journaled module's own state.
• SourceState class — The code source journal folded over BOTH regimes: the latest snapshot per key, the phase-2
• absorb_records function — A write to a captured module, at element grain (abfc2829 (7)): the new text is lifted into
• capture_records function — The records that capture one module into the element regime, and what the capture changes:
• derive_captured function — A captured module's nodes and local edges, every node keyed by its element id (see the module
• element_canonical function

cjm_context_graph_projection.cohesion

• cohesion function — Audit module cohesion: grab-bag (under_split) + scattered-helper (over_split) candidates.
• compute_cohesion function — Compute module cohesion candidates from the code graph slices (pure).

cjm_context_graph_projection.comments

• apply_harvest function — Land one harvest: each Note's winning thread stands (superseding a different active
• fetch_threads function — Every comment thread on the repo: the utterances issues, and the discussions of the
• gh_graphql function — One GraphQL request through the GitHub CLI (its own authentication).
• harvest_discussions function — The harvest verb: read every comment thread, map it to a Note, land the facts. All or
• load_comments_config function — The widget's settings from the site config (post-comments) and the site's title (the
• load_threads function — Every Note's comment threads: the active discussion fact and the superseded ones.
• map_threads function — Each thread's Note: an authored map wins; a path-era title by the page's site_path
• page_comments function — What a page's block loads: its one active thread, else its canonical path as the term.
• path_key function — A pathname (utterances, 'posts/x/' or 'posts/x/index') or a giscus term ('/posts/x/')
• plan_threads function — Per Note, the thread with the MOST comments stands; the others are earlier threads
• render_comments function — The comments block: the questions line, the earlier threads, and the giscus widget --
• thread_url function — A thread's page: comment threads are discussions once the publish converts them.

cjm_context_graph_projection.conceptjudge

• apply_concept_run function — Land one run: each asked pair's standing judgments are replaced by the run's (a source
• concept_question function — One concept's question for a source of the family.
• concept_scope function — The sources the judge asks (module docstring): each public post of a declaring type for
• concept_state function — The reads a run, a review and a measure share: the selected sources, their states, the
• concept_view function — What the concept judge sees of a post: every section's prose in order, each capped at
• concepts_read function — The live concept vocabulary with each concept's confirmed relation counts -- the read the
• criteria_hash function
• definition function
• family_of function
• judge_concepts function — The concept judge verb: find the stale pairs, ask, land the run. All or nothing -- a run with
• load_concept_judgments function — Every stored concept-relation judgment (the JUDGED family proposing TEACHES / ASSUMES / COVERS).
• load_concept_records function
• load_concept_views function — Every source's judged state, from its post's Sections in the graph.
• load_concept_vocab function — The live (unretired) concepts -- the questions' subjects.
• load_confirmed_relations function — Every confirmed TEACHES / ASSUMES / COVERS edge onto a concept, per pair.
• measure function — The pilot's measure (ruling ad37f62a (4)), from the stored judgments and the confirmed
• plan_requests function — A source's questions in as few requests as the budget allows -- each over the whole state.
• record_value function — The canonical JSON of a source's record (key-sorted, compact).
• relations_of function
• request_body function
• resolve_only function — A run's selection: each ref names a source, or a notes post whose source is its unit.
• review_basis function — A pair's basis: the source's judged state and the concept's criteria. A mark whose basis
• run_concepts function — Ask every request; an answer missing an asked concept (or one of a Choice's options) fails.
• section_prose function
• source_criteria function
• stale_pairs function — A pair is stale when its source has no record, the source's state moved, or the record
• tokens function
• type_relations function — The deliverable types whose information_policy declares concept_relations.

cjm_context_graph_projection.conceptreview

• apply_relations function — Land one relation review: the retractions, the confirmations (record_relation, checked at
• apply_vocab function — Land the checked blocks as one entity batch (subjects first, so a concept may name a subject
• draft_area function — A draft names its area typed (area: stage:export), or -- as the pilot's first drafts did,
• live_entities function
• merge_drafts function — The drafts by key: the first draft of a key gives its fields, a later differing description
• parse_relations function
• parse_vocab function — The document's blocks: each head line with the field lines beneath it.
• plan_relations function — Check every row against the graph and plan the batch (module docstring); any error refuses.
• relation_document function — The relation review document, grouped by source, each source's rows by p.
• relation_state function — Every fresh pair's review row (module docstring), the stale pairs apart, and the reads the
• review_concepts function — The review verb: either review's document, or one landed (or refused) review.
• vocab_document function — The vocabulary review document (module docstring), grouped by area.
• word_of function

cjm_context_graph_projection.config

• load_graph_config function — Read the graph-sibling config. Absent = {} (fallback to DEFAULT_*);
• sibling_graphs function — The sibling_graphs registry as DATA: which other graphs a <key>:<id> reference

cjm_context_graph_projection.contradictions

• contradictions function — All slots whose active assertions form a hard contradiction (optionally scoped).

cjm_context_graph_projection.conventions

• compute_conventions function — Compute convention findings from CodeSymbol nodes + the documented-id set (pure).
• compute_untested function — The untested-symbol audit (pure): every public top-level PACKAGE symbol (test
• conventions function — Audit notebook-sourced symbols for missing prose/docstrings + non-granular cells,

cjm_context_graph_projection.coverage

• check_coverage_value function — A coverage value must name a live vocabulary entry of the predicate's kind, so a
• coverage_matrix function — The Tutorials matrix over the graph: every deliverable whose type's kind is
• field_format_error function — The formats some fields carry beyond their type (design leg 4a4ef27e): published is an
• land_entities function — Land a checked batch one op at a time (ruling 547f4123 (1)): each record planned against the
• load_coverage_facts function — Every subject's ACTIVE coverage values (both predicates, supersession applied).
• load_hardware function — Every hardware Entity with its ACTIVE standing (None if never asserted; two active
• load_verifications function — The verification edges (deliverable -> device) with their evidence.
• load_vocab function — The live (unretired) vocabulary of both axes, each entry its properties plus id.
• mint_entities function — A vocabulary batch (amendment 3c5cff97), checked WHOLE before anything lands, as the
• mint_entity function — Mint or update a typed Entity from its WHOLE record (journaled entity; upsert by
• project_matrix function — The pure projection (no graph access): see the module docstring for the rules. A filter
• record_verification function — Write one VERIFIED_ON edge with its evidence (journaled verified-on), or retract it.
• resolve_deliverable function — Resolve a deliverable argument to its Note id (an id first, then a slug).
• validate_entity function — Check one entity record against its kind's declared fields.

cjm_context_graph_projection.derivedblocks

• check_derived function — After the render: every planned post reported, each named block dropped exactly once, and
• check_end_placement function — After the render: every post's end matter -- the author strip, and the comments and
• derived_plan function — Plan every rendered post's drops and navigation. A derived block with no link target
• render_nav function — The post navigation: the series position, then the collections line, as simple callouts.
• write_derived function — Write the data file and the filter (only what changed) and clear the report.

cjm_context_graph_projection.devgraph

• ArchiveSource class — The archive's kept paths and their decomposition — ONE definition for the ingest that
• build_dev_graph_elements function — Assemble the full dev graph: memory notes (+ refs), the repo map (+ deps),
• memory_elements function — Decompose every memory markdown file (except MEMORY.md) into graph elements.
• notes_corpus_elements function — Decompose a git-held <dir>/index.md / index.qmd markdown corpus into graph elements.
• parse_source_id function
• repo_entity function
• repo_map_elements function — One repo Entity per cjm-* repo (RENAME-STABLE keys) + DEPENDS_ON from pyproject.
• site_page_slug function — A site page's slug — "about.qmd" -> "about", "series/notes/index.md" -> "series/notes";
• source_id function — An ingested git source's id (DEC a9176261): its kind and where it lives — the root a
• stamp_note_profile function — Record the relationship-harvest profile on every Note wire dict (in place).

cjm_context_graph_projection.display

• Displayer class — The rule interpreter: loads a graph's DisplayRules once, then batch-annotates.
• annotate_display function — Load this graph's rules + annotate nodes (the one-call seam for read verbs).
• display_rule_node_id function — Deterministic DisplayRule id — one rule per kind, so re-authoring converges.
• first_clause function — A long statement's leading clause — the Decision-title extractor.
• node_title function — Best display label for a node: the stored/cascade tiers of the resolution order.
• parse_template function — Parse a display template into literal / property / edge parts.
• set_display_rule function — Author/update the graph-carried DisplayRule for a kind (presentation vocabulary).

cjm_context_graph_projection.evidence

• apply_evidence function — Land one run in ONE batch: the snapshot node, every web_path the run names, each measure's
• cloudflare_measures function — Each day from the snapshot holding its best reading: a COMPLETE reading (taken after the UTC
• evidence_config function — The evidence block of the graph-sibling config: the evidence root, the site's host, each
• evidence_timer function — Install, report or remove the pull-only timer. The units are GENERATED here from the config
• ingest_evidence function — Ingest one snapshot: its source's months are recomputed over every snapshot of that source
• ingested_snapshots function
• pending_snapshots function — What the next ingest reads (ruling 56c17a80: the timer pulls, a session ingests every
• plan_evidence function — What lands: each measure whose value differs from its window's active value (superseding
• pull_cloudflare function — One calendar month per query and shape (well inside the 13-week cap); bot rows kept (the
• pull_evidence function — Pull one source into a new snapshot. By default it starts where the snapshots on disk end,
• pull_search_console function — Each shape per calendar month, paged by startRow until a short page (dataState all: the
• read_snapshot function — Read one snapshot, every file checked against its manifest hash; any mismatch, missing file
• search_console_measures function — Each DAY from the latest snapshot whose window covers it (Search Console revises recent
• snapshot_id function
• snapshot_record function — What the snapshot node records: its source, pull time, covered window and file hashes (the
• timer_units function — The pull-only timer as systemd user units (ruling 56c17a80; cadence 6e283d4b): the service
• traffic_report function — Each page's traffic DERIVED across every path it holds or held (the path ownership follows
• web_path_id function
• write_snapshot function — Write one snapshot's raw files and its manifest; an existing snapshot refuses (a pull never

cjm_context_graph_projection.facetjudge

• applies function — Task and stage entries are asked of non-tutorial posts only (eefda2dd (4)).
• apply_facet_run function — Land one facet run: each asked pair's standing judgment is replaced by the run's (a post
• code_signals function — What the post's code says about its tools, read from its fenced blocks.
• criteria_hash function — The hash of an entry's Noul as asked: the entry's fields and its kind's text together.
• entry_id function
• entry_question function — One entry's Noul: its kind's instructions naming it, its description and not-for line as criteria.
• facet_view function — What the facet judge sees of a post -- and what its staleness is measured against.
• facets_stale function — The public posts with missing or stale facet judgments.
• is_facet_entry function — A live entry of a facet kind that is not a matrix-structural task row: the cross-task row
• judge_facets function — The facet judge verb: find the stale pairs, ask one request per post, land the run.
• load_facet_judgments function — Every stored facet judgment.
• load_facet_records function — What each judged post's facet judgments were made against (_value = the fact's text).
• load_facet_views function — The facet judge's state of every public post, from the graph (the audience rule: only
• load_facet_vocab function — Every entry of the five facet kinds the judge asks (is_facet_entry).
• measure function — The measuring pass's report (eefda2dd (6)), from the stored judgments: per entry the posts
• opening_prose function — The post's opening prose, whitespace collapsed.
• post_outline function — A post's section outline for a judged state: each content section's title, links reduced
• record_value function — The canonical JSON of a post's record (key-sorted, compact).
• request_body function
• review_basis function — A pair's basis: the post's judged state and the entry's criteria. A mark whose basis is
• run_facets function — One request per post with a Noul per entry; a response missing an asked entry is a failure.
• stale_pairs function — A pair is stale when its post has no record, the post's state moved, or the record holds

cjm_context_graph_projection.facetreview

• apply_review function — Land one review: assert each confirmation (checked at write time like any facet), then set
• facet_gate function — The public build's facet gate (eefda2dd (7)): the public posts with stale pairs, the ones
• load_confirmed function — Every post's ACTIVE confirmed facets (supersession applied).
• parse_review function — The document's rows; a repeated pair is an error (the file is refused whole).
• plan_review function — Check every row against the graph (its pair fresh, its basis current, its edge present) and
• review_document function — The review document, grouped by entry, each entry's rows by p (module docstring).
• review_facets function — The review verb: the document (counts and stale pairs alongside), or one landed review.
• review_state function — Every fresh pair's review row (module docstring), the stale pairs apart, and the reads

cjm_context_graph_projection.factlayer

• active_assertions function — The active assertions in a slot under append-only supersession.
• alias_index function — Build the entity alias index + an id->entity lookup (rename-stable subjects).
• count_label function — Count nodes of a label (optionally predicate-filtered) — NodeQuery(count=True).
• edge_holds function — Whether re-landing an edge would change nothing -- a restatement verb's PLAN no-change test
• group_by_slot function — Group assertion nodes by their slot_id property.
• holds function — Whether an upsert would change nothing -- the PLAN's no-change test (ruling 17daa86b).
• label function — A node's label / kind (typed GraphNode or wire dict) — the sibling of nid/props.
• load_assertions function — All Assertion nodes.
• load_contradicts function — All CONTRADICTS pairs already recorded (for write idempotency / reporting).
• load_edge_pairs function — All (source, target) pairs for an edge relation type.
• load_edges function — The edges an EdgeQuery matches, whole -- for a caller that diffs edge ids.
• load_label function — All nodes of a label — every row, never a capped subset (finding a107e2f3); the
• load_label_where function — Nodes of a label filtered by property predicates, SERVER-SIDE (NodeQuery.where).
• load_nodes function — Batch-fetch nodes by id in ONE worker round-trip (NodeQuery.ids).
• load_supersedes function — All SUPERSEDES (superseder, superseded) pairs (the resolve_active input).
• nid function — A node's id (typed GraphNode or wire dict).
• note_alias_map function — Confirmed note aliases as a {drifted-slug: canonical-slug} map.
• prop function — One property value off a node.
• props function — A node's properties dict (typed GraphNode or wire dict).

cjm_context_graph_projection.filing

• classify_filing function — Pure: partition open items into filed/unfiled and score anchor proposals.
• derive_anchors function — The program-anchor set: subjects whose ACTIVE role is one of ANCHOR_ROLES.
• filing function — The derived filing report over task_state subjects + PART_OF/REFERENCES/SHAPES edges.
• near_duplicate_scores function — IDF-weighted token-set cosine between a new statement and existing items.
• near_duplicates function — Mint-time near-duplicate proposals over the OPEN work-item population.

cjm_context_graph_projection.gitfold

• ElementFold class — Element times over file versions: runs by holder count, content changes by wire.
• FoldedHistory class — One work tree's kept paths folded to HEAD: the HEAD-state per-path payloads + the times.
• blobs_at function — Several paths' contents at one commit through one ls-tree + one cat-file batch.
• cjm_dep_names function — The cjm-* dependencies a pyproject declares (an unparseable file declares none).
• commit_exists function
• fold_history function — Walk the kept paths' versions, decompose each, fold the element times, check the end
• git_toplevel function — The work tree path belongs to (None = no git history: no durable time).
• git_versions function — Every commit in HEAD's ancestry, reverse topological order, with the kept paths it set.
• head_commit function
• head_tree function — Every file HEAD holds.
• paths_between function — What moved between two commits of one source (renames are a delete + an add: identity
• read_blobs function — Many blobs through one git cat-file --batch.
• root_commit_time function — When a repo began: its root commit (the earliest, when several histories were joined).
• unquote_path function — Undo git's C-style path quoting (core.quotePath=false leaves UTF-8 bare, not " / \).
• worktree_changes function — What HEAD does not carry: reported by the ingest, never read from the tree.

cjm_context_graph_projection.homepage

• entry_anchor function
• entry_refs function — The map's entries in their order: the refs of the selection's subgraph clauses, in turn.
• home_body function
• map_entries function — Each named page as a map entry (the module docstring's (2)). An entry's form names its
• plan_home_page function — Plan the home page: the identity, the map, the jump links, the band.
• post_line function
• recent_posts function

cjm_context_graph_projection.inbound

• Browser class — A Chrome under the dedicated Search Console profile, driven over the DevTools protocol (one
• apply_links function — Land one links run in ONE batch: the snapshot node; every web_path and web Reference it
• clean function
• fetch_list function
• fetch_outcome function
• html_total function — The drill-down's total from the kept bytes (the snapshot is the source): the first bare
• import_export function — Keep hand exports as a dated snapshot, byte for byte (ruling a3c02fb1 (4)): each file copied
• inbound_report function — Each page's inbound links DERIVED across every path it holds or held: per linking site, the
• ingest_links function — One links or export snapshot. An already-ingested one plans no change (ruling 24fa72c2 (4)):
• normalize_url function
• plan_links function — What one snapshot observed, computed from its files alone (the op carries it whole):
• pull_drilldowns function — Walk the Links drill-downs: the top linked pages, each page's linking sites, each (page,
• pull_fetch function — Fetch every page politely (ruling a3c02fb1 (3)): each host's robots.txt read once and kept,
• pull_links function — Pull one links source into a new snapshot (files only, never the graph); a source already
• read_drilldown function — Open one drill-down and read its table once it is stable: two consecutive reads agree and the
• site_key function

cjm_context_graph_projection.journal

• apply_write_op function — Apply one journaled op through its core verb -- THE applier, live and on rebuild (design
• journal_sourced_note_paths function — The memory .md files ingest must NOT read — they're journal-sourced now.
• journal_touch_rows function — A journal's touch rows across its whole segment family (cold first,
• journal_window function — The journal-window projection: which nodes a window/session touched, when, how.
• journal_window_view function — The SESSION LENS read verb: journal_window + graph join (title/label per ref).
• m3_baseline_import function — One-time M3 GENESIS IMPORT: emit a per-note new-note baseline op into the journal.
• node_journal_trace function — One node's journal TRACE: created/updated + session keys + actors (axis D).
• replay_journal function — Re-apply every journaled write through its core verb (idempotent).
• touched_node_ids function — Best-effort node refs a journaled op touched — the session-lens feed (2f51ff5d).

cjm_context_graph_projection.judgeengine

• digest function — The hash staleness is keyed by: key-sorted JSON, so equal content hashes equal.
• http_ask function — The HTTP judge: one POST per request, retried with backoff on overload and network faults.
• land_run function — The run verbs' shared tail (ruling 24fa72c2, design detail 65f4a6c9 (1)): the run's apply
• normalized function — The journal writes ops sort_keys, so replay rebuilds every dict key-sorted: live and
• post_sections function — Every Note's sections in order (HAS_SECTION), for a family's judged state to read from
• public_posts function — The posts a judge may be shown (the audience rule e1fd4d64: only public posts are sent).
• read_key function — The key from KEY_ENV, else KEY_FILE -- never printed, never journaled.
• resolve_ask function — The judge a run asks: the one given, else HTTP with the key -- or the reason there is none.
• restates function — A family apply's PLAN no-change test (ruling 24fa72c2 (3)): a run that drops exactly the
• run_requests function — Ask every request on a worker pool; every answer is kept (the family applies its floor).

cjm_context_graph_projection.judging

• apply_judgments function — Land one judge run: every stored judgment touching a re-judged post is replaced by the
• judge_pairs function — Both directions for every stale post, against every other judged post.
• judge_related function — The judge verb: find the stale posts, judge every pair touching them, land the run.
• judgment_of function — The judgment as the edge stores it, from the service's typed answers.
• load_judged function — Every stored judgment.
• load_post_views function — The judged state of every public post (the audience rule: only public posts are sent).
• load_records function — What each judged post's judgments were made against.
• post_view function — What the judge sees of a post -- and what its staleness is measured against. An empty
• question_hash function — The questions' identity: a changed question makes every judgment stale.
• related_stale function — The public posts whose related judgments are missing or stale -- the build's report.
• run_judge function — Ask the judge about every pair; every answer is kept (the caller applies the floor).
• stale_posts function — A post is stale when it has no record or its record names another state or question.
• state_hash function — A post's judged-state identity.

cjm_context_graph_projection.lens

• apply_lens function — APPLY a lens: bind params -> run each selection clause through the real
• bind_params function — Bind an application's params: defaults + provided, typed, loud on gaps.
• lens_count function — A number a page projected from a Lens reads off its Lens (a62f2499 (3), 5c3c2662 (5)):
• lens_node_id function — Deterministic Lens id — one lens per slug, so re-authoring converges.
• load_lenses function — Every well-formed Lens on this graph (the shelf feed), slug-sorted.
• set_lens function — Author/update a graph-carried Lens (journaled upsert-by-slug).
• validate_lens_spec function — Parse-validate a lens spec against the v1 shape; a bad spec NEVER lands.

cjm_context_graph_projection.library

• check_survey_targets function — The graph half of the survey check, run before anything is written: each row's
• library_index function — Load what the Library derives from and project it: the Library entities, the asserted
• load_library_entities function — Every work, unit and output-class Entity on the graph, keyed by sub-kind then key.
• plan_survey function — The pure plan of a survey batch: the works and units to mint and the provenance edge per
• project_library function — The Library as data, deriving everything and storing nothing (design 5de7fae9 (3), leg
• read_survey function — Read the reviewed survey table.
• record_provenance function — Write an ARCHIVE deliverable's one DERIVED_FROM edge to its work or unit (journaled
• record_work_member function — Place a metabolized source in its work (journaled work-member): a Source Reference
• source_entity_id function — The Entity a provenance key names: a key carrying the unit separator is a unit's.

cjm_context_graph_projection.librarypage

• form_name function — A form key as a reader reads it ("lecture-series" -> "lecture series").
• plan_library_pages function — Plan the Library index and every work page it links: the Library under the profile, a
• render_index function — The topic line, then one section per form: each work's name (linked to its work page when
• render_work function — The card, the units grouped by part, and the outputs on the whole work. A unit with one
• topic_pages function — The topical pages: a SUBJECT's category page listing at least one notes post (the topic
• unit_anchor function
• work_description function
• year function

cjm_context_graph_projection.linkaudit

• bracket_from_cdx function — Bracket the rot from a Wayback capture list: the last capture that answered
• classify_link function — Classify a probe: a hop leaving the registrable domain is offsite (the hijack
• extract_external_links function — Pull the external URLs out of markdown text.
• link_audit function — The audit: enumerate Notes (frontmatter + every Section's raw), extract the
• probe_url function — Fetch a URL following redirects ONE HOP AT A TIME (GET with a browser-like
• registrable_domain function — The registrable (owner-level) domain of a URL — the unit a hijack crosses.
• wayback_bracket function — Ask the Wayback CDX index for the URL's capture history and bracket the rot.

cjm_context_graph_projection.listing

• list_graph function — Enumerate one CLASS of the graph: nodes by label / assertions by predicate / edges
• parse_where function — Parse --where PROP=VALUE clauses into property predicates (op eq, AND).

cjm_context_graph_projection.memorysource

• MemorySource class — The memory lane's decomposition: the memory profile, identity from the frontmatter name,
• capture_memory_records function — One note's capture + cutover records, canonical, proved: the db's text re-decomposes to the
• cutover_memory function — Capture + cut over the memory notes as ONE group, each read from the db as its writes-journal
• is_memory_lane function
• memory_inventory function — The memory notes the writes journal holds: each new-note genesis op without a born
• memory_lane function — The note-lane config the notes lane's machinery reads: the memory journal as its source
• memory_new_note function — A memory note born cut over (c9b29de5 (6)): one group -- the note, its elements' state and
• note_lane function — One graph, one note lane: the notes graph's archive, else the dev graph's memory notes.
• stray_memory_files function — A memory note is born on the graph; a markdown file that appears in the harness memory dir
• title_records function — An in-body H1 is the note's title (c9b29de5 (5)): its text moves into the frontmatter as

cjm_context_graph_projection.module_ops

• add_module function — Birth a module WHOLE in ONE journaled op, BORN CAPTURED (work item 177dcb07, the ruling
• delete_module function — Delete a module — retire its journal key, drop its file, and let the code fold's step
• flip_notebook_to_py function — The off-nbdev step, ONE LOUD VERB, in the element regime (design detail 25c1fadc, ruling N):
• new_module function — Mint an EMPTY module, graph-sourced from birth (the target add-text / add-symbol /
• regroup function — Gather symbols into a module — the EXECUTE verb for an under_split (extract a
• rename_module function — Rename a .py module — re-emit its content at the new path, drop the old file, and
• rewrite_module_import function — Rewrite a module-RENAME across an importer: every from old import … and

cjm_context_graph_projection.notes_outline

• apply_outline function — Turn the outline pass's answers into STRUCTURE rows on a proposal SET (ruling bc62c727 (A);
• apply_outline_plan function — Land a plan as the journaled ops it names, in an order every step of which stands on its
• outline_of function — The draft's STANDING outline as rows in the pass's own contract, so a reader can keep,
• plan_outline function — The DRAFT mode's plan (81d6e669 (3); rulings 96be1528 (11) — a pass is a proposal set and a
• render_outline_brief function — The brief of the whole-source OUTLINE PASS (ruling bc62c727 (A); parents per 776c13d3 (a)):

cjm_context_graph_projection.notes_place

• apply_placement_plan function — Land a plan as the journaled ops it names: each role as ONE assert of point_role on
• gx_note_missing function — Whether the draft exists — the one graph read the apply makes before its first op.
• plan_placement function — The pass's plan, mutating nothing: each row resolved to a point key and compared with what
• render_place_brief function — The brief of the PLACEMENT PASS (rulings 96be1528 (1)/(3)): the keyed points laid out

cjm_context_graph_projection.notesource

• Element class — A journaled element's state and placement.
• KeyedSection class — A Section whose id is its journaled id, not the one its derived anchor would mint, with
• NoteRec class — A journaled Note's state.
• NotesFold class — The notes source journal folded to state: notes, elements, the addresses ever used.
• NotesFoldError class — A note whose journaled state does not compose and re-decompose to the same elements.
• absorb_archive function — Absorb an outside edit (a typo-fix pull request merged into the website repo): HEAD's blob
• absorb_records function — Map an outside version's elements to ids by their derived anchors (an unheaded element's
• append_group function — Append one write's records under ONE ts (the op clock's), through the shared choke point.
• apply_notes_groups function — THE LIVE STEP at any journal position: records[start:end] applied to the db group by group,
• apply_notes_live function — THE LIVE STEP for the records a live verb just appended: apply_notes_groups over the
• archive_add_section function
• archive_author function — author on a cut-over archive Section, journal-first (56b24fd5 (4)): title + body; a
• archive_command function — The archive cutover's verbs (work item 79703485; design amendment 56b24fd5): capture-archive,
• archive_source function
• birth_records function — A new headed element: its address at birth (the anchor its heading slugs to), a generation
• capture_archive function — Capture every kept post at commit into the notes source journal: one group, each post's
• capture_records function
• cutover_archive function — Cut captured notes over: the journal's composition, the graph's (the round trip), HEAD's
• cutover_freeze function — The git fold's freeze for the cut-over paths: each stops at its note's capture commit.
• derive_note function — Compose the note from its state, decompose the text as ingest would, and key every
• emit_note function — Write the note's composition to its path in the website tree (the emit). Commit + push main
• fold_records function
• fold_source_records function — Continue the cut-over paths in the git fold's ElementFold: each journal step that touches a
• group_spans function — groups as index ranges: one write's records share a ts.
• groups function — One write's records share a ts and fold as one step.
• held_text function — The note as the db holds it -- what a capture reads, and the prior a cutover's relation
• ingest_records function
• journal_write function — The journal-first write path every authoring verb takes: build the records from the
• journaled_lane function
• note_edit_records function — An edit of a Note's own state, its frontmatter (design c9b29de5 (6)); a changed identity is
• note_source function — One grammar, two lanes (design c9b29de5 (2)): a lane is config DATA plus its source.
• note_wires function
• notes_source_check function — Each journaled note's file against its journal: CLEAN (working tree == HEAD == journal),
• place_records function — A move, re-parent or reorder: the element's own placement, plus the two siblings whose
• read_notes_journal function
• replay_source function — The rebuild swap's source-journal fold (finding 6c121287): records appended to the SOURCE
• replay_spans function — The groups a rebuild replays as windows instead of folding at ingest (design amendment
• retire_records function — An element leaves the note; its follower closes the gap. One with children refuses (move or
• retired_section function
• section_edit_records function — An edit of one element's text: a headed element keeps its level (level is placement --

cjm_context_graph_projection.onboarding

• project_onboarding function — Project the onboarding surface by WALKING the asserted lead structure.
• surface_budget function — Pure: the lock budget MEASURED from this projection, never remembered.

cjm_context_graph_projection.oracle

• procedure_node function — The oracle's Procedure node (the programmatic value-source for its assertions).
• read_repo_version function — Read a repo's version: installed metadata first, else __version__ on disk.
• run_version_oracle function — Refresh version slots for repo entities; report what changed.

cjm_context_graph_projection.paths

• alternatives function — alternatives: steps sharing an input ARTIFACT and producing one artifact KIND -- [{input,
• analogues function — analogues (ad9bef5a (2)): steps making the SAME stage transition with DIFFERENT base models
• check_record_refs function — Every Entity a record names is live (or earlier in its batch) and unretired, and its
• continues_from function — continues-from: a step's REQUIRES matched to another step's PRODUCES -- [{step, from, via,
• endpoint_kind function — What a node is, in RELATION_ENDPOINTS' vocabulary.
• flywheel_cycles function — Flywheel paths (ae698640 (2)): a flywheel is a CYCLE AT THE KIND LEVEL over ACYCLIC instance
• gaps function — gaps: an ASSUMED concept that no deliverable TEACHES and no Library unit or work COVERS --
• land_record_edges function — Reconcile the edges a record owns with the record: the ones it no longer implies go, the new
• load_path_graph function — The path model's slice of the graph as plain data: the Entities it names (by id: their
• path_reads function — The paths read verb: one derived read, or all of them, with every node it mentions named.
• prepares_for function — What a work, a unit or a deliverable PREPARES YOU FOR (e2b3a414): the deliverables that
• record_edge_delta function — What landing a record's edges would change -- read-only, so a plan can tell an entity
• record_edges function — The edges a record lands: an artifact's lineage, an environment's parts and requirements,
• record_field_error function — The SHAPE of a path-model record field (pure; the live references are checked by
• record_refs function — The Entities a record names (its references), from its fields.
• record_relation function — Write one path-model relation (journaled relate), or retract it. The endpoints' kinds must
• resolve_endpoint function — Resolve a relation endpoint argument: an Entity by kind:key, else a deliverable by id or
• split_candidates function — SPLIT CANDIDATES (ae698640 (6)): a post turning A into B and B into C -- it PRODUCES B and C,
• stage_matches function — A step's DERIVED stage and task (ae698640 (2)): its input artifact kinds and output kinds
• staleness function — Environment staleness (ae698640 (3)): a deliverable that requires or produces an environment
• step_view function — One step in context: its relations, what it continues from and what continues from it, its
• steps_of function — Every deliverable with relations, as a step: what it requires (artifact / environment ->
• transitions_error function — A stage's transitions (ae698640 (2)): each {in: [kinds], optional: [kinds], out: kind}, the

cjm_context_graph_projection.perf

• append_timing function — Append one timing event: O(1), dedup off (every run is one event), fail-open -- the
• appended_bytes function — The run's journal appends, every file (design detail 2f5033bf (1)).
• begin_invocation function — Arm the instrument at the top of main -- everything before it is the launch and the
• end_to_end function — An invocation's whole cost as its caller waits for it: the in-process wall plus the
• fit function — Least squares of cost on one covariate -- the shape d7742c47 (b) reads. None when the
• gesture_cost function — What a gesture cost the store (design detail 4389a579): its wait on the loop and its
• growth function — A measure's growth exponent across the scale tiers (design detail 3bd8673d): least
• guards function — The design's guards, read off one event (681604c1): each row names the guard, what it
• invocation_graph function — The invocation's graph with its phases: the body runs as verb, and the covariates are
• invocation_parsed function — Name the run, record the parse, and keep it armed only when a ledger will take it.
• io_row function — An event's disk figures (design detail 2f5033bf (1)): net bytes written and bytes read
• journal_footprint function — A journal family's size as stored: segments and bytes on disk (a cold segment counts
• knee function — 7b's KNEE (ruling 110c662f (2), design detail 2c4bad75 (5)): the client count after which
• load_definitions function — The planning loads (ruling 110c662f (5), design detail 2c4bad75 (1)): every perf_load
• load_report function — The concurrent replay mode's read (design detail 2f5033bf (2)): per load run -- its lane,
• load_targets function — The target classes (design detail 2f5033bf (3)): every perf_class Entity not retired and its
• logical_bytes function — The denominator of a run's write amplification (ruling 9af0e42e (1) / (3)): the journal
• measure_covariates function — The growth covariates every event carries: the store half (nodes, edges and bytes of the
• net_written function — Bytes a run wrote to the disk (design detail 2f5033bf (1)): write_bytes less
• parse_roles function — A load's role counts (design detail 2c4bad75 (1)): role=count pairs, space- or
• perf_report function — The ledger read: per verb the latest / median / p90 END-TO-END seconds (launch + import
• poll_rows function — A poll's cost per tick (design detail 4389a579): its rolling windows' ticks, the mean work
• render_perf function — Render the perf read: tables for a person, the result as JSON for an agent.
• run_invocation function — Run the invocation and append its event, whatever its outcome -- a refusal or a crash
• self_times function — A phase's SELF time: its inclusive seconds less its direct children's.
• series_trend function — A positioned cost's trend: the mean cost per item in the last third of the bins over the
• target_standing function — Each seat against its class's targets (ruling dba17ca8, design detail 2f5033bf (3)).
• tier_curves function — The scale harness's read (design detail 3bd8673d): per lane and canonical verb, the
• tier_regressions function — A seat's latest reading at a tier against its best there (design detail 2f5033bf (3)):

cjm_context_graph_projection.postpage

• category_links function — Each category as a link to its category page where one exists (design a62f2499 (7)), else
• display_date function — Quarto formats a page's dates BEFORE user filters run, so a date the filter sets must
• end_plan function — Every post's end matter. A Note of no post kind (a site page, an untyped Note) has none.
• fill_copy function — Copy names the site author through {name} / {role} (the summary its holds clause through
• header_facts function — The header's dated facts (39c51c15 (2)): when a deliverable's published state was asserted,
• header_meta function — The header's projected metadata (39c51c15 (2)): the kind label; a born post's date is its
• holds_line function
• is_category_link function — A link to the category listing opened filtered to a category (category_links' form,
• license_facts function — The license facts (39c51c15 (6)): per deliverable class on the DeliverableType, per
• links_line function
• load_category_listing function — The listing a post's categories link into (category-listing in the site config: a listing
• load_holder function — The copyright holder the footer names (copyright-holder in the site config): a missing
• load_reading_guide function — The site's one statement of how to read it (reading-guide in the site config, design
• load_site_author function — The site's one statement of its author (site-author in the site config, amendment
• load_site_holds function — What the site holds (site-holds in the site config, design 8b4f15d0 (3)): the second part
• load_site_links function — The site's one statement of its contact links (site-links in the site config, design
• load_site_nav function — The navbar's own entries (site-nav in the site config, finding c6befeb6): each names its
• load_site_summary function — The site's one sentence of who and what (site-summary in the site config, amendment
• load_strip_copy function — The strip's copy from the site config: a missing key or field refuses (the build never
• nav_entries function — Resolve each navbar entry to what Quarto links (finding c6befeb6): a page path to the ONE
• offered_backing function — The posts that back an OFFERED claim through a backing kind, read through the public
• pitch_target function — The page the pitch points at: the Work-with-me page (903bc108 (5)). It is not on-graph
• post_dates function — A post's public dates (39c51c15 (2)): an archive post's own date, a born post's publication;
• post_licenses function — A post's licenses: its own override, else its class's. A post with none, or with an id
• related_context function — The relations related posts rank by (39c51c15 (4), amendment e09e262b): post-to-post links
• related_posts function — Related posts by relation, each with its reason (39c51c15 (4), amendment e09e262b):
• render_end function — What the post draws on, related posts, the author strip (with the pitch line when given) and the comments block.
• render_related function — Related posts, each with its reason, as a plain classed div (styled by the site).
• render_reuse function — The license line, as Quarto's own Reuse section (a filter-set license never reaches
• site_footer function — The footer, derived (39c51c15 (6)): the copyright years run from the first publication to
• site_nav function — The navbar's right side: its own entries in their stated order (finding c6befeb6), then the

cjm_context_graph_projection.projection

• ambiguity_error function — One-line error naming the candidates, so the caller's next call can be exact.
• explore function — Descend into one cluster of a query: its members, BOUNDED, re-faceting if large.
• find_seeds function — Find seed nodes by term overlap with their text fields (accept misses).
• full_graph_view function — The WHOLE graph as one canvas payload: every node (cheap-title tier) + every edge.
• get_schema function — The graph's ontology: node labels, edge types, per-label counts.
• graph_overview function — The whole-graph orientation view — the facets of the DEFAULT (empty) query.
• grep function — Exact-substring CONTENT search over every node's text fields — the literal third leg.
• locate function — Resolve a human HANDLE to node(s) + their on-disk path — the inverse of show.
• node_summary function — Compact, provenance-carrying summary of a node (the unit of a bounded read).
• relevant function — The bounded level-0 pull: the full reached set's SHAPE + a top-k teaser.
• resolve_node_ref function — Resolve a node reference: exact id first, then unique id-prefix.
• show function — One node in full, with its immediate neighbours + the relation to each.
• state function — Graph overview (no subject) or a subject's effective view (show).
• subgraph_view function — The BULK read verb: a node SET -> nodes + interconnecting edges, batched.

cjm_context_graph_projection.propose

• draft_code_block_update function — Pure: re-render the fenced code block that carries name's body from the live body.
• propose_updates function — Draft a proposal for every actionable, unacknowledged, not-yet-proposed change on the
• symbol_baseline_body function — The approval-time body: the module's last source snapshot at/before T (else the

cjm_context_graph_projection.prose_refs

• extract_id_tokens function — Id-shaped tokens in prose: 8-hex prefixes / full UUIDs, ordered, deduped.
• prose_refs function — The prose-ref drift audit over asserted Decisions + Notes (pure read).

cjm_context_graph_projection.pull_transcript

• build_derived_edges function — The pure aggregation-seam assembly: sent Message DERIVED_FROM each part,
• build_mint_batch function — The pure node/edge assembly the live mint AND replay share.
• build_pull_payload function — The journalable payload for an extraction sequence.
• derive_message function — The compose-send aggregation seam (DEC fc6a0cdc pt 5): the sent message
• edit_message function — In-place body edit of a Message — the journaled edit-op half of the
• mint_pulled_messages function — Land pulled messages on the spine — the code path live pull AND replay share.
• plan_pull function — THE PULL'S PLAN (ruling 24fa72c2 (5)), read before anything lands: the op's messages are
• pull_transcript function — The live pull: derive the mapping, extract the active path, mint the delta.
• stale_next_edges function — The chain re-link plan (finding e358fe97) — pure, so the live pull and

cjm_context_graph_projection.purenotes

• accept_point function — Land ONE accepted point: the Point node, its segment References (from observations —
• apply_judgements function — THE FOLD (ruling 1798a796 (3)): apply a judge's answers mechanically, loud on the first
• born_notes_by_unit function — Which source UNITS carry a born deliverable on this graph, with its state and synopsis:
• build_notes_pack function — Apply the type's INFORMATION POLICY (a stratum query read as ROLES — ruling e1e096fa)
• build_point_tree function — Nest by parent_key (second-read ruling (4): depth TWO in practice, the tree is generic).
• choose_spine function — Pick the SKELETON spine to read (the correction core's spine_where_for rule, pure):
• close_open_refs function — Apply a reconciler's answers to a set's hinted references — mechanically checked, loud
• coverage_gaps function — Pure: the unreferenced-lines query — every content line the type includes that no
• date_phrase function — A date as the card prints it, at the precision it is KNOWN to (ruling de9c4cda (H7)): day
• deliverable_owns function — Ruling 96be1528 (P): a source's points are the source's points — a SUBSTANCE point is
• derive_frontmatter function — The type may OWN the title and the description — the rest of the authored frontmatter
• derive_work_frontmatter function — The work-page type OWNS the title and description: notes-on-work = "Notes on "
• derived_description function — What the unit CONTAINS, from data the rendering already uses: the work (when the
• edit_point function — Edit an accepted point IN PLACE — the per-point repair the ch. 2 staging read demanded
• effective_roles function — Each point's role (ruling 96be1528 (1)): its own fact, else its parent's effective
• elided_point function — A point the TYPE elides by kind (ruling 15657521 (2)): the standalone lecture resource
• ensure_point_set function — Mint the (Source, unit)'s PointSet on first use and assert the Note RENDERS it — both
• extra_list function — Every EXTRA still pending in a set, keyed x001… in the set's order — the ids the judge
• group_points function — The page's sections. SYNTHESIZED (ruling bc62c727 (A)): when the points include
• judge_points function — Apply an overlap judge's answers to an ACCEPTED draft (ruling 1798a796; work item
• key_owner function — Cross-point keys name SUBSTANCE points: for a set-owned point that is its own set; for
• lecture_title function — The title a reader knows the lecture by. The URL binding kept the playlist row's title as
• load_deliverable_type function — Read a DeliverableType profile off the graph (None = notes-type <key> first).
• load_notes_propsets function — Every notes proposal set under root (optionally for one source), newest first.
• load_owned_points function — The points ONE owner holds (HAS_POINT owner -> point), in source order — the owner's
• load_placements function — The deliverable's PER-POINT OVERLAY (ruling 96be1528 (3)/(7)): every PLACED edge from a
• load_point_roles function — The point_role facts on the draft's points (ruling 96be1528 (1)): the active value per
• load_points function — What a Note RENDERS (ruling 96be1528 (P)): its OWN points (sections, research) plus the
• merge_point_blocks function — The BLOCK merge (ruling 1798a796, fork 1; work item 1561551e): the unit of agreement is
• merge_point_proposals function — The ROW-LEVEL merge (work item 3a2c94eb (2); the filter lane's merge_filter_proposals
• mint_deliverable_type function — UPSERT a DeliverableType by slug (the display-rule pattern: last journaled op wins).
• nest_points function — The one-level view of build_point_tree (kept for callers that only need parent -> children).
• note_deliverable_type function — The Note's bound type slug (the active deliverable_type fact).
• note_publish_states function — The publish_state facts as a map: every deliverable's active values. One value is the
• note_types function — Every typed Note's active type with that type's kind and origin (design amendment
• observe_segments function — Observe each segment in the sibling READ-ONLY (label + properties hash + title) — the
• open_reference_list function — Every hinted reference still open in a set, keyed r01… in the order of points_index
• overlapping_points function — Pure: the duplication candidates — two points deriving from a shared segment — and
• pack_digest function — Digest the READ content (source binding + numbered lines + headers) — what a proposal
• pick_propset function — Choose a proposal set: newest by default, else the unique id/prefix match.
• place_point function — Land the deliverable's overlay on ONE point (ruling 96be1528 (3)/(7)): ONE PLACED edge
• plan_notes_blocks function — Cut the whole pack into BLOCKS (ruling 1798a796, fork 1): a block runs between COMMON
• plan_notes_windows function — Cut a whole-unit pack into count windows of near-equal line count at MECHANICAL
• point_check function — The CHECK review: one point beside its segments' LIVE text from the sibling — the
• point_coverage function — The COVERAGE review: re-read the unit per the Note's type policy and list the content
• point_from_args function — The op-args -> PointNode mapping the live accept, the replay AND the re-home share.
• point_set_of function — The PointSet a unit snapshot addresses (ruling 96be1528 (P)): identity = (sibling graph
• points_as_proposals function — An accepted draft read as a proposal set — a point's key IS its accepted proposal id, so
• points_index function — Key a set of proposal rows for a reader that cannot see their lines: p001… in source
• proposals_from_point_rows function — Resolve validated rows to proposal rows: a minted proposal id (the point's future
• public_deliverables function — The public rule the publish guard enforces, as a set: a Note is public when its active
• pure_notes_type function — The pure-notes profile as data: information policy = a stratum query, presentation
• read_source_facts function — The Source-level facts a rendering's title and card read LIVE from the sibling (finding
• read_source_references function — The Source's human-added resource links (Reference nodes minted by the transcription
• read_source_unit function — Read one source unit: the EFFECTIVE spine (layer-0 + applied corrections, via the
• read_work_structure function — The WORK as the sibling holds it: every Source whose structure map names the work, in
• rehead_points function — Re-derive every Point's captured heading / heading_index from its segment run against a
• rehome_points function — THE RE-HOME (ruling 96be1528 (P); the migration of a deliverable born before PointSets):
• render_judge_brief function — The brief of the bounded JUDGEMENT (ruling 1798a796 (2)): ONE whole-source reader works
• render_notes function — Derive the Note's body from its Points and APPLY it: the authored preamble stays, the
• render_notes_pack function — Render a pack as the brief a proposer reads: the unit, the kind slate, the headers
• render_pairs_brief function — The brief of the judgement over what standing detection flags (ruling 1798a796 (1)-(2)):
• render_points function — Render the body from the Points — deterministic, so a replayed render-notes derives
• render_points_index function — The index as a reader sees it: p017 [claim] 12:03 **lead** — text, nested by depth.
• render_reconcile_brief function — The brief of the pass that closes hinted references (work item 3a2c94eb (3)): a
• render_source_card function — The reader-facing provenance (second-read ruling (1)): a derived one-line callout under
• render_work_card function — The work page's reader-facing card (check 2d01fe1e): the work-level content — never
• render_work_chapters function — The TOC that is also the executive summary (checks 2d01fe1e + 34f73e46): the units in
• render_work_page function — Derive the WORK PAGE's body and APPLY it (item ebb77107; ruling a7ca900d (2)): the
• render_works_table function — Pure: the per-work promotion condition as the staging site's works table (item
• rendered_sets function — The Note's RENDERS edges (ruling 96be1528 (P)) — where its substance lives. A node that
• renderers_of function — The inverse of rendered_sets: every deliverable sharing the set's substance — what a
• resolve_references function — Resolve human-added links for rendering (ae103970): a cross-work link naming a
• resolve_sibling_source function — Resolve a Source in the sibling graph: id prefix first (the shared seam), then a
• retract_note_points function — Retract EVERY point a Note renders (the re-drive's clean slate — ruling e1fd4d64 (5)):
• retract_point function — Retract a point: delete the node (its edges cascade). The compensating op of accept —
• speaker_labels function — Ruling bc62c727 (B): a speaker reads as its NAME, else its ROLE in the role's own words
• staging_index function — Project the staging site's LISTINGS from the publish_state facts (item 140981e9 (b)):
• stratum_role_policy function — Read a type's stratum policy as ROLES (ruling e1e096fa). stratum_roles is the one
• synopsis_of function
• unit_label function — The short unit handle the title carries (second-read ruling (1): the short shape).
• unit_title_header function — Ruling e1fd4d64 (C): the first read-aloud header of a chapter file is the chapter's own
• unjudged_pairs function — STANDING DETECTION (ruling 1798a796 (1)): the pairs of points that leave a draft
• validate_point_rows function — Validate + normalize proposer rows against their pack — loud on the first bad row.
• with_points_index function — The SEQUENTIAL arm's pack (design 6752db0a (11)): the window pack plus a running index
• work_of_note function — Which WORK a typed deliverable belongs to — read from its Points' unit (the structure
• work_page_notes function — The WORK PAGES on this graph: every Note bound to the work-page type, keyed by the work
• work_page_type function — The WORK PAGE profile as data: one page per Source work, the directory index above its
• work_promotion_status function — The WORK-PAGE promotion condition (ruling a7ca900d (1)/(4); item 140981e9 (c)) as a
• work_reference_of_note function — The work a WORK PAGE stands for, read off its edges: the page is linked DERIVED_FROM a
• write_notes_propset function — Write one notes proposal set: <out_root>/<set_id>/manifest.json + proposals.jsonl

cjm_context_graph_projection.readiness

• anchor_matches function — Pure: does an --anchor query name this anchor? id prefix, title substring, or slug.
• classify_readiness function — Pure: partition work-items into done / ready / blocked from authored ground truth.
• honored_closable function — Pure: open items a DONE Decision points at via EVIDENCE_FOR / SUPERSEDES — closable
• readiness function — The derived ready/blocked/done frontier over authored task_state + GATED_BY edges.
• summarize_checks function — Pure: per-item DoD summary from the checks' own task_states.

cjm_context_graph_projection.readme

• project_readme function — Project a repo's README markdown from the graph (structural-only v1).
• repo_purpose function — The repo's intro/"why" prose: the active purpose assertion on the repo Entity.

cjm_context_graph_projection.reads

• append_read function — Append one read event; ts/session stamping rides append_op.
• configure_reads function — Arm (or disarm, path=None) read recording for this process.
• delivered_ids function — Node ids a rendered result delivered into the consumer's context.
• record_read function — The render-boundary tap: no-op unarmed, FAIL-OPEN armed.

cjm_context_graph_projection.rebuilddiff

• moved_sources function — The source moved attribution: the rows a moved source's changed paths decompose to,
• parse_path_map function — Parse --path-map OLD=NEW flags; a pair without = is refused loudly.
• rebuild_diff function — Compare two graph dbs property for property — the live-versus-rebuild standing check.
• render_rebuild_diff function — Markdown by class and field (the drift map, the layer's), with this lane's Sources

cjm_context_graph_projection.reconcile

• reconcile_memory function — Report .md<->graph section drift across the corpus; optionally absorb hand-edits.

cjm_context_graph_projection.refactor

• compute_refactor_candidates function — Compute refactoring candidates from the code graph slices (pure).
• refactor_candidates function — Identify relocation / dead-code / consolidation / split candidates over the code graph.

cjm_context_graph_projection.refactor_ops

• move function — Relocate a single top-level symbol from its module to another, graph-driven.
• rewrite_symbol_import function — Rewrite from old_module import ... S ... -> import S from new_module instead.

cjm_context_graph_projection.registers

• classify_register_drift function — Pure: reconcile each register's cache against its membership ground truth.
• register_drift function — The derived register-cache reconciliation over role assertions + hub edges.

cjm_context_graph_projection.relive

• apply_live function — Apply the code fold's step to the db for the records a live verb just appended.

cjm_context_graph_projection.relocate

• apply_relocation function — The copy's web Reference (what was read at landing rides the op) and the page's
• ast_targets function
• clone_repo function — The repository a clone pushes to (its origin) and the branch it holds.
• copy_dir function — posts/ in the dedicated repository, retired-post/ in a companion repository:
• copy_header function — The copy's head (design 3d5ee659 (4)): the title, a note naming where the page lived and
• copy_targets function — Where a link to a relocated page goes from this copy: relative inside one repository,
• copy_url function
• front_matter function
• gh_repos function — The owner's repositories, read from GitHub through gh (its own auth).
• github_repo function
• http_fetch function
• include_paths function
• land_relocations function — Land each page's destination (design 3d5ee659 (6)): a page a public successor supersedes
• link_map function — The map the Lua filter applies. A raw-HTML attribute resolves as a link unless it names
• linked_repos function — The owner's repositories a page links, counted (a clone URL counts as its repository).
• load_pages function — Every page leaving or gone (the standing rows), with its paths, its source, its retire
• merge_readme function — The README with the block replaced in place, else appended; a new README is the title,
• parse_copy_url function
• pointer_block function — The README's projected block: every copy the repository holds, by date.
• project_copies function — Project each page's copy into the clone (design 3d5ee659 (1)-(4)) and regenerate the
• relocation_config function — The relocation's settings (DATA beside the notes db, design 3d5ee659 (2)/(3)): the
• relocation_plan function — The worklist as a read (design 3d5ee659 (6)): every page pending relocation with its
• render_copy function — The page's body as GitHub markdown: Quarto renders it in a scratch project of its own,
• repo_candidates function — Each page's candidate companion repository: the one its SERIES links most (a series =
• resolve_target function — One link target in the copy (design 3d5ee659 (1)). A fragment, a mail link or another
• source_bundle function — The source and every file in its directory at the commit, nested pages left out (a
• source_targets function — Every link target the source writes, read by Pandoc (the same reader the render uses).
• strip_chrome function
• with_lead function — The description opens the copy's body, so its links pass through the link map like any

cjm_context_graph_projection.rename_ops

• rename_symbol function — Rename a top-level free function/class everywhere it is referenced, graph-driven.
• rename_symbols function — Batch top-level renames in ONE emit set (finding 889b3025).
• rewrite_import_for_rename function — Re-point an importer's from src_module import old [as a] at the new name.
• scoped_rename function — Rename references to the module-global old -> new, scope-aware, by exact position.

cjm_context_graph_projection.render

• render function — Render a projection result in the requested format.

cjm_context_graph_projection.review

• approvals_of function — Pure: the ACTIVE approval-class assertions (the roots the frontier walks from).
• change_key function — The change KEY an acknowledgment binds to: <upstream 8>@<token 12> (a hash token
• classify_reference_change function — Pure: a foreign node changed when its live hash is not the observed one; a foreign
• classify_text_change function — Pure, revert-aware: compare the live content against its approval-time baseline.
• reference_baseline function — Pure: the observation an approval at T saw — the last journaled observation at or
• review_frontier function — The derived review frontier: approved deliverables whose upstream changed since approval.
• walk_upstream function — Pure: BFS upstream from the deliverable's components along the dependency edges.

cjm_context_graph_projection.rolereview

• apply_review function — Land one review: assert each role (checked at write time like any vocabulary fact), then
• parse_review function — The document's rows; a repeated row is an error (the file is refused whole).
• plan_review function — Check every row against the graph (its basis current, its role live) and plan the batch.
• review_document function — The review document: the patterns, then each post's Sections, then the overrides.
• review_roles function — The review verb: the document (with its counts), or one landed review.
• review_state function — Every open row (module docstring), with the reads the plan reuses. done = each settled

cjm_context_graph_projection.runtime

• GraphHandle class — A live, started graph: the queue + the capability id to address it.
• open_graph function — Load the graph-storage capability on graph_db_path and yield a started handle.

cjm_context_graph_projection.scratchpad_export

• derive_entries function — Chronological entries with derived on_active_path (transcript tip
• export_session_markdown function — Gather the session's message graph and render the .md projection.
• read_session_messages function — A session spine's Message BODIES in chain order — the read --session verb.
• render_session_markdown function — The pure renderer: one portable markdown document from derived entries.

cjm_context_graph_projection.sectionroles

• apply_role_run function — Land one run: each asked Section's standing judgments are replaced by the run's, a review
• distribution function — A Section's judged distribution over the live roles and none.
• effective_roles function — Each Section's role as the page reads it: its own fact; else, below the candidate levels,
• heading function
• judge_roles function — The role judge verb: find the stale Sections, ask one request each, land the run. All or
• load_role_facts function — The confirmed roles (supersession applied).
• load_role_judgments function — Every stored role judgment, keyed by the role's vocabulary key (retired roles included).
• load_role_views function — Every scoped Section's judged state, from the graph (never the file).
• load_role_vocab function — The live (unretired) section_role entries -- the Choice's options.
• pattern_key function
• question_hash function
• request_body function
• review_basis function — A Section's basis: its judged state and the question, and for an override row the role it
• role_question function — One Choice over the live roles in position order and none: each role's description is
• role_scope function — The posts that carry roles: public (the audience rule, e1fd4d64 -- the judge sees only
• role_types function — The deliverable types whose presentation_policy declares a section_roles map.
• run_roles function — One request per Section; an answer missing a role's probability is a failure.
• scope_sections function — Each scoped post's content Sections -- derived blocks, the preamble and retired Sections
• section_roles function — The derived read: each scoped post's Sections with the role the page reads (own,
• section_view function
• stale_sections function — A Section is stale when a live role has no judgment of it, or any judgment's state or

cjm_context_graph_projection.seeds

• aliases_for function — Prior names that should resolve to this repo (empty unless it was renamed).
• class_subject_elements function — Class-subject entities + PART_OF-style membership edges (ABOUT member->class).
• conceptual_key function — The durable conceptual key for a repo (rename-aware; defaults to the name).
• rename_contradiction_elements function — The torch/hf-utils rename-disposition slots with BOTH claims active.
• repo_dir_name function — The CURRENT repo dir name for a conceptual key (identity unless renamed).
• seed_elements function — All hand-seeded elements (rename contradiction + stale version + class subjects).
• stale_version_seed_elements function — A cjm-substrate version slot seeded BEHIND the real version (oracle bumps it).

cjm_context_graph_projection.series

• mint_series function — Mint or update a Series from its page's record (journaled series; upsert by key).
• order_members function — Walk the after chain from the head; report forks and unreached members.
• place_in_series function — Splice ONE member (journaled place-in-series): insert, move, or remove.
• series_order function — The series in its AUTHORED order, with whatever breaks the chain (the read verb).
• set_series_members function — Set a series' WHOLE ordered membership (journaled series-members).

cjm_context_graph_projection.serve

• build_app function — Build the read-only API app over already-open graph handles.
• graph_names function — Derive a stable short name per db (its file stem; collisions suffixed -2, -3, …).
• serve_graphs function — Open every graph once, hold the handles, and serve the API until interrupted.

cjm_context_graph_projection.sessioncost

• cg_invocations function — Every graph-tool invocation in a command: the tool, and for cg-read / cg-write
• find_session_transcript function — The session's transcript: its pull-transcript op's cc_session_uuid first (the
• is_refusal function — A call refused when it exited non-zero or printed the verbs' error form (see the
• session_cost function — The cost instrument: the transcript half (commands, refusals, wall, file edits) and
• transcript_cost function — Walk a transcript's main chain: pair each tool call with its result, classify the

cjm_context_graph_projection.site

• check_rendered_site function — Every rendered page, read whole (findings c6befeb6 + d807a18f): each internal href / src
• check_source_aliases function — Every front-matter alias must be a superseded site_path of the page that declares it:
• output_href function — Quarto's alias fixupHref: a trailing slash or an extension-less path names the
• page_outputs function
• publish_guard function — Refuse public output that carries a draft (design 13753cbf (1)): no drafts tree, no link
• quarto_inspect function — The profile's output dir and input documents, read from Quarto itself.
• redirect_page function — Quarto's redirect page for one alias location.
• redirect_plan function — The redirect projection from the site_path facts: one stub per superseded path, to
• site_build function — Build the site under one profile: generated inputs, render, the redirect projection,
• stated function — The ONE reader of what a post's page states (finding 12d98020): its front matter first,
• write_redirects function — Write each redirect page; a stub landing on a rendered page is an error (Quarto skips it

cjm_context_graph_projection.sitefeeds

• absolute_url function
• day_time function
• escape function
• feed_image_size function
• feed_order function — prepareItems: an undated item sorts last, equal dates keep the order given.
• highlight_styles function — Quarto's defaultSyntaxHighlightingClassMap: each text style of the default theme as the
• item_image function — A site-absolute image stands; a relative one is relative to the post's folder.
• math_image_url function
• png_size function
• render_feed function
• rendered_contents function — readRenderedContents under kFeedOptions, on the page as rendered. The authors are the
• rss_date function
• write_feeds function — Write every feed whose text changed. An item is {output, date, categories, image, authors?}:

cjm_context_graph_projection.sitelinks

• resolve_site_links function — Reconcile the site_link REFERENCES edges of the scoped notes against the facts.
• site_link_window function — Observe the block's writes, then run the step once at its close (a live write window —
• site_path_holders function — Every site_path value on the graph, keyed for resolution, plus each page's ACTIVE path.
• site_path_key function — The key two URLs of one page share under Quarto's URL rules (the facts stay verbatim).
• step_site_links function — THE STEP (design amendment 9ee4e346): one whole-graph resolve at a window's close, run
• touches_inputs function — Whether a window moved an input of the resolve (design amendment 9ee4e346 (3)).

cjm_context_graph_projection.sitelisting

• check_listing_chips function — After the render, with a category listing named: every chip on a projected page is a link
• chip_hrefs function — Every chip's href from the one encoder (postpage.category_links); on the category listing a
• date_text function
• feed_header function
• feed_plan function — A listing's feed (design 0efb5497 (3b)): the page's output and the feed beside it (the page's
• listing_kinds function — The filter's kinds (e66296bd (1)): only the categories this listing's items carry, so a
• listing_script function — The site script, its words baked in from WORDS.
• load_site_title function
• note_item function — A post as a listing shows it: what its page states (site.stated, the one reader).
• output_href function
• page_item function — A collection page as a listing shows it (the logs index's series, the learning paths): its
• render_listing function — The listing's markup: a container carrying the filter's data, an ordered list of the items,
• sort_rows function — The rows in the order a listing shows them, each term applied as a stable sort from the last
• title_html function — A title is the author's markdown: Quarto rendered a listed title through Pandoc (its smart

cjm_context_graph_projection.sitepages

• check_category_listing function — The category listing a Lens projects (design ce17606b (3)) is the page every chip links
• check_page_outputs function — Every Series or Lens page the build projected has its rendered page (the guard's check,
• group_through_series function — A Lens with view.group_by "series" lists a member THROUGH its Series page (design 7657c4a5
• hub_order function — The pages a listing links in the order the listing SHOWS them: its sort applied to what the
• is_generated function
• is_public function — A publish_state decides (public only when published); with none, a Note of an ARCHIVE
• member_updated function — last-modified is a file mtime (a checkout time, not an edit), so it never counts.
• page_plan function — Plan every projected page: a Series or Lens with an active site_path gets one; a broken
• page_source function — The source a page's output is rendered from: Quarto's output file with .qmd.
• parse_date function
• project_pages function — Write the planned pages into the source tree (only those whose text changed), remove
• render_page function
• unlisted_posts function — The posts a page meant to cover every post leaves out (the category listing, ce17606b (3);

cjm_context_graph_projection.sitetheme

• bound_system function — The design system the binding names, read from the sibling at its latest capture.
• mode_pair function — The light / dark pair: the profile's facts, else the system's scheme map (9a7224a7 (3)).
• profile_key function
• project_theme function — Write the profile's theme from its bound design system (the module docstring's steps).
• site_binding function — The profile Entity, its ONE STYLED_BY Reference and its mode facts.
• system_fonts function — THE FONT SEAM (amendment 4b58c9db (2)): the files the captured tokens name, found beside
• theme_wanted function

cjm_context_graph_projection.source_state

• IdentityWalk class — The identity map's walk ONE RECORD AT A TIME — the step symbol_identity_map folds
• SymbolIdentity class — Container-independent CodeSymbol identity, DERIVED from the source journal (36f649d3).
• append_elements function — Append one write's element records under ONE op-clock time: they fold as one group (the
• append_register function — Append a register event — repo inventory as JOURNAL DATA (DEC c47912f6).
• append_retire function — Append a retire op ending a module key's journal life.
• birth_form function — What a module born at this path lands as its text: born captured (the ruling bef8e6b8), its
• canonicalization_report function — What a canonicalization CHANGES, and whether the change can alter runtime behaviour
• collect_appends function — Collect every source-journal record appended inside the block, as it landed on disk.
• derive_import_name function — A module's dotted import name from its repo-relative path ("pkg/sub.py" -> "pkg.sub");
• element_absorb function — One captured module's write at element grain -- element_plan over a single emission (a file
• element_plan function — The element regime's part of one write (abfc2829 (7), design detail aba8ec79): every emission
• emit_source_artifact function — (Re)generate a module's file artifact from its journaled source (the recovery /
• flip_module function — Absorb a module's FILE into the source journal at element grain (abfc2829 (7)): a captured
• is_test_module_path function — Whether a module path denotes TEST source (tests/ or tests_manual/) -- the code fold's
• journal_repos function — The on-graph repos — DERIVED from the journal (finding 7a2d54ae): a repo is on-graph
• journaled_emit function — The ops seam (pillar 1 of DEC 6ee4b4f2): events BEFORE files — THE file-write path.
• latest_source_ops function — The LATEST source state per module, over both regimes (codesource.SourceState): before a
• notebook_to_py_source function — Build a plain-.py module source from a notebook's EXPORT cells (the flip transform).
• read_source_journal function — Read every source op across the rotated SEGMENT FAMILY (one JSON object per
• source_check function — The regen gate over every live module: two checks each.
• symbol_identity_map function — Derive the container-independent symbol identity map from the source journal (36f649d3).
• uncaptured_modules function — The uncaptured-module audit (build a6453f70) — the ac3d52f4 recipe as a verb.

cjm_context_graph_projection.sourcemoves

• attribute_moved_sources function — Every source whose HEAD differs between the two records, with the element ids its moved
• moved_element_ids function — Decompose every kept path that changed between a and b, at both versions; a source
• source_lane function — The ingest's own view of one source: which paths it reads and what each version of a

cjm_context_graph_projection.sources

• apply_source_facts function — Land an observation's facts on its Reference -- live and replay alike. An unchanged value
• citation_text function — A citation's parts as one line, in the order a reader reads them.
• collection_members function — A Collection's member Sources in the sibling, read with the observation.
• draws_plan function — Each rendered post's draws-on block; every source a post derives from that the Library
• load_sources function — Every Note's sources -- its DERIVED_FROM References to a Source or a Collection, each
• observed_facts function — The facts a source states about itself, read at observation (722a8232 (1), (2)); its
• render_draws function — What the post draws on (design 37f82f72 (2)): each work or unit named from the Library's
• source_text function

cjm_context_graph_projection.standing

• load_relocations function — Every RELOCATED_TO edge, its web Reference read back to the URL it keys.
• load_standing function — Every page's standing over the live graph.
• matches function — The --standing filter the standing, traffic and inbound-links reads share.
• project_standing function — The pure projection (no graph access): see the module docstring for the rules. A row is
• standing_label function — One page's standing in a word or two: the label, superseded beside it when it is.
• standing_report function — The disposition worklist as a read (9a21e345): each page's standing, and with evidence
• support_standing function — What a page's standing does to the claim support it gives (cbd5f154 (6)): a superseded

cjm_context_graph_projection.structure

• add_section function — Add a section to an existing note (append, or insert after an anchor), born on-graph.
• born_post_path function — Where a born post's file lives — DERIVED from the config's emit root and the slug, never
• new_note function — Create a brand-new note, born on-graph (write the .md + ingest it this session).
• reconstruct_note function — Reconstruct a whole note (Note + ordered Section nodes) FROM JOURNALED text — the M3

cjm_context_graph_projection.tutorialspage

• anchor function — A section anchor from vocabulary keys (never a node id).
• hardware_marks function — The verification marks per deliverable: STATED evidence under every profile, the
• learning_paths function — The collection pages whose listed members are ALL tutorials; a collection mixing
• plan_matrix_page function — Plan the Tutorials page: the listed population under the profile, the matrix over it,
• render_body function — The grid, the learning paths, the tutorials by task, the off-grid list, and (staging)

cjm_context_graph_projection.viz

• project_viz function — Project the readiness frontier into a self-contained interactive HTML page.
• render_viz_html function — Render the elements into one self-contained interactive HTML page (Cytoscape + dagre).
• viz_elements function — Pure: turn a readiness frontier into Cytoscape elements — the whole data model.

cjm_context_graph_projection.workbench

• anchor_lead_view function — One anchor's LEAD as STRUCTURE (DEC ee9e9be6): the navigable pin tree.
• journal_ops function — The feed's OP-LEDGER zoom (DEC ee9e9be6): one row per journaled op.
• portfolio_view function — The workbench FRONT DOOR (DEC ee9e9be6): every role-asserted anchor, one row.
• session_feed function — The TWO-ZOOM session feed (DEC ee9e9be6): op ledger + touched-node cards.

cjm_context_graph_projection.worklist

• dangling_reference_proposals function — Referenced [[slugs]] with no note, each with a fuzzy suggestion (no auto-fix).
• dangling_reference_sources function — The note ids whose [[wiki-links]] include drifted_slug (alias evidence).
• worklist function — Assemble the propose/confirm worklist (graph signals + optional corpus triage).

cjm_context_graph_projection.write

• FactBatch class — One batch's view of the fact layer (finding da6cdab6): every Assertion by slot and every
• add_check function — Attach a definition-of-done check to a work item (DoD-as-graph-objects).
• alias function — Confirm a drifted link slug as an alias OF a real note (the worklist payoff).
• assert_value function — Write one value to a (subject, predicate) slot, recording any conflict.
• author_section function — Apply a memory section's verbatim raw STATE to the graph — the born-on-graph leg
• confirm_proposal function — CONFIRM a proposal: apply its drafted section raw to the deliverable, then re-assert
• content_hash_of function — The content an approval binds to (design 40622922): a Note hashes as its lossless
• decide function — Record a Decision + its SUPPORTED_BY premise edges (reasoning substrate).
• link function — Mint a deliberate edge between two EXISTING nodes (heterogeneous interlink).
• link_op function — A link's op: the RESOLVED ids (a prefix resolves against today's db; replay must land on
• mint_procedure function — Upsert a Procedure node by deterministic (method) id — the programmatic value-source
• mint_proposal function — Mint a PROPOSAL — an agent-drafted update for ONE section of a stale deliverable
• observe_foreign function — Open the sibling graph READ-ONLY, resolve the foreign node, and take the observation.
• register_session function — Register/update a timestamp-keyed Session node — the session SPINE (DEC 6124d8bf).
• resolve_subject function — Resolve a subject to an entity id (rename-stable), minting a term entity
• retract_session function — RETRACT a Session spine node — the write dual of register_session, on
• unlink function — RETRACT a deliberate edge — the write dual of link (finding 2f1d9382).

cjm_context_graph_projection.writes

• InvocationWrites class — One invocation's unit of work on its graph's writes journal (65f4a6c9): begin() before
• Written class — What one write did: the core verb's result, and whether its op was appended (False only
• adopt_cursor function — The one-time adoption of a db written before the cursor existed (65f4a6c9 (2c)): its
• cursor_report function — A READER's view of the write order (65f4a6c9 (2d)): where the db's cursor stands and how

Dependencies

Depends on: beautifulsoup4, cjm-context-graph-layer, cjm-context-graph-primitives, cjm-design-system, cjm-dev-graph-schema, cjm-harness-transcripts, cjm-markdown-decompose-core, cjm-notebook-decompose-core, cjm-python-decompose-core, cjm-substrate, pypdf, pyyaml, websocket-client Used by: cjm-graph-workbench-qt, cjm-notebook-decompose-core, cjm-session-scratchpad-qt, cjm-substrate