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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-correction-core
-Version: 0.0.2
+Version: 0.0.4
 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
@@ -10,9 +10,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 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.14
-Requires-Dist: cjm-context-graph-layer>=0.0.8
+Requires-Dist: cjm_substrate>=0.0.57
+Requires-Dist: cjm_context_graph_primitives>=0.0.15
+Requires-Dist: cjm-context-graph-layer>=0.0.11
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
 
@@ -26,7 +26,7 @@ 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.journal`** — Live append-through for the correction verbs — the workflow journal's domain half.
 - **`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.
@@ -46,11 +46,14 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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_mark_correction` _function_ — Build a NON-MUTATING mark Correction (DEC 2a231843: routed attention).
 - `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_mark_correction` _function_ — Commit a mark (node + CORRECTS per anchored segment [+ SUPERSEDES]).
+- `commit_mark_dismissal` _function_ — Dismiss an open mark WITHOUT a correction (reject-as-supersede).
 - `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.
@@ -66,7 +69,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `load_source_corrections` _function_ — Load every Correction targeting a Source (across sessions) + the superseded-id set.
 - `load_source_segments` _function_ — Load a Source's fine Segment spine under its chosen rendition (typed query surface).
 - `load_variant_texts` _function_ — Resolve per-transcriber chunk texts from the segments' CharSlice refs.
+- `mark_anchor_segments` _function_ — Validate a mark anchor and list the Segment ids it touches.
+- `open_marks` _function_ — Filter to the OPEN marks — the pass-2 worklist ('query open marks, walk them').
 - `project_effective_spine` _function_ — Project the effective spine = layer-0 + applied corrections.
+- `reanchor_span` _function_ — Re-locate a span anchor in text that may have been edited since mark time.
 - `record_review_markers` _function_ — Persist per-(session, segment) review markers as REVIEWED edges.
 - `resolve_source_renditions` _function_ — Pick the AudioRendition set whose fine Segment spine correction operates on.
 - `set_session_status` _function_ — Update a session's status + updated_at.
@@ -79,7 +85,6 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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`
 

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

@@ -8,7 +8,7 @@ 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.journal`** — Live append-through for the correction verbs — the workflow journal's domain half.
 - **`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.
@@ -28,11 +28,14 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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_mark_correction` _function_ — Build a NON-MUTATING mark Correction (DEC 2a231843: routed attention).
 - `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_mark_correction` _function_ — Commit a mark (node + CORRECTS per anchored segment [+ SUPERSEDES]).
+- `commit_mark_dismissal` _function_ — Dismiss an open mark WITHOUT a correction (reject-as-supersede).
 - `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.
@@ -48,7 +51,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `load_source_corrections` _function_ — Load every Correction targeting a Source (across sessions) + the superseded-id set.
 - `load_source_segments` _function_ — Load a Source's fine Segment spine under its chosen rendition (typed query surface).
 - `load_variant_texts` _function_ — Resolve per-transcriber chunk texts from the segments' CharSlice refs.
+- `mark_anchor_segments` _function_ — Validate a mark anchor and list the Segment ids it touches.
+- `open_marks` _function_ — Filter to the OPEN marks — the pass-2 worklist ('query open marks, walk them').
 - `project_effective_spine` _function_ — Project the effective spine = layer-0 + applied corrections.
+- `reanchor_span` _function_ — Re-locate a span anchor in text that may have been edited since mark time.
 - `record_review_markers` _function_ — Persist per-(session, segment) review markers as REVIEWED edges.
 - `resolve_source_renditions` _function_ — Pick the AudioRendition set whose fine Segment spine correction operates on.
 - `set_session_status` _function_ — Update a session's status + updated_at.
@@ -61,7 +67,6 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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`
 

cjm_transcript_correction_core-0.0.4/cjm_transcript_correction_core/__init__.py

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

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/cjm_transcript_correction_core/cli.py

@@ -3,11 +3,13 @@
 import argparse
 import asyncio
 import logging
+import os
 from pathlib import Path
 from typing import Dict, List, Optional
 
 from cjm_substrate.core.manager import CapabilityManager
 from cjm_substrate.core.queue import JobQueue
+from cjm_substrate.core.workspace import resolve_workspace
 from cjm_transcript_correction_core.models import CorrectionConfig
 from cjm_transcript_correction_core.pipeline import (load_decomp_manifest, resolve_graph_db_path,
                                                      run_correction, run_review)
@@ -18,7 +20,13 @@ logger = logging.getLogger(__name__)
 def _add_common_run_args(p: argparse.ArgumentParser) -> None:  # Shared run/review arguments
     """Attach the capability / session / output arguments shared by `run` and `review`."""
     p.add_argument("manifest", help="Decomp-core run manifest JSON (the committed spine)")
