Metadata-Version: 2.4
Name: cjm-context-graph-projection
Version: 0.0.76
Summary: 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.
Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
License: Apache-2.0
Project-URL: Repository, https://github.com/cj-mills/cjm-context-graph-projection
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Python: >=3.12
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: cjm-substrate>=0.0.52
Requires-Dist: cjm-context-graph-layer>=0.0.12
Requires-Dist: cjm-context-graph-primitives>=0.0.13
Requires-Dist: cjm-dev-graph-schema>=0.0.27
Requires-Dist: cjm-markdown-decompose-core>=0.0.12
Requires-Dist: cjm-python-decompose-core>=0.0.7
Requires-Dist: cjm-notebook-decompose-core>=0.0.4
Requires-Dist: cjm-harness-transcripts>=0.0.2
Requires-Dist: pyyaml>=6.0
Dynamic: license-file

# cjm-context-graph-projection

<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->

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 *<work>*"
- `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`
