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.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.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.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.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.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.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.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.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 — N+3 Phase 1 (SHADOW): capture a module's canonical source into a SOURCE journal and
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.

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 / .ipynb / .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.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`

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.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.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
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).
group_by_slot function — Group assertion nodes by their slot_id property.
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 (bounded by limit).
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
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`

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.
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.
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.module_ops`

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 golden-reference flip, ONE LOUD VERB (DEC b2c5363d): notebook -> plain .py.
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.
ingest_records function
journal_write function — The journal-first write path every authoring verb takes: build the records from the
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_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.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.
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`

diff_graphs function — The pure comparison: node and edge id sets, then every field on each shared id.
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), or the report as JSON for agents. Rows a

`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.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.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.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).
absorb_authored_text function — Absorb an author edit of a GRAPH-SOURCED module into the source journal.
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.
append_source function — Append a source op, skipping a write identical to the module's current latest state.
canonical_emit function — Decompose source text and re-emit it canonically — the exact graph→.py Phase 2 yields.
canonical_emit_notebook function — The notebook analogue of canonical_emit: parse to cells, re-render canonically.
collect_appends function — Collect every source-journal record appended inside the block, as it landed on disk.
cutover_module function — Phase 2: make the JOURNAL the module's source of truth (the persistence flip).
emit_source_artifact function — (Re)generate a module's file artifact from its journaled source (the recovery /
flip_module function — Capture a module's CANONICAL source into the shadow source journal (Phase 1).
graph_sourced_modules function — The modules whose ingest source IS the journal (a cutover op exists for them).
is_test_module_path function — Whether a module path denotes TEST source (tests/ or tests_manual/).
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 (last write wins — the 'journal STATE, not diff'
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 soak instrument: for each shadow-sourced module, check two things.
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`

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).
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).

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

Metadata

Release files for cjm-context-graph-projection 0.0.84

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for cjm-context-graph-projection 0.0.84
File	Size	Uploaded
cjm_context_graph_projection-0.0.84.tar.gz	1.1 MB	Oct 10, 2026	Details

Built distribution (wheel)

Table of built distributions (wheels) for cjm-context-graph-projection 0.0.84
File	Interpreter	ABI	Platform	Reset
cjm_context_graph_projection-0.0.84-py3-none-any.whl 856.3 kB Oct 10, 2026	Python 3	none	any	Details

Total release size: 2.0 MB

Release files / cjm_context_graph_projection-0.0.84.tar.gz

Download URL	cjm_context_graph_projection-0.0.84.tar.gz
Size	1.1 MB
Tags	Source
SHA-256 checksum How to use checksums	`ad3ee2f145c165c8bd2fbbf9e56a4981da7f8cea3fcb08ed24a7dc534d49283c`
BLAKE2b-256 checksum How to use checksums	`d6c14d6b33a67e8a10ba6df3c0ccd0f08bbdc8b1521ec385b566572f7708d9f7`
Upload date	Oct 10, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/6.2.0 CPython/3.12.12`

Release files / cjm_context_graph_projection-0.0.84-py3-none-any.whl

Download URL	cjm_context_graph_projection-0.0.84-py3-none-any.whl
Size	856.3 kB
Tags	Python 3
SHA-256 checksum How to use checksums	`3776215df9410280ae234c0dd83be6c4639ed81140d25340b47ec193ab86fe73`
BLAKE2b-256 checksum How to use checksums	`59da69271d333344629b1f3c237c39e9738133f9184ebcad6e93bf96997a6d60`
Upload date	Oct 10, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/6.2.0 CPython/3.12.12`