-    p.add_argument("--manifests-dir", default=".cjm/manifests", help="Capability manifests directory")
+    p.add_argument("--manifests-dir", default=None,
+                   help="Capability manifests directory (default: the workspace's .cjm/manifests "
+                        "when one is active, else .cjm/manifests under the cwd)")
+    p.add_argument("--workspace", default=None,
+                   help="Workspace root (5daadfc4; default: CJM_WORKSPACE env, else upward walk "
+                        "from cwd). Supplies manifests/output defaults and is exported so "
+                        "capability workers resolve workspace-scoped paths")
     p.add_argument("--graph-capability", default="cjm-capability-graph-sqlite", help="Graph-storage capability name")
     p.add_argument("--graph-db-path", default=None,
                    help="Override graph DB path (default: the decomp manifest's recorded db_path)")
@@ -31,7 +39,9 @@ def _add_common_run_args(p: argparse.ArgumentParser) -> None:  # Shared run/revi
     p.add_argument("--session", default=None, help="Resume an existing CorrectionSession id")
     p.add_argument("--reopen", action="store_true", help="Reopen a completed session (with --session)")
     p.add_argument("--actor", default="human", help="Actor recorded on corrections + review markers")
-    p.add_argument("--output", default=None, help="Correction-manifest output path (default: runs/<run_id>.json)")
+    p.add_argument("--output", default=None,
+                   help="Correction-manifest output path (default: <workspace>/runs/<run_id>.json "
+                        "when a workspace is active, else runs/<run_id>.json under the cwd)")
     p.add_argument("-v", "--verbose", action="store_true", help="DEBUG-level logging")
 
 
@@ -84,6 +94,14 @@ async def run_command(
     args: argparse.Namespace,  # Parsed args for the `run` subcommand
 ) -> int:  # Process exit code
     """Execute the `run` subcommand: correct a decomp manifest's committed spine."""
+    # 5daadfc4 workspace: resolve BEFORE any substrate config loads; export so
+    # the process tree (substrate config, capability workers) is workspace-scoped.
+    ws = resolve_workspace(explicit=getattr(args, "workspace", None))
+    if ws is not None:
+        os.environ["CJM_WORKSPACE"] = str(ws.root)
+    if args.manifests_dir is None:
+        args.manifests_dir = (str(ws.substrate_data_dir / "manifests")
+                              if ws is not None else ".cjm/manifests")
     manifest_path = str(Path(args.manifest).resolve())
     if not Path(manifest_path).exists():
         raise SystemExit(f"decomp manifest not found: {manifest_path}")
