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.authoring — The B write surface: AUTHOR a verbatim-text slot on-graph, emit the canonical artifact.
• 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.cohesion — Module cohesion audit over the code graph — the read-only cohesion ORACLE (N+1).
• 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.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.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.lens — Lenses: graph-carried, parameterized views (DEC f1b02b95 — tier 2 of the
• 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.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.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 — Live re-derivation of a module's region nodes from its new text (36f649d3).
• 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.serve — A served, read-only graph EXPLORER data API over the read verbs — the richer-viz INSTRUMENT.
• 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.structure — M2a GRADIENT — structural memory authoring: create a note / add a section, born on-graph.
• 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.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.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.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.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.devgraph

• build_dev_graph_elements function — Assemble the full dev graph: memory notes (+ refs), the repo map (+ deps),
• code_elements function — Decompose each repo's importable package into code nodes + edges.
• memory_elements function — Decompose every memory markdown file (except MEMORY.md) into graph elements.
• notebook_elements function — Decompose each repo's nbdev notebooks into code/cell nodes + edges.
• notes_corpus_elements function — Decompose an arbitrary <dir>/index.md markdown corpus into graph elements.
• repo_map_elements function — One repo Entity per cjm-* repo (RENAME-STABLE keys) + DEPENDS_ON from pyproject.
• resolve_corpus_code_edges function — Resolve CALLS/IMPORTS edges ACROSS the whole code + notebook corpus.
• resolve_test_edges function — Resolve TESTS edges across the corpus (the code<->test link).
• stamp_note_profile function — Record the relationship-harvest profile on every Note wire dict (in place).
• test_elements function — Decompose each repo's pytest / manual test files into code nodes + edges.

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.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.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.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 — drop its file and its whole graph subtree. Guarded: refuses while
• flip_notebook_to_py function — The golden-reference flip, ONE LOUD VERB (DEC b2c5363d): notebook -> plain .py.
• new_module function — Mint an empty CodeModule node (the target a regroup/move populates).
• 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.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
• 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
• 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.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

• relive_module function — The single-module form of relive_modules.
• relive_modules function — Re-derive several modules' region nodes LIVE in one pass — the batch form a move

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

• 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.
• 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/).
• 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.structure

• add_section function — Add a section to an existing note (append, or insert after an anchor), born on-graph.
• 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.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-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