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.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.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.explorer_page — The graph EXPLORER client page — the first client of the serve data API.
• 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.hybrid_page — The HYBRID graph explorer client — GPU physics canvas + DOM overlay (check-in 1233ab46).
• cjm_context_graph_projection.journal — The write journal: the durable, replayable source of truth for born-on-graph writes.
• 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.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.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.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.sitelinks — In-body site links, RESOLVED through site_path facts (DEC 72d669c5 (1); the step, 9ee4e346).
• 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.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.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.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 from the site config: a missing key or summary refuses (the build
• 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
• 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.
• 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

• 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/
• 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.claims

• claims_report function — The claims over the live graph: every claim Entity with its state and 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_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.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_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.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.judging

• apply_judgments function — Land one judge run: every stored judgment touching a re-judged post is replaced by the
• http_ask function — The HTTP judge: one POST per pair, retried with backoff on overload and network faults.
• 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.
• question_hash function — The questions' identity: a changed question makes every judgment stale.
• read_key function — The key from KEY_ENV, else KEY_FILE -- never printed, never journaled.
• 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_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 Lens pages: a Lens page whose listed members are all notes; one mixing notes
• 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.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.postpage

• 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}; any other placeholder refuses.
• 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
• license_facts function — The license facts (39c51c15 (6)): per deliverable class on the DeliverableType, per
• load_holder function — The copyright holder the footer names (copyright-holder in the site config): a missing
• load_site_author function — The site's one statement of its author (site-author 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
• 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

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.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_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.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.sitepages

• 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
• 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

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.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 slot, 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: 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, pyyaml Used by: cjm-graph-workbench-qt, cjm-notebook-decompose-core, cjm-session-scratchpad-qt