@@ -122,8 +140,9 @@ async def run_command(
             except Exception as e:  # Best-effort teardown; never mask the run's outcome
                 logger.warning(f"unload {iid} failed: {e}")
 
-    out = Path(args.output) if args.output else Path("runs") / f"{manifest.run_id}.json"
-    manifest.save(out)
+    out = (Path(args.output) if args.output
+           else (ws.runs_dir if ws is not None else Path("runs")) / f"{manifest.run_id}.json")
+    manifest.save(out, workspace=ws)
     n_sources = len(manifest.sources)
     n_pruned = sum(s.get("pruned", 0) for s in manifest.sources)
     n_flagged = sum(s.get("worklist_flagged", 0) for s in manifest.sources)
@@ -137,6 +156,13 @@ async def review_command(
     args: argparse.Namespace,  # Parsed args for the `review` subcommand
 ) -> int:  # Process exit code
     """Execute the `review` subcommand: interactive text corrections over the flagged worklist."""
+    # 5daadfc4 workspace: same early resolution + export as run_command.
+    ws = resolve_workspace(explicit=getattr(args, "workspace", None))
+    if ws is not None:
+        os.environ["CJM_WORKSPACE"] = str(ws.root)
+    if args.manifests_dir is None:
+        args.manifests_dir = (str(ws.substrate_data_dir / "manifests")
+                              if ws is not None else ".cjm/manifests")
     manifest_path = str(Path(args.manifest).resolve())
     if not Path(manifest_path).exists():
         raise SystemExit(f"decomp manifest not found: {manifest_path}")
@@ -167,8 +193,9 @@ async def review_command(
             except Exception as e:  # Best-effort teardown; never mask the run's outcome
                 logger.warning(f"unload {iid} failed: {e}")
 
-    out = Path(args.output) if args.output else Path("runs") / f"{manifest.run_id}.json"
-    manifest.save(out)
+    out = (Path(args.output) if args.output
+           else (ws.runs_dir if ws is not None else Path("runs")) / f"{manifest.run_id}.json")
+    manifest.save(out, workspace=ws)
     n_corr = sum(s.get("corrected", 0) for s in manifest.sources)
     n_active = sum(s.get("active_corrections", 0) for s in manifest.sources)
     print(f"correction manifest: {out}")

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

@@ -259,7 +259,7 @@ def _edge(
 
 
 def build_correction_node(
-    correction_type: str,                  # "text_content" | "punctuation" | "grouping" | "review"
+    correction_type: str,                  # "text_content" | "punctuation" | "grouping" | "review" | "mark"
     session_id: str,                       # Owning session id
     payload: Dict[str, Any],               # Type-specific payload
     actor: str = "human",                  # Actor
@@ -376,7 +376,8 @@ async def record_review_markers(
     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})
+    edges = [_edge(session_id, seg_id, CorrectionRelations.REVIEWED,
+                   {"decision": dec, "ts": time.time()})
              for seg_id, dec in decisions]
     n = (await commit_nodes_edges(queue, graph_id, [], edges))["edges"]
     if journal_path:
@@ -395,11 +396,21 @@ async def load_review_markers(
     graph_id: str,    # Graph-storage capability id
     session_id: str,  # Owning session id
 ) -> Dict[str, str]:  # segment_id -> decision for the session
-    """Load a session's review markers (typed edge projection over REVIEWED edges)."""
+    """Load a session's review markers (typed edge projection over REVIEWED edges).
+
+    Markers are EVENTS (a re-decision appends — the _edge docstring's contract),
+    so the read is LATEST-WINS by the marker's ts, and a latest decision of
+    "unreviewed" means UNDECIDED: the segment drops out of the returned map
+    entirely (the space-undo gesture; compute_worklist then re-surfaces it).
+    Historical edges without ts sort first, so any re-decision beats them.
+    """
     q = EdgeQuery(source_id=session_id, relation_type=CorrectionRelations.REVIEWED,
-                  project=["decision"])
+                  project=["decision", "ts"])
     res = await graph_task(queue, graph_id, "query_edges", query=q.to_dict())
-    return {r["target_id"]: r["decision"] for r in (res.rows or [])}
+    latest: Dict[str, str] = {}
+    for r in sorted((res.rows or []), key=lambda r: float(r.get("ts") or 0.0)):
+        latest[r["target_id"]] = r["decision"]
+    return {sid: dec for sid, dec in latest.items() if dec != "unreviewed"}
 
 
 def _node_to_correction_dict(
@@ -836,3 +847,178 @@ async def commit_prune_amendment(
                               anchor=await segment_anchor(queue, graph_id, unprune_ids),
                               nodes=[node], edges=edges, op_id=node["id"])
     return _node_to_correction_dict(node)
+
+
+def mark_anchor_segments(
+    anchor: Dict[str, Any],  # Mark anchor: {"kind": "segment" | "boundary" | "span", ...}
+) -> List[str]:  # The layer-0 Segment ids the anchor touches (CORRECTS targets)
+    """Validate a mark anchor and list the Segment ids it touches.
+
+    The three anchor shapes (DEC 2a231843): `segment` {segment_id} ·
+    `boundary` {boundary_after, right_segment_id} (the boundary AFTER a
+    segment — the shift gesture's coordinates) · `span` {segment_id,
+    char_start, char_end, text_snapshot} (offsets into the segment's effective
+    text AT MARK TIME; the snapshot is what re-anchoring trusts — see
+    `reanchor_span` — the offsets are only its hint).
+    """
+    kind = anchor.get("kind")
+    if kind == "segment":
+        ids = [anchor.get("segment_id")]
+    elif kind == "boundary":
+        ids = [anchor.get("boundary_after"), anchor.get("right_segment_id")]
+    elif kind == "span":
+        ids = [anchor.get("segment_id")]
+        if not anchor.get("text_snapshot") or anchor.get("char_start") is None \
+                or anchor.get("char_end") is None:
+            raise ValueError("span mark anchor needs char_start, char_end and a text_snapshot")
+    else:
+        raise ValueError(f"mark anchor kind must be 'segment' | 'boundary' | 'span', got {kind!r}")
+    if any(not sid for sid in ids):
+        raise ValueError(f"{kind} mark anchor is missing its segment id(s): {anchor!r}")
+    return [str(sid) for sid in ids]
+
+
+def build_mark_correction(
+    source_id: str,                       # Source the marked segment(s) belong to
+    anchor: Dict[str, Any],               # Anchor: segment | boundary | span (see mark_anchor_segments)
+    mark_class: str,                      # Open-vocabulary class (RECOMMENDED_MARK_CLASSES is the slate)
+    session_id: str,                      # Owning session id
+    supersedes_id: Optional[str] = None,  # Prior mark this one replaces (re-mark)
+    actor: str = "human",                 # Actor ("human" | "capability:<name>" for pass-2 assists)
+    note: Optional[str] = None,           # Optional free-text note
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:  # (correction node dict, edge dicts)
+    """Build a NON-MUTATING mark Correction (DEC 2a231843: routed attention).
+
+    A mark is a placeholder correction: it records that a slot needs judgment
+    (an omission-entangled boundary, a suspect entity, ...) WITHOUT resolving
+    anything — `corrections_to_edits` has no arm for it, so it can never touch
+    the effective view. It closes by SUPERSESSION: the real correction that
+    discharges it passes `supersedes_id=<mark id>`, or a dismissal supersedes
+    it (`commit_mark_dismissal`, riding the reject-review shape). CORRECTS
+    edges anchor every touched segment so marks surface in segment-scoped
+    reads.
+    """
+    mc = (mark_class or "").strip()
+    if not mc:
+        raise ValueError("mark_class must be a non-empty string")
+    if not mc[:1].isalnum():
+        raise ValueError(f"mark_class must start with a letter or digit, got {mark_class!r}"
+                         " — punctuation-led tokens are reserved for gestures ('-' dismissal)")
+    seg_ids = mark_anchor_segments(anchor)
+    payload = {"operation": "mark", "source_id": source_id,
+               "anchor": dict(anchor), "mark_class": mc}
+    node = build_correction_node("mark", session_id, payload, actor=actor,
+                                 rationale=note).to_graph_node()
+    edges = [make_edge(node.id, sid, CorrectionRelations.CORRECTS) for sid in seg_ids]
+    if supersedes_id:
+        edges.append(make_edge(node.id, supersedes_id, CorrectionRelations.SUPERSEDES))
+    return node.to_dict(), edges
+
+
+async def commit_mark_correction(
+    queue: JobQueue,                      # Started job queue
+    graph_id: str,                        # Graph-storage capability id
+    source_id: str,                       # Source the marked segment(s) belong to
+    anchor: Dict[str, Any],               # Anchor: segment | boundary | span
+    mark_class: str,                      # Open-vocabulary class
+    session_id: str,                      # Owning session id
+    supersedes_id: Optional[str] = None,  # Prior mark to supersede (re-mark)
+    actor: str = "human",                 # Actor
+    note: Optional[str] = None,           # Optional free-text note
+    journal_path: Optional[str] = None,   # Sidecar journal — append the op on success (None = unjournaled)
+) -> str:  # The new mark Correction node id
+    """Commit a mark (node + CORRECTS per anchored segment [+ SUPERSEDES]).
+
+    NO review marker: a mark is routed attention, not a review decision — the
+    walked-past state stays exactly as the operator left it.
+    """
+    node, edges = build_mark_correction(source_id, anchor, mark_class, session_id,
+                                        supersedes_id=supersedes_id, actor=actor, note=note)
+    await commit_nodes_edges(queue, graph_id, [node], edges)
+    if journal_path:
+        journal_correction_op(journal_path, "mark", actor=actor, session_id=session_id,
+                              args={"source_id": source_id, "anchor": dict(anchor),
+                                    "mark_class": mark_class, "note": note,
+                                    "supersedes_id": supersedes_id},
+                              anchor=await segment_anchor(queue, graph_id,
+                                                          mark_anchor_segments(anchor)),
+                              nodes=[node], edges=edges, op_id=node["id"])
+    return node["id"]
+
+
+async def commit_mark_dismissal(
+    queue: JobQueue,                     # Started job queue
+    graph_id: str,                       # Graph-storage capability id
+    source_id: str,                      # Source the mark belongs to
+    mark_id: str,                        # The open mark being dismissed
+    session_id: str,                     # Owning session id
+    actor: str = "human",                # Actor (the dismisser)
+    note: Optional[str] = None,          # Optional note (why dismissed)
+    journal_path: Optional[str] = None,  # Sidecar journal — append the op on success (None = unjournaled)
+) -> str:  # The review node id that superseded the mark
+    """Dismiss an open mark WITHOUT a correction (reject-as-supersede).
+
+    Rides the review verdict shape (`build_reject_review`): dismissal is a
+    SUPERSEDES edge from a small review node — append-only, carrying
+    actor/note/timestamp — and `open_marks` then excludes the mark. No anchor
+    on the journal op: dismissal is derivative session state, like review
+    markers (the ccbab9f5 anchor scope).
+    """
+    node, edges = build_reject_review(source_id, mark_id, session_id,
+                                      actor=actor, rationale=note)
+    await commit_nodes_edges(queue, graph_id, [node], edges)
+    if journal_path:
+        journal_correction_op(journal_path, "mark-dismiss", actor=actor,
+                              session_id=session_id,
+                              args={"source_id": source_id, "mark_id": mark_id, "note": note},
+                              nodes=[node], edges=edges, op_id=node["id"])
+    return node["id"]
+
+
+def open_marks(
+    corrections: List[Dict[str, Any]],  # Corrections (e.g. from load_source_corrections)
+    superseded_ids: set,                # Ids that are SUPERSEDES targets
+) -> List[Dict[str, Any]]:  # The OPEN marks (not yet discharged/dismissed), oldest first
+    """Filter to the OPEN marks — the pass-2 worklist ('query open marks, walk them').
+
+    A mark leaves this set the moment anything supersedes it (the discharging
+    correction or a dismissal review) — resolution is read from SUPERSEDES
+    edges, never a status mutation.
+    """
+    marks = [c for c in corrections
+             if c.get("correction_type") == "mark"
+             and (c.get("payload") or {}).get("operation") == "mark"
+             and c.get("id") not in superseded_ids]
+    marks.sort(key=lambda c: c.get("created_at") or 0.0)
+    return marks
+
+
+def reanchor_span(
+    anchor: Dict[str, Any],  # A span mark anchor (char_start / char_end / text_snapshot)
+    effective_text: str,     # The segment's CURRENT effective text
+) -> Optional[Tuple[int, int]]:  # Current (char_start, char_end); None = degrade to segment level
+    """Re-locate a span anchor in text that may have been edited since mark time.
+
+    The SNAPSHOT is the anchor's truth; the recorded offsets are only its hint
+    (DEC 2a231843): exact offsets verified first, then the snapshot occurrence
+    NEAREST the recorded start, else None — the caller degrades the mark to
+    segment level (which usually means the marked text was addressed).
+    """
+    snap = anchor.get("text_snapshot")
+    if not snap:
+        return None
+    try:
+        cs, ce = int(anchor.get("char_start")), int(anchor.get("char_end"))
+    except (TypeError, ValueError):
+        cs, ce = -1, -1
+    if 0 <= cs <= ce <= len(effective_text) and effective_text[cs:ce] == snap:
+        return cs, ce
+    hits: List[int] = []
+    at = effective_text.find(snap)
+    while at != -1:
+        hits.append(at)
+        at = effective_text.find(snap, at + 1)
+    if not hits:
+        return None
+    best = min(hits, key=lambda h: abs(h - cs) if cs >= 0 else h)
+    return best, best + len(snap)

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/cjm_transcript_correction_core/journal.py

@@ -11,22 +11,12 @@ 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_layer.journal import wires_handlers
+from cjm_context_graph_layer.ops import 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
@@ -92,22 +82,21 @@ def journal_correction_op(
 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 [])
-
+    Exported through the `cjm_context_graph_layer.replay` entry-point group (DEC
+    426658f1) and unioned by `composed_replay_handlers`: wire-carrying verbs register
+    the layer's shared `apply_wires` — the single wires-replay authority, identity-
+    comparable across cores, which keeps cross-core verb collisions checkable;
+    `session-status` is the core's only update_node write, replayed last-wins in
+    append order."""
     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}
+    handlers = wires_handlers("session-start", "boundary-shift", "text-correction",
+                              "prune-amendment", "mark", "mark-dismiss", "review-markers")
+    handlers["session-status"] = _apply_session_status
+    return handlers
 
 
 # A Source's content hash is IMMUTABLE — read once per process, not per commit

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/cjm_transcript_correction_core/models.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 from cjm_context_graph_primitives.graph import GraphNode
+from cjm_substrate.core.workspace import relativize_recorded
 
 
 class CorrectionRelations:
@@ -35,7 +36,7 @@ class Correction:
     generic GraphNode. Corrections are DECISIONS (asserted events) — they keep
     GENERATED ids, the FLIP-TRIGGER-protected class.
     """
-    correction_type: str                                   # "text_content" | "punctuation" | "grouping" | "review"
+    correction_type: str                                   # "text_content" | "punctuation" | "grouping" | "review" | "mark"
     status: str = "applied"                                # "proposed" | "applied" | "superseded"
     session_id: str = ""                                   # Owning CorrectionSession id
     payload: Dict[str, Any] = field(default_factory=dict)  # Type-specific data (new text, prune set, ...)
@@ -158,14 +159,38 @@ class CorrectionManifest:
     def save(
         self,
         path: Union[str, Path],  # Destination JSON file (parent dirs created)
+        workspace=None,  # Active Workspace; owned paths record as ${WS}/<rel> (5daadfc4 rung f)
     ) -> Path:  # The written path
-        """Write the manifest as pretty-printed JSON."""
+        """Write the manifest as pretty-printed JSON.
+
+        With `workspace`, recorded paths under its root take the ${WS}/ token
+        form (relativize_recorded), so the manifest relocates with the
+        workspace; readers resolve via resolve_recorded_tree at load."""
         out = Path(path)
         out.parent.mkdir(parents=True, exist_ok=True)
-        out.write_text(json.dumps(self.to_dict(), indent=2))
+        out.write_text(json.dumps(relativize_recorded(self.to_dict(), workspace), indent=2))
         return out
 
 
 def new_run_id() -> str:  # e.g. "correct_20260608_153000_1a2b3c4d"
     """Generate a unique, sortable correction run id."""
     return f"correct_{time.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+
+
+# The RECOMMENDED mark-class slate (DEC 2a231843) — an OPEN vocabulary: classes are
+# DATA, not schema. A mark commits with any non-empty class string; this tuple is
+# the evidence-derived starting set (census dc31c33c + the drive evidence chain)
+# that pickers and status hints surface, so a new class found mid-walk is a journal
+# entry, never a core release.
+RECOMMENDED_MARK_CLASSES = (
+    "hesitation-omission",     # single Um / 'you know' slots dropped (fill dominates)
+    "repeat-omission",         # dropped repeated words/stutters — the omission-entangled boundary case
+    "meta-speech-omission",    # spoken 'Quote' / 'End Quote' markers dropped
+    "meta-speech-executed",    # meta-speech rendered AS punctuation instead
+    "homophone-substitution",  # context-vs-acoustics substitution (where/were)
+    "proper-noun-suspect",     # entity spelling suspect (Hiroo/Hiro/Hero)
+    "orthographic-drift",      # decoder-state capitalization/orthography decay
+    "granularity-mismatch",    # VAD split lands mid-word/mid-token
+    "foreign-speech",          # non-English speech garbled into English (montage/quote cases; drive-minted 2026-07-19)
+    "suspect",                 # free-note catch-all — flag now, judge later
+)

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/cjm_transcript_correction_core/pipeline.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional
 from cjm_substrate.core.journal_store import JournalEvent, SubstrateEventType
 from cjm_substrate.core.manager import CapabilityManager
 from cjm_substrate.core.queue import JobQueue
+from cjm_substrate.core.workspace import resolve_recorded_tree
 from cjm_transcript_correction_core.graph import (active_corrections, build_prune_correction,
                                                   commit_nodes_edges, commit_text_correction,
                                                   count_source_segments,
@@ -31,8 +32,11 @@ logger = logging.getLogger(__name__)
 def load_decomp_manifest(
     path: str,  # Path to a decomp-core run manifest JSON
 ) -> Dict[str, Any]:  # Parsed manifest dict
-    """Load + lightly validate a decomp-core run manifest (untyped JSON; CR-20 interchange)."""
-    data = json.loads(Path(path).read_text())
+    """Load + lightly validate a decomp-core run manifest (untyped JSON; CR-20 interchange).
+
+    ${WS}/ recorded paths (5daadfc4 rung f) resolve to absolute here, anchored
+    at the manifest's own location (active workspace as fallback)."""
+    data = resolve_recorded_tree(json.loads(Path(path).read_text()), Path(path))
     fmt = data.get("format", "")
     if "decomp-core" not in fmt:
         logger.warning(f"unexpected decomp manifest format: {fmt!r} (continuing)")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-correction-core
-Version: 0.0.2
+Version: 0.0.4
 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
@@ -10,9 +10,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 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.14
-Requires-Dist: cjm-context-graph-layer>=0.0.8
+Requires-Dist: cjm_substrate>=0.0.57
+Requires-Dist: cjm_context_graph_primitives>=0.0.15
+Requires-Dist: cjm-context-graph-layer>=0.0.11
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
 
@@ -26,7 +26,7 @@ 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.journal`** — Live append-through for the correction verbs — the workflow journal's domain half.
 - **`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.
@@ -46,11 +46,14 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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_mark_correction` _function_ — Build a NON-MUTATING mark Correction (DEC 2a231843: routed attention).
 - `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_mark_correction` _function_ — Commit a mark (node + CORRECTS per anchored segment [+ SUPERSEDES]).
+- `commit_mark_dismissal` _function_ — Dismiss an open mark WITHOUT a correction (reject-as-supersede).
 - `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.
@@ -66,7 +69,10 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `load_source_corrections` _function_ — Load every Correction targeting a Source (across sessions) + the superseded-id set.
 - `load_source_segments` _function_ — Load a Source's fine Segment spine under its chosen rendition (typed query surface).
 - `load_variant_texts` _function_ — Resolve per-transcriber chunk texts from the segments' CharSlice refs.
+- `mark_anchor_segments` _function_ — Validate a mark anchor and list the Segment ids it touches.
+- `open_marks` _function_ — Filter to the OPEN marks — the pass-2 worklist ('query open marks, walk them').
 - `project_effective_spine` _function_ — Project the effective spine = layer-0 + applied corrections.
+- `reanchor_span` _function_ — Re-locate a span anchor in text that may have been edited since mark time.
 - `record_review_markers` _function_ — Persist per-(session, segment) review markers as REVIEWED edges.
 - `resolve_source_renditions` _function_ — Pick the AudioRendition set whose fine Segment spine correction operates on.
 - `set_session_status` _function_ — Update a session's status + updated_at.
@@ -79,7 +85,6 @@ A frontend-agnostic core for the transcript correction workflow — the first do
 - `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`
 

cjm_transcript_correction_core-0.0.4/cjm_transcript_correction_core.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[cjm_context_graph_layer.replay]
+correction = cjm_transcript_correction_core.journal:correction_replay_handlers
+
+[console_scripts]
+cjm-transcript-correction-core = cjm_transcript_correction_core.cli:main

cjm_transcript_correction_core-0.0.4/cjm_transcript_correction_core.egg-info/requires.txt

@@ -0,0 +1,4 @@
+cjm_substrate>=0.0.57
+cjm_context_graph_primitives>=0.0.15
+cjm-context-graph-layer>=0.0.11
+cjm-transcript-graph-schema>=0.0.7

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/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.14', 'cjm-context-graph-layer>=0.0.8', 'cjm-transcript-graph-schema>=0.0.7']
+dependencies = ['cjm_substrate>=0.0.57', 'cjm_context_graph_primitives>=0.0.15', 'cjm-context-graph-layer>=0.0.11', 'cjm-transcript-graph-schema>=0.0.7']
 
 [project.urls]
 Repository = "https://github.com/cj-mills/cjm-transcript-correction-core"
@@ -22,6 +22,9 @@ Repository = "https://github.com/cj-mills/cjm-transcript-correction-core"
 [project.scripts]
 cjm-transcript-correction-core = "cjm_transcript_correction_core.cli:main"
 
+[project.entry-points."cjm_context_graph_layer.replay"]
+correction = "cjm_transcript_correction_core.journal:correction_replay_handlers"
+
 [tool.setuptools.dynamic]
 version = {attr = "cjm_transcript_correction_core.__version__"}
 

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/tests/test_graph.py

@@ -5,12 +5,15 @@ Projected from the graph notebook's two pure-check cells at the golden-reference
 from cjm_transcript_correction_core.graph import (
     active_corrections,
     build_boundary_shift_correction,
+    build_mark_correction,
     build_prune_amendment,
     build_prune_correction,
     build_reject_review,
     build_text_correction,
     corrections_to_edits,
+    open_marks,
     project_effective_spine,
+    reanchor_span,
 )
 from cjm_transcript_correction_core.models import SpineSegment
 
@@ -178,3 +181,94 @@ def test_prune_amendment_rescues_boundary_shift_target():
     eff2 = project_effective_spine(segs, active)
     assert [s.id for s in eff2] == ["a", "b", "c"]
     assert eff2[0].text == "largest naval battle" and eff2[1].text == "in history"
+
+
+def test_build_mark_correction_anchor_shapes():
+    # segment: one CORRECTS edge, non-mutating payload vocabulary
+    node, edges = build_mark_correction("src1", {"kind": "segment", "segment_id": "a"},
+                                        "suspect", session_id="s1", note="check later")
+    props = node["properties"]
+    assert props["correction_type"] == "mark"
+    assert props["payload"]["operation"] == "mark"
+    assert props["payload"]["mark_class"] == "suspect"
+    assert props["rationale"] == "check later"
+    assert [(e["relation_type"], e["target_id"]) for e in edges] == [("CORRECTS", "a")]
+    # boundary: CORRECTS x2 (the shift gesture's coordinates; seams allowed)
+    _, edges = build_mark_correction(
+        "src1", {"kind": "boundary", "boundary_after": "a", "right_segment_id": "b"},
+        "repeat-omission", session_id="s1")
+    assert [(e["relation_type"], e["target_id"]) for e in edges] == [
+        ("CORRECTS", "a"), ("CORRECTS", "b")]
+    # span: offsets + verbatim snapshot ride the anchor; supersession is an edge
+    node, edges = build_mark_correction(
+        "src1", {"kind": "span", "segment_id": "c", "char_start": 0, "char_end": 5,
+                 "text_snapshot": "world"},
+        "homophone-substitution", session_id="s1", supersedes_id="m0")
+    assert node["properties"]["payload"]["anchor"]["text_snapshot"] == "world"
+    assert ("SUPERSEDES", "m0") in [(e["relation_type"], e["target_id"]) for e in edges]
+
+
+def test_build_mark_correction_validation():
+    def rejects(anchor, mark_class="suspect"):
+        try:
+            build_mark_correction("src1", anchor, mark_class, session_id="s1")
+        except ValueError:
+            return True
+        return False
+    assert rejects({"kind": "segment", "segment_id": "a"}, mark_class="   ")
+    # punctuation-led classes are reserved for gestures (the '`-`' junk-mark drive find)
+    assert rejects({"kind": "segment", "segment_id": "a"}, mark_class="-")
+    assert rejects({"kind": "segment", "segment_id": "a"}, mark_class="`-`")
+    assert rejects({"kind": "sentence", "segment_id": "a"})
+    assert rejects({"kind": "segment"})
+    assert rejects({"kind": "boundary", "boundary_after": "a"})
+    # a span without its snapshot could never re-anchor — refused at build time
+    assert rejects({"kind": "span", "segment_id": "a", "char_start": 0, "char_end": 2})
+
+
+def test_mark_never_touches_projection():
+    """The DEC 2a231843 invariant: a mark is invisible to the effective view BY
+    CONSTRUCTION — corrections_to_edits has no arm for correction_type "mark"."""
+    node, _ = build_mark_correction("src1", {"kind": "segment", "segment_id": "b"},
+                                    "hesitation-omission", session_id="s1")
+    props = dict(node["properties"])
+    props["id"] = node["id"]
+    assert corrections_to_edits([props]) == []
+    out = project_effective_spine(SEGS, [props])
+    assert [(s.id, s.text) for s in out] == [(s.id, s.text) for s in SEGS]
+
+
+def test_open_marks_lifecycle():
+    m1, _ = build_mark_correction("src1", {"kind": "segment", "segment_id": "a"},
+                                  "suspect", session_id="s1")
+    m2, _ = build_mark_correction("src1", {"kind": "boundary", "boundary_after": "a",
+                                           "right_segment_id": "b"},
+                                  "repeat-omission", session_id="s1")
+    fix, _ = build_text_correction("src1", "a", "Hello", session_id="s1",
+                                   supersedes_id=m1["id"])
+    rows = []
+    for n in (m1, m2, fix):
+        p = dict(n["properties"])
+        p["id"] = n["id"]
+        rows.append(p)
+    # open until something supersedes: the discharging correction closes m1
+    assert [m["id"] for m in open_marks(rows, set())] == [m1["id"], m2["id"]]
+    assert [m["id"] for m in open_marks(rows, {m1["id"]})] == [m2["id"]]
+    # a dismissal review (reject-as-supersede) closes m2 and is not itself a mark
+    rej, _ = build_reject_review("src1", m2["id"], session_id="s1")
+    p = dict(rej["properties"])
+    p["id"] = rej["id"]
+    assert open_marks(rows + [p], {m1["id"], m2["id"]}) == []
+
+
+def test_reanchor_span():
+    a = {"char_start": 6, "char_end": 11, "text_snapshot": "world"}
+    assert reanchor_span(a, "hello world") == (6, 11)         # exact offsets verified
+    assert reanchor_span(a, "well, hello world") == (12, 17)  # edited text -> snapshot re-found
+    assert reanchor_span(a, "goodbye moon") is None           # gone -> degrade to segment level
+    # multiple occurrences: the one nearest the recorded start wins
+    assert reanchor_span({"char_start": 0, "char_end": 2, "text_snapshot": "ab"},
+                         "ab ab") == (0, 2)
+    assert reanchor_span({"char_start": 3, "char_end": 5, "text_snapshot": "ab"},
+                         "ab ab") == (3, 5)
+    assert reanchor_span({"text_snapshot": ""}, "x") is None

{cjm_transcript_correction_core-0.0.2 → cjm_transcript_correction_core-0.0.4}/tests/test_journal.py

@@ -1,8 +1,8 @@
 """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)
+from cjm_transcript_correction_core.journal import correction_replay_handlers, journal_correction_op
+from cjm_context_graph_layer.journal import sidecar_journal_path
 
 
 def test_sidecar_journal_path():
@@ -33,4 +33,11 @@ def test_journal_correction_op_envelope(tmp_path):
     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"}
+                                                 "prune-amendment", "mark", "mark-dismiss",
+                                                 "review-markers", "session-status"}
+
+
+def test_replay_handlers_cover_mark_verbs():
+    """Marks are BORN JOURNALED (DEC 2a231843): both verbs replay as wire ops."""
+    handlers = correction_replay_handlers()
+    assert "mark" in handlers and "mark-dismiss" in handlers

cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core/__init__.py

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

cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-cjm-transcript-correction-core = cjm_transcript_correction_core.cli:main

cjm_transcript_correction_core-0.0.2/cjm_transcript_correction_core.egg-info/requires.txt

@@ -1,4 +0,0 @@
-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