cjm-transcript-correction-core 0.0.1__tar.gz → 0.0.2__tar.gz

{cjm_transcript_correction_core-0.0.1/cjm_transcript_correction_core.egg-info → cjm_transcript_correction_core-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-correction-core
-Version: 0.0.1
+Version: 0.0.2
 Summary: A frontend-agnostic core for the transcript correction workflow — the first downstream graph-extension core; composes the graph-storage capability worker into a headless pipeline that applies unified, non-destructive corrections (text, punctuation, segmentation) as a supersede-able overlay on a committed decomposition spine, recomputes the review worklist from deterministic signals, and exposes a CLI as its first driver.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -11,7 +11,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cjm_substrate>=0.0.51
-Requires-Dist: cjm_context_graph_primitives>=0.0.12
+Requires-Dist: cjm_context_graph_primitives>=0.0.14
 Requires-Dist: cjm-context-graph-layer>=0.0.8
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
@@ -26,12 +26,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 
 - **`cjm_transcript_correction_core.cli`** — The CLI driver — the correction core's first (and currently only) frontend. run <decomp-manifest> corrects the committed spine in the decomp graph DB, pointing the graph worker at that shared DB via load-time config, with optional session resume/reopen; review runs the interactive text-correction loop (the cross-transcriber diff is intra-graph since stage 5).
 - **`cjm_transcript_correction_core.graph`** — The correction overlay's graph I/O: targeted (scale-shaped) reads of a committed spine via the graph-storage query action, construction of Correction / CorrectionSession nodes + CORRECTS / SUPERSEDES / DERIVED_FROM / REVIEWED edges, the in-core effective-spine projection (layer-0 + applied corrections), and commit through the job queue. Hand-rolled (revolution-1) = direct CR-18 spec material; append-only on layer-0 (never update/delete a Segment).
+- **`cjm_transcript_correction_core.journal`**
 - **`cjm_transcript_correction_core.models`** — Overlay data shapes for the transcript-correction workflow: the Correction / CorrectionSession graph nodes + their relation registry, the read view of a committed spine segment, the worklist item, run configuration, and the correction run manifest (proto-bundle that chains decomp -> correction).
 - **`cjm_transcript_correction_core.pipeline`** — The headless correction workflow: load a decomp run manifest, resolve the shared graph DB, start/resume/reopen a CorrectionSession, recompute the worklist from deterministic signals + persisted review state, run the D14 empty-segment prune (first operation), and record a chainable correction run manifest — with a cheapest-form HITL approval seam.
 - **`cjm_transcript_correction_core.signals`** — Pure deterministic Tier-1 signal functions (no capability calls): empty-segment detection, bidirectional boundary punctuation/capitalization heuristics, forced-alignment coverage flags, positional cross-transcriber diff, and phonetic + edit-distance variant clustering. The worklist is recomputed from these each session; revolution-1 builds ZERO new capabilities.
-- **`tests.test_graph`** — Tests for cjm_transcript_correction_core.graph — overlay construction + effective spine.
-- **`tests.test_models`** — Tests for cjm_transcript_correction_core.models — correction overlay data shapes.
-- **`tests.test_signals`** — Tests for cjm_transcript_correction_core.signals — pure deterministic Tier-1 signals.
 
 ## API
 
@@ -46,10 +44,15 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 ### `cjm_transcript_correction_core.graph`
 
 - `active_corrections` _function_ — Filter to the effective correction set (the layer's resolve_active over a read superseded set).
+- `build_boundary_shift_correction` _function_ — Build a grouping Correction that moves text across one segment boundary.
 - `build_correction_node` _function_ — Construct a Correction overlay node (pure; commit happens separately).
+- `build_prune_amendment` _function_ — Build a grouping Correction that supersedes a prune with a REDUCED set (unprune).
 - `build_prune_correction` _function_ — Build one batch grouping Correction that prunes empty segments (D14).
+- `build_reject_review` _function_ — Build a review Correction that REJECTS a prior correction (reject-as-supersede).
 - `build_text_correction` _function_ — Build a text_content Correction + its CORRECTS (+ optional SUPERSEDES) edges.
+- `commit_boundary_shift_correction` _function_ — Commit a boundary-shift correction (node + CORRECTS x2 [+ SUPERSEDES]) + REVIEWED markers on both segments.
 - `commit_nodes_edges` _function_ — Commit overlay nodes/edges through the layer's idempotent extend_graph.
+- `commit_prune_amendment` _function_ — Commit an unprune amendment (node + DERIVED_FROM edges + SUPERSEDES).
 - `commit_text_correction` _function_ — Commit a text_content correction (node + CORRECTS [+ SUPERSEDES]) + a REVIEWED marker.
 - `corrections_to_edits` _function_ — Map this core's Correction payloads onto the layer's spine-edit vocabulary.
 - `count_source_segments` _function_ — Count a Source's segments server-side under its chosen rendition (typed count mode).
@@ -71,6 +74,13 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `start_session` _function_ — Create + commit a new CorrectionSession node.
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, return its result (raise on failure).
 
+### `cjm_transcript_correction_core.journal`
+
+- `correction_replay_handlers` _function_ — The correction core's registered replay vocabulary (replay stays DOMAIN-OWNED).
+- `journal_correction_op` _function_ — Append one correction op — envelope + semantic args + the EXACT wires committed.
+- `segment_anchor` _function_ — The run-independent anchor stamped on every correction op (DEC ccbab9f5 point 5).
+- `sidecar_journal_path` _function_ — The db's sidecar journal path (DEC ccbab9f5 point 3: placement is per-workflow,
+
 ### `cjm_transcript_correction_core.models`
 
 - `Correction` _class_ — A single non-destructive correction over the committed spine (overlay node).
@@ -105,31 +115,7 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `phonetic_key` _function_ — Compute a coarse phonetic key for a word (groups like-sounding variants).
 - `variant_divergence` _function_ — Within-segment cross-transcriber divergence (stage 5: intra-graph).
 
-### `tests.test_graph`
-
-- `test_build_prune_correction` _function_
-- `test_build_text_correction_and_active_filter` _function_
-- `test_latest_wins_ordering_from_layer` _function_
-- `test_project_effective_spine_prune_replace_supersede` _function_
-
-### `tests.test_models`
-
-- `test_correction_graph_node_mapping` _function_
-- `test_correction_relations_registry` _function_
-- `test_correction_session_node` _function_
-- `test_manifest_save_round_trip` _function_
-- `test_manifest_shape_and_run_id` _function_
-- `test_spine_segment_and_worklist_item` _function_
-
-### `tests.test_signals`
-
-- `test_boundary_punct_caps_flags` _function_
-- `test_clustering_primitives` _function_
-- `test_compute_signal_flags_combined` _function_
-- `test_empty_and_coverage_flags` _function_
-- `test_variant_divergence_within_segment` _function_
-
 ## Dependencies
 
-**Depends on:** `cjm-substrate`
+**Depends on:** `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`
 **Used by:** `cjm-transcript-correction-tui`

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2}/README.md

@@ -8,12 +8,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 
 - **`cjm_transcript_correction_core.cli`** — The CLI driver — the correction core's first (and currently only) frontend. run <decomp-manifest> corrects the committed spine in the decomp graph DB, pointing the graph worker at that shared DB via load-time config, with optional session resume/reopen; review runs the interactive text-correction loop (the cross-transcriber diff is intra-graph since stage 5).
 - **`cjm_transcript_correction_core.graph`** — The correction overlay's graph I/O: targeted (scale-shaped) reads of a committed spine via the graph-storage query action, construction of Correction / CorrectionSession nodes + CORRECTS / SUPERSEDES / DERIVED_FROM / REVIEWED edges, the in-core effective-spine projection (layer-0 + applied corrections), and commit through the job queue. Hand-rolled (revolution-1) = direct CR-18 spec material; append-only on layer-0 (never update/delete a Segment).
+- **`cjm_transcript_correction_core.journal`**
 - **`cjm_transcript_correction_core.models`** — Overlay data shapes for the transcript-correction workflow: the Correction / CorrectionSession graph nodes + their relation registry, the read view of a committed spine segment, the worklist item, run configuration, and the correction run manifest (proto-bundle that chains decomp -> correction).
 - **`cjm_transcript_correction_core.pipeline`** — The headless correction workflow: load a decomp run manifest, resolve the shared graph DB, start/resume/reopen a CorrectionSession, recompute the worklist from deterministic signals + persisted review state, run the D14 empty-segment prune (first operation), and record a chainable correction run manifest — with a cheapest-form HITL approval seam.
 - **`cjm_transcript_correction_core.signals`** — Pure deterministic Tier-1 signal functions (no capability calls): empty-segment detection, bidirectional boundary punctuation/capitalization heuristics, forced-alignment coverage flags, positional cross-transcriber diff, and phonetic + edit-distance variant clustering. The worklist is recomputed from these each session; revolution-1 builds ZERO new capabilities.
-- **`tests.test_graph`** — Tests for cjm_transcript_correction_core.graph — overlay construction + effective spine.
-- **`tests.test_models`** — Tests for cjm_transcript_correction_core.models — correction overlay data shapes.
-- **`tests.test_signals`** — Tests for cjm_transcript_correction_core.signals — pure deterministic Tier-1 signals.
 
 ## API
 
@@ -28,10 +26,15 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 ### `cjm_transcript_correction_core.graph`
 
 - `active_corrections` _function_ — Filter to the effective correction set (the layer's resolve_active over a read superseded set).
+- `build_boundary_shift_correction` _function_ — Build a grouping Correction that moves text across one segment boundary.
 - `build_correction_node` _function_ — Construct a Correction overlay node (pure; commit happens separately).
+- `build_prune_amendment` _function_ — Build a grouping Correction that supersedes a prune with a REDUCED set (unprune).
 - `build_prune_correction` _function_ — Build one batch grouping Correction that prunes empty segments (D14).
+- `build_reject_review` _function_ — Build a review Correction that REJECTS a prior correction (reject-as-supersede).
 - `build_text_correction` _function_ — Build a text_content Correction + its CORRECTS (+ optional SUPERSEDES) edges.
+- `commit_boundary_shift_correction` _function_ — Commit a boundary-shift correction (node + CORRECTS x2 [+ SUPERSEDES]) + REVIEWED markers on both segments.
 - `commit_nodes_edges` _function_ — Commit overlay nodes/edges through the layer's idempotent extend_graph.
+- `commit_prune_amendment` _function_ — Commit an unprune amendment (node + DERIVED_FROM edges + SUPERSEDES).
 - `commit_text_correction` _function_ — Commit a text_content correction (node + CORRECTS [+ SUPERSEDES]) + a REVIEWED marker.
 - `corrections_to_edits` _function_ — Map this core's Correction payloads onto the layer's spine-edit vocabulary.
 - `count_source_segments` _function_ — Count a Source's segments server-side under its chosen rendition (typed count mode).
@@ -53,6 +56,13 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `start_session` _function_ — Create + commit a new CorrectionSession node.
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, return its result (raise on failure).
 
+### `cjm_transcript_correction_core.journal`
+
+- `correction_replay_handlers` _function_ — The correction core's registered replay vocabulary (replay stays DOMAIN-OWNED).
+- `journal_correction_op` _function_ — Append one correction op — envelope + semantic args + the EXACT wires committed.
+- `segment_anchor` _function_ — The run-independent anchor stamped on every correction op (DEC ccbab9f5 point 5).
+- `sidecar_journal_path` _function_ — The db's sidecar journal path (DEC ccbab9f5 point 3: placement is per-workflow,
+
 ### `cjm_transcript_correction_core.models`
 
 - `Correction` _class_ — A single non-destructive correction over the committed spine (overlay node).
@@ -87,31 +97,7 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `phonetic_key` _function_ — Compute a coarse phonetic key for a word (groups like-sounding variants).
 - `variant_divergence` _function_ — Within-segment cross-transcriber divergence (stage 5: intra-graph).
 
-### `tests.test_graph`
-
-- `test_build_prune_correction` _function_
-- `test_build_text_correction_and_active_filter` _function_
-- `test_latest_wins_ordering_from_layer` _function_
-- `test_project_effective_spine_prune_replace_supersede` _function_
-
-### `tests.test_models`
-
-- `test_correction_graph_node_mapping` _function_
-- `test_correction_relations_registry` _function_
-- `test_correction_session_node` _function_
-- `test_manifest_save_round_trip` _function_
-- `test_manifest_shape_and_run_id` _function_
-- `test_spine_segment_and_worklist_item` _function_
-
-### `tests.test_signals`
-
-- `test_boundary_punct_caps_flags` _function_
-- `test_clustering_primitives` _function_
-- `test_compute_signal_flags_combined` _function_
-- `test_empty_and_coverage_flags` _function_
-- `test_variant_divergence_within_segment` _function_
-
 ## Dependencies
 
-**Depends on:** `cjm-substrate`
+**Depends on:** `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`
 **Used by:** `cjm-transcript-correction-tui`

cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.2"

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2}/cjm_transcript_correction_core/graph.py

@@ -14,6 +14,7 @@ from cjm_context_graph_primitives.query import (EdgeQuery, EdgeQueryResult, Node
                                                 NodeQueryResult, OrderBy, PropertyPredicate,
                                                 RelationPredicate, SourcePredicate)
 from cjm_substrate.core.queue import JobQueue, JobStatus
+from cjm_transcript_correction_core.journal import journal_correction_op, segment_anchor
 from cjm_transcript_correction_core.models import (Correction, CorrectionRelations,
                                                    CorrectionSession, SpineSegment)
 from cjm_transcript_graph_schema.schema import TranscriptGraphLabels
@@ -318,10 +319,16 @@ async def start_session(
     queue: JobQueue,   # Started job queue
     graph_id: str,     # Graph-storage capability id
     scope: List[str],  # Source node ids in scope
+    journal_path: Optional[str] = None,  # Sidecar journal — append the op on success (None = unjournaled)
 ) -> CorrectionSession:  # The committed CorrectionSession
     """Create + commit a new CorrectionSession node."""
     sess = CorrectionSession(scope=scope)
-    await commit_nodes_edges(queue, graph_id, [sess.to_graph_node().to_dict()], [])
+    node = sess.to_graph_node().to_dict()
+    await commit_nodes_edges(queue, graph_id, [node], [])
+    if journal_path:
+        journal_correction_op(journal_path, "session-start", actor="human",
+                              session_id=node["id"], args={"scope": scope},
+                              nodes=[node], edges=[], op_id=node["id"])
     return sess
 
 
@@ -342,14 +349,23 @@ async def set_session_status(
     graph_id: str,    # Graph-storage capability id
     session_id: str,  # CorrectionSession node id
     status: str,      # New status ("in_progress" | "completed" | "reopened")
+    journal_path: Optional[str] = None,  # Sidecar journal — append the op on success (None = unjournaled)
 ) -> None:
     """Update a session's status + updated_at.
 
     The ONLY update_node use in this core: a CorrectionSession is OVERLAY metadata
     whose lifecycle is mutable. Layer-0 Segments + Corrections stay append-only.
+    Its journal op replays via update_node (last-wins in append order), not wires.
     """
+    ts = time.time()
     await graph_task(queue, graph_id, "update_node", node_id=session_id,
-                     properties={"status": status, "updated_at": time.time()})
+                     properties={"status": status, "updated_at": ts})
+    if journal_path:
+        journal_correction_op(journal_path, "session-status", actor="human",
+                              session_id=session_id,
+                              args={"session_id": session_id, "status": status,
+                                    "updated_at": ts},
+                              nodes=[], edges=[])
 
 
 async def record_review_markers(
@@ -357,11 +373,21 @@ async def record_review_markers(
     graph_id: str,                     # Graph-storage capability id
     session_id: str,                   # Owning session id
     decisions: List[Tuple[str, str]],  # (segment_id, decision) pairs
+    journal_path: Optional[str] = None,  # Sidecar journal — append the op on success (None = unjournaled)
 ) -> int:  # Number of REVIEWED edges committed
     """Persist per-(session, segment) review markers as REVIEWED edges."""
     edges = [_edge(session_id, seg_id, CorrectionRelations.REVIEWED, {"decision": dec})
              for seg_id, dec in decisions]
-    return (await commit_nodes_edges(queue, graph_id, [], edges))["edges"]
+    n = (await commit_nodes_edges(queue, graph_id, [], edges))["edges"]
+    if journal_path:
+        # No anchor: markers are derivative session state — the CORRECTION op carries
+        # the anchor (DEC ccbab9f5 point 5 scopes anchors to correction ops), and the
+        # extra segment reads priced the TUI keystroke (journal-lag finding).
+        journal_correction_op(journal_path, "review-markers", actor="human",
+                              session_id=session_id,
+                              args={"decisions": [list(d) for d in decisions]},
+                              nodes=[], edges=edges)
+    return n
 
 
 async def load_review_markers(
@@ -526,13 +552,24 @@ async def commit_text_correction(
     supersedes_id: Optional[str] = None,   # Prior Correction to supersede (re-edit)
     actor: str = "human",                  # Actor
     canonical_form: Optional[str] = None,  # Optional entity key
+    journal_path: Optional[str] = None,    # Sidecar journal — append the op on success (None = unjournaled)
 ) -> str:  # The new Correction node id
     """Commit a text_content correction (node + CORRECTS [+ SUPERSEDES]) + a REVIEWED marker."""
     node, edges = build_text_correction(
         source_id, segment_id, new_text, session_id, old_text=old_text,
         supersedes_id=supersedes_id, actor=actor, canonical_form=canonical_form)
     await commit_nodes_edges(queue, graph_id, [node], edges)
-    await record_review_markers(queue, graph_id, session_id, [(segment_id, "corrected")])
+    if journal_path:
+        journal_correction_op(journal_path, "text-correction", actor=actor,
+                              session_id=session_id,
+                              args={"source_id": source_id, "segment_id": segment_id,
+                                    "new_text": new_text, "old_text": old_text,
+                                    "supersedes_id": supersedes_id,
+                                    "canonical_form": canonical_form},
+                              anchor=await segment_anchor(queue, graph_id, [segment_id]),
+                              nodes=[node], edges=edges, op_id=node["id"])
+    await record_review_markers(queue, graph_id, session_id, [(segment_id, "corrected")],
+                                journal_path=journal_path)
     return node["id"]
 
 
@@ -730,14 +767,25 @@ async def commit_boundary_shift_correction(
     session_id: str,                       # Owning session id
     supersedes_id: Optional[str] = None,   # Prior Correction to supersede (re-edit)
     actor: str = "human",                  # Actor
+    journal_path: Optional[str] = None,    # Sidecar journal — append the op on success (None = unjournaled)
 ) -> str:  # The new Correction node id
     """Commit a boundary-shift correction (node + CORRECTS x2 [+ SUPERSEDES]) + REVIEWED markers on both segments."""
     node, edges = build_boundary_shift_correction(
         source_id, left_segment_id, right_segment_id, text, direction, session_id,
         supersedes_id=supersedes_id, actor=actor)
     await commit_nodes_edges(queue, graph_id, [node], edges)
+    if journal_path:
+        journal_correction_op(journal_path, "boundary-shift", actor=actor,
+                              session_id=session_id,
+                              args={"source_id": source_id, "left_segment_id": left_segment_id,
+                                    "right_segment_id": right_segment_id, "text": text,
+                                    "direction": direction, "supersedes_id": supersedes_id},
+                              anchor=await segment_anchor(queue, graph_id,
+                                                          [left_segment_id, right_segment_id]),
+                              nodes=[node], edges=edges, op_id=node["id"])
     await record_review_markers(queue, graph_id, session_id,
-                                [(left_segment_id, "corrected"), (right_segment_id, "corrected")])
+                                [(left_segment_id, "corrected"), (right_segment_id, "corrected")],
+                                journal_path=journal_path)
     return node["id"]
 
 
@@ -776,8 +824,15 @@ async def commit_prune_amendment(
     unprune_ids: List[str],     # Segment ids rescued from the prune set
     session_id: str,            # Owning session id
     actor: str = "human",       # Actor
+    journal_path: Optional[str] = None,  # Sidecar journal — append the op on success (None = unjournaled)
 ) -> Dict[str, Any]:  # The amended correction as a property dict + id (local-echo ready)
     """Commit an unprune amendment (node + DERIVED_FROM edges + SUPERSEDES)."""
     node, edges = build_prune_amendment(prior, unprune_ids, session_id, actor=actor)
     await commit_nodes_edges(queue, graph_id, [node], edges)
+    if journal_path:
+        journal_correction_op(journal_path, "prune-amendment", actor=actor,
+                              session_id=session_id,
+                              args={"prior_id": prior.get("id"), "unprune_ids": unprune_ids},
+                              anchor=await segment_anchor(queue, graph_id, unprune_ids),
+                              nodes=[node], edges=edges, op_id=node["id"])
     return _node_to_correction_dict(node)

cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core/journal.py

@@ -0,0 +1,116 @@
+"""Live append-through for the correction verbs — the workflow journal's domain half.
+
+Every correction commit appends its op to the sidecar journal (DEC ccbab9f5): the
+ENVELOPE (op id = minted Correction id, actor, set = session id, run-independent
+segment ANCHOR) keeps each op a legible dataset row; the exact WIRES committed make
+replay faithful to what WAS written (builder evolution can never drift a rebuild —
+store the effect, not the recipe). Replay handlers register onto
+`cjm_context_graph_layer.journal.replay_journal` (replay stays domain-owned); the
+append discipline lives in `cjm_context_graph_primitives.journal`.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from cjm_context_graph_layer.ops import extend_graph, graph_task
+from cjm_context_graph_primitives.journal import append_op
+from cjm_context_graph_primitives.query import NodeQuery
+
+
+def sidecar_journal_path(
+    db_path: str,  # The workflow graph db path (e.g. .../context_graph.db)
+) -> str:  # The sidecar write-journal path next to it (.../context_graph.writes.jsonl)
+    """The db's sidecar journal path (DEC ccbab9f5 point 3: placement is per-workflow,
+    NEXT TO the db it is the source of truth for). Derived, never configured — one
+    less ambient default (the explicit-db-path guardrail extended to the journal)."""
+    if db_path.endswith(".db"):
+        return db_path[: -len(".db")] + ".writes.jsonl"
+    return db_path + ".writes.jsonl"
+
+
+async def segment_anchor(
+    queue: Any,               # Started job queue
+    graph_id: str,            # Graph-storage capability id
+    segment_ids: List[str],   # The Segment ids the correction touches
+) -> Dict[str, Any]:  # Run-independent anchor: source hashes + per-segment time span + verbatim text
+    """The run-independent anchor stamped on every correction op (DEC ccbab9f5 point 5).
+
+    Segment ids are THIS pipeline run's coordinates; (source content hash, time span,
+    verbatim layer-0 text) survive any re-run — the coordinates the orphan detector's
+    propose/confirm rebind (DEC point 6) matches against. ONE batched segments read
+    per call; Source media hashes are immutable, so they read once per process."""
+    res = await graph_task(queue, graph_id, "query_nodes",
+                           query=NodeQuery(ids=list(segment_ids)).to_dict())
+    segs = sorted(res.nodes or [], key=lambda n: n.properties.get("index") or 0)
+    source_ids = sorted({s.properties.get("source_id") for s in segs
+                         if s.properties.get("source_id")})
+    missing = [sid for sid in source_ids if sid not in _SOURCE_HASH_CACHE]
+    if missing:
+        sres = await graph_task(queue, graph_id, "query_nodes",
+                                query=NodeQuery(ids=missing).to_dict())
+        for s in (sres.nodes or []):
+            hashes = [r.content_hash for r in s.sources if getattr(r, "content_hash", None)]
+            _SOURCE_HASH_CACHE[s.id] = hashes[0] if hashes else None
+    src_hash = {sid: _SOURCE_HASH_CACHE.get(sid) for sid in source_ids}
+    return {
+        "sources": [{"id": sid, "content_hash": src_hash.get(sid)} for sid in source_ids],
+        "segments": [{"id": s.id, "index": s.properties.get("index"),
+                      "start": s.properties.get("start_time"),
+                      "end": s.properties.get("end_time"),
+                      "text": s.properties.get("text")} for s in segs],
+    }
+
+
+def journal_correction_op(
+    journal_path: str,             # Sidecar journal path
+    verb: str,                     # Domain verb ("boundary-shift" | "text-correction" | ...)
+    actor: str,                    # Who decided ("human" | "agent:*" | "import:*")
+    session_id: str,               # The op's SET identity (per-run CorrectionSession)
+    args: Dict[str, Any],          # The semantic call args (the dataset row)
+    nodes: List[Dict[str, Any]],   # The exact node wires committed
+    edges: List[Dict[str, Any]],   # The exact edge wires committed
+    anchor: Optional[Dict[str, Any]] = None,  # Run-independent segment anchor
+    op_id: Optional[str] = None,   # Minted Correction node id (exact-once dedup lane)
+) -> bool:  # True if appended
+    """Append one correction op — envelope + semantic args + the EXACT wires committed.
+
+    Wires make replay faithful to what WAS written (a builder change can never drift a
+    rebuild); args + anchor keep the op a legible dataset row (the north-star pullable-
+    datasets requirement). Appended AFTER the commit succeeds, mirroring the dev-graph
+    append-on-success discipline. dedup=False: the append must stay UI-cheap (a dedup
+    rescan over a genesis-scale journal cost 111ms/op — the TUI keystroke lag finding);
+    id-carrying ops mint a fresh Correction uuid per commit so duplicates are
+    structurally impossible live, and replay converges on collisions regardless."""
+    op: Dict[str, Any] = {"verb": verb, "actor": actor, "set": session_id,
+                          "args": args, "wires": {"nodes": nodes, "edges": edges}}
+    if op_id:
+        op["id"] = op_id
+    if anchor:
+        op["anchor"] = anchor
+    return append_op(journal_path, op, dedup=False)
+
+
+def correction_replay_handlers() -> Dict[str, Any]:  # verb -> async handler(queue, graph_id, op)
+    """The correction core's registered replay vocabulary (replay stays DOMAIN-OWNED).
+
+    Pass to `cjm_context_graph_layer.journal.replay_journal(handlers=...)`: wire-carrying
+    ops re-apply through the layer's idempotent extend (replayed wires collide into
+    verified no-ops); `session-status` is the core's only update_node write, replayed
+    last-wins in append order."""
+    async def _apply_wires(queue: Any, graph_id: str, op: Dict[str, Any]) -> None:
+        w = op.get("wires") or {}
+        await extend_graph(queue, graph_id, w.get("nodes") or [], w.get("edges") or [])
+
+    async def _apply_session_status(queue: Any, graph_id: str, op: Dict[str, Any]) -> None:
+        a = op["args"]
+        await graph_task(queue, graph_id, "update_node", node_id=a["session_id"],
+                         properties={"status": a["status"], "updated_at": a["updated_at"]})
+
+    return {"session-start": _apply_wires, "boundary-shift": _apply_wires,
+            "text-correction": _apply_wires, "prune-amendment": _apply_wires,
+            "review-markers": _apply_wires, "session-status": _apply_session_status}
+
+
+# A Source's content hash is IMMUTABLE — read once per process, not per commit
+# (the per-keystroke Source re-read priced the TUI; ids are uuids, so cross-db
+# collisions within one process cannot occur).
+_SOURCE_HASH_CACHE: Dict[str, Optional[str]] = {}

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-correction-core
-Version: 0.0.1
+Version: 0.0.2
 Summary: A frontend-agnostic core for the transcript correction workflow — the first downstream graph-extension core; composes the graph-storage capability worker into a headless pipeline that applies unified, non-destructive corrections (text, punctuation, segmentation) as a supersede-able overlay on a committed decomposition spine, recomputes the review worklist from deterministic signals, and exposes a CLI as its first driver.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -11,7 +11,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cjm_substrate>=0.0.51
-Requires-Dist: cjm_context_graph_primitives>=0.0.12
+Requires-Dist: cjm_context_graph_primitives>=0.0.14
 Requires-Dist: cjm-context-graph-layer>=0.0.8
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
@@ -26,12 +26,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 
 - **`cjm_transcript_correction_core.cli`** — The CLI driver — the correction core's first (and currently only) frontend. run <decomp-manifest> corrects the committed spine in the decomp graph DB, pointing the graph worker at that shared DB via load-time config, with optional session resume/reopen; review runs the interactive text-correction loop (the cross-transcriber diff is intra-graph since stage 5).
 - **`cjm_transcript_correction_core.graph`** — The correction overlay's graph I/O: targeted (scale-shaped) reads of a committed spine via the graph-storage query action, construction of Correction / CorrectionSession nodes + CORRECTS / SUPERSEDES / DERIVED_FROM / REVIEWED edges, the in-core effective-spine projection (layer-0 + applied corrections), and commit through the job queue. Hand-rolled (revolution-1) = direct CR-18 spec material; append-only on layer-0 (never update/delete a Segment).
+- **`cjm_transcript_correction_core.journal`**
 - **`cjm_transcript_correction_core.models`** — Overlay data shapes for the transcript-correction workflow: the Correction / CorrectionSession graph nodes + their relation registry, the read view of a committed spine segment, the worklist item, run configuration, and the correction run manifest (proto-bundle that chains decomp -> correction).
 - **`cjm_transcript_correction_core.pipeline`** — The headless correction workflow: load a decomp run manifest, resolve the shared graph DB, start/resume/reopen a CorrectionSession, recompute the worklist from deterministic signals + persisted review state, run the D14 empty-segment prune (first operation), and record a chainable correction run manifest — with a cheapest-form HITL approval seam.
 - **`cjm_transcript_correction_core.signals`** — Pure deterministic Tier-1 signal functions (no capability calls): empty-segment detection, bidirectional boundary punctuation/capitalization heuristics, forced-alignment coverage flags, positional cross-transcriber diff, and phonetic + edit-distance variant clustering. The worklist is recomputed from these each session; revolution-1 builds ZERO new capabilities.
-- **`tests.test_graph`** — Tests for cjm_transcript_correction_core.graph — overlay construction + effective spine.
-- **`tests.test_models`** — Tests for cjm_transcript_correction_core.models — correction overlay data shapes.
-- **`tests.test_signals`** — Tests for cjm_transcript_correction_core.signals — pure deterministic Tier-1 signals.
 
 ## API
 
@@ -46,10 +44,15 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 ### `cjm_transcript_correction_core.graph`
 
 - `active_corrections` _function_ — Filter to the effective correction set (the layer's resolve_active over a read superseded set).
+- `build_boundary_shift_correction` _function_ — Build a grouping Correction that moves text across one segment boundary.
 - `build_correction_node` _function_ — Construct a Correction overlay node (pure; commit happens separately).
+- `build_prune_amendment` _function_ — Build a grouping Correction that supersedes a prune with a REDUCED set (unprune).
 - `build_prune_correction` _function_ — Build one batch grouping Correction that prunes empty segments (D14).
+- `build_reject_review` _function_ — Build a review Correction that REJECTS a prior correction (reject-as-supersede).
 - `build_text_correction` _function_ — Build a text_content Correction + its CORRECTS (+ optional SUPERSEDES) edges.
+- `commit_boundary_shift_correction` _function_ — Commit a boundary-shift correction (node + CORRECTS x2 [+ SUPERSEDES]) + REVIEWED markers on both segments.
 - `commit_nodes_edges` _function_ — Commit overlay nodes/edges through the layer's idempotent extend_graph.
+- `commit_prune_amendment` _function_ — Commit an unprune amendment (node + DERIVED_FROM edges + SUPERSEDES).
 - `commit_text_correction` _function_ — Commit a text_content correction (node + CORRECTS [+ SUPERSEDES]) + a REVIEWED marker.
 - `corrections_to_edits` _function_ — Map this core's Correction payloads onto the layer's spine-edit vocabulary.
 - `count_source_segments` _function_ — Count a Source's segments server-side under its chosen rendition (typed count mode).
@@ -71,6 +74,13 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `start_session` _function_ — Create + commit a new CorrectionSession node.
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, return its result (raise on failure).
 
+### `cjm_transcript_correction_core.journal`
+
+- `correction_replay_handlers` _function_ — The correction core's registered replay vocabulary (replay stays DOMAIN-OWNED).
+- `journal_correction_op` _function_ — Append one correction op — envelope + semantic args + the EXACT wires committed.
+- `segment_anchor` _function_ — The run-independent anchor stamped on every correction op (DEC ccbab9f5 point 5).
+- `sidecar_journal_path` _function_ — The db's sidecar journal path (DEC ccbab9f5 point 3: placement is per-workflow,
+
 ### `cjm_transcript_correction_core.models`
 
 - `Correction` _class_ — A single non-destructive correction over the committed spine (overlay node).
@@ -105,31 +115,7 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `phonetic_key` _function_ — Compute a coarse phonetic key for a word (groups like-sounding variants).
 - `variant_divergence` _function_ — Within-segment cross-transcriber divergence (stage 5: intra-graph).
 
-### `tests.test_graph`
-
-- `test_build_prune_correction` _function_
-- `test_build_text_correction_and_active_filter` _function_
-- `test_latest_wins_ordering_from_layer` _function_
-- `test_project_effective_spine_prune_replace_supersede` _function_
-
-### `tests.test_models`
-
-- `test_correction_graph_node_mapping` _function_
-- `test_correction_relations_registry` _function_
-- `test_correction_session_node` _function_
-- `test_manifest_save_round_trip` _function_
-- `test_manifest_shape_and_run_id` _function_
-- `test_spine_segment_and_worklist_item` _function_
-
-### `tests.test_signals`
-
-- `test_boundary_punct_caps_flags` _function_
-- `test_clustering_primitives` _function_
-- `test_compute_signal_flags_combined` _function_
-- `test_empty_and_coverage_flags` _function_
-- `test_variant_divergence_within_segment` _function_
-
 ## Dependencies
 
-**Depends on:** `cjm-substrate`
+**Depends on:** `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`
 **Used by:** `cjm-transcript-correction-tui`

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2}/cjm_transcript_correction_core.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 cjm_transcript_correction_core/__init__.py
 cjm_transcript_correction_core/cli.py
 cjm_transcript_correction_core/graph.py
+cjm_transcript_correction_core/journal.py
 cjm_transcript_correction_core/models.py
 cjm_transcript_correction_core/pipeline.py
 cjm_transcript_correction_core/signals.py
@@ -16,6 +17,7 @@ cjm_transcript_correction_core.egg-info/requires.txt
 cjm_transcript_correction_core.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_graph.py
+tests/test_journal.py
 tests/test_models.py
 tests/test_pipeline.py
 tests/test_signals.py

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2}/cjm_transcript_correction_core.egg-info/requires.txt

@@ -1,4 +1,4 @@
 cjm_substrate>=0.0.51
-cjm_context_graph_primitives>=0.0.12
+cjm_context_graph_primitives>=0.0.14
 cjm-context-graph-layer>=0.0.8
 cjm-transcript-graph-schema>=0.0.7

{cjm_transcript_correction_core-0.0.1 → cjm_transcript_correction_core-0.0.2}/pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
 ]
-dependencies = ['cjm_substrate>=0.0.51', 'cjm_context_graph_primitives>=0.0.12', 'cjm-context-graph-layer>=0.0.8', 'cjm-transcript-graph-schema>=0.0.7']
+dependencies = ['cjm_substrate>=0.0.51', 'cjm_context_graph_primitives>=0.0.14', 'cjm-context-graph-layer>=0.0.8', 'cjm-transcript-graph-schema>=0.0.7']
 
 [project.urls]
 Repository = "https://github.com/cj-mills/cjm-transcript-correction-core"

cjm_transcript_correction_core-0.0.2/tests/test_journal.py

@@ -0,0 +1,36 @@
+"""The correction journal: sidecar path + op envelope (pure half; replay is e2e-proven)."""
+
+from cjm_context_graph_primitives.journal import read_journal
+from cjm_transcript_correction_core.journal import (correction_replay_handlers,
+                                                    journal_correction_op, sidecar_journal_path)
+
+
+def test_sidecar_journal_path():
+    assert (sidecar_journal_path("/data/context_graph.db")
+            == "/data/context_graph.writes.jsonl")
+    assert sidecar_journal_path("/data/odd_name") == "/data/odd_name.writes.jsonl"
+
+
+def test_journal_correction_op_envelope(tmp_path):
+    """Envelope: op id = minted Correction id, set = session, anchor + exact wires ride along."""
+    j = str(tmp_path / "w.jsonl")
+    node = {"id": "corr-1", "label": "Correction", "properties": {"correction_type": "grouping"}}
+    edge = {"id": "e-1", "source_id": "corr-1", "target_id": "seg-1", "relation_type": "CORRECTS"}
+    anchor = {"sources": [{"id": "src", "content_hash": "sha256:x"}],
+              "segments": [{"id": "seg-1", "start": 1.0, "end": 2.0, "text": "t"}]}
+    assert journal_correction_op(j, "boundary-shift", actor="human", session_id="sess-1",
+                                 args={"direction": "pull"}, nodes=[node], edges=[edge],
+                                 anchor=anchor, op_id="corr-1")
+    rec = read_journal(j)[0]
+    assert rec["id"] == "corr-1" and rec["set"] == "sess-1" and rec["actor"] == "human"
+    assert rec["wires"]["nodes"][0]["id"] == "corr-1" and rec["anchor"]["segments"][0]["end"] == 2.0
+    # Live appends ride the bulk lane (dedup=False — the 111ms/op rescan priced the TUI):
+    # a re-append lands as a duplicate LINE, and exactness is REPLAY's job (extend
+    # collides duplicate wires into verified no-ops).
+    assert journal_correction_op(j, "boundary-shift", actor="human", session_id="sess-1",
+                                 args={"direction": "pull"}, nodes=[node], edges=[edge],
+                                 anchor=anchor, op_id="corr-1")
+    assert len(read_journal(j)) == 2
+    # every registered replay verb has a handler
+    assert set(correction_replay_handlers()) == {"session-start", "boundary-shift", "text-correction",
+                                                 "prune-amendment", "review-markers", "session-status"}

cjm_transcript_correction_core-0.0.1/cjm_transcript_correction_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.1"