cjm-transcript-decomp-core 0.0.4__tar.gz → 0.0.5__tar.gz

{cjm_transcript_decomp_core-0.0.4/cjm_transcript_decomp_core.egg-info → cjm_transcript_decomp_core-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-decomp-core
-Version: 0.0.4
+Version: 0.0.5
 Summary: A frontend-agnostic core for the transcript decomposition workflow — composes isolated capability workers (forced alignment, VAD, graph storage) into a headless pipeline that decomposes transcription run manifests into a VAD-aligned context-graph spine with traceable provenance, and a CLI as its first driver.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cjm_substrate>=0.0.57
 Requires-Dist: cjm_context_graph_primitives>=0.0.15
-Requires-Dist: cjm_capability_primitives>=0.0.10
+Requires-Dist: cjm_capability_primitives>=0.0.11
 Requires-Dist: cjm-context-graph-layer>=0.0.11
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
@@ -38,6 +38,8 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `assign_words_to_chunks` _function_ — Assign each FA word to a VAD chunk by timestamp overlap.
 - `build_segments_from_alignment` _function_ — Build a TextSegment per VAD chunk by grouping words by chunk assignment.
 - `map_fa_words_to_text` _function_ — Map forced-alignment words back to character spans in the original text.
+- `sentence_end_word_indices` _function_ — Map capability-delivered sentence boundaries onto FA words (B.5: the
+- `split_chunks_at_sentence_gaps` _function_ — The sentence-split stage (SENTENCE_SPLIT_POLICY, DEC f1024568): refine the
 - `tier1_alignment_checks` _function_ — Tier-1 deterministic pre-filters for the alignment-review seam (no AI).
 
 ### `cjm_transcript_decomp_core.cli`
@@ -68,14 +70,16 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.pipeline`
 
-- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA) composition (D8 fan-in, stage-5 variants).
+- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA ∥ SEG) composition (D8 fan-in, stage-5 variants).
 - `collect_capability_info` _function_ — Record capability identity + data-DB pointers for the run manifest (provenance).
+- `compute_skeleton_hash` _function_ — Skeleton identity, pure (DEC f1024568 + 9241564f).
 - `confirm_seam` _function_ — HITL approval seam in its cheapest viable form (log + optional CLI prompt).
 - `decomp_replay_handlers` _function_ — The decomp core's replay vocabulary (DEC 426658f1, replay stays DOMAIN-OWNED).
 - `decompose_source` _function_ — Decompose one source into aligned fine segments with per-transcriber variants.
 - `fa_words_from_result` _function_ — Normalize a typed forced-alignment result into FA words (pure; stage 3).
 - `load_source_manifest` _function_ — Load + lightly validate a transcription-core run manifest.
 - `run_decomp` _function_ — Extend every source in a transcription run manifest with its fine spine.
+- `sentence_spans_from_result` _function_ — Normalize a typed sentence-segmentation result into char-span tuples (pure; B.5).
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, and return its result (raise on failure).
 - `vad_chunks_from_result` _function_ — Normalize a typed VAD result into segment-local VAD chunks.
 

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/README.md

@@ -19,6 +19,8 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `assign_words_to_chunks` _function_ — Assign each FA word to a VAD chunk by timestamp overlap.
 - `build_segments_from_alignment` _function_ — Build a TextSegment per VAD chunk by grouping words by chunk assignment.
 - `map_fa_words_to_text` _function_ — Map forced-alignment words back to character spans in the original text.
+- `sentence_end_word_indices` _function_ — Map capability-delivered sentence boundaries onto FA words (B.5: the
+- `split_chunks_at_sentence_gaps` _function_ — The sentence-split stage (SENTENCE_SPLIT_POLICY, DEC f1024568): refine the
 - `tier1_alignment_checks` _function_ — Tier-1 deterministic pre-filters for the alignment-review seam (no AI).
 
 ### `cjm_transcript_decomp_core.cli`
@@ -49,14 +51,16 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.pipeline`
 
-- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA) composition (D8 fan-in, stage-5 variants).
+- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA ∥ SEG) composition (D8 fan-in, stage-5 variants).
 - `collect_capability_info` _function_ — Record capability identity + data-DB pointers for the run manifest (provenance).
+- `compute_skeleton_hash` _function_ — Skeleton identity, pure (DEC f1024568 + 9241564f).
 - `confirm_seam` _function_ — HITL approval seam in its cheapest viable form (log + optional CLI prompt).
 - `decomp_replay_handlers` _function_ — The decomp core's replay vocabulary (DEC 426658f1, replay stays DOMAIN-OWNED).
 - `decompose_source` _function_ — Decompose one source into aligned fine segments with per-transcriber variants.
 - `fa_words_from_result` _function_ — Normalize a typed forced-alignment result into FA words (pure; stage 3).
 - `load_source_manifest` _function_ — Load + lightly validate a transcription-core run manifest.
 - `run_decomp` _function_ — Extend every source in a transcription run manifest with its fine spine.
+- `sentence_spans_from_result` _function_ — Normalize a typed sentence-segmentation result into char-span tuples (pure; B.5).
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, and return its result (raise on failure).
 - `vad_chunks_from_result` _function_ — Normalize a typed VAD result into segment-local VAD chunks.
 

cjm_transcript_decomp_core-0.0.5/cjm_transcript_decomp_core/__init__.py

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

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core/alignment.py

@@ -1,13 +1,23 @@
 """Pure forced-alignment logic (no capability calls): map FA words back to character spans in the original text, assign words to VAD chunks by timestamp, and build one text segment per VAD chunk. Extracted from the page-centric ForcedAlignmentService (Tier-1 logic)."""
 
 import re
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 
 from cjm_transcript_decomp_core.models import FAWord, TextSegment, VADChunk
 
 # Strip punctuation for comparison (matches what FA models strip).
 _PUNCT_RE = re.compile(r"[^\w\s]", re.UNICODE)
 
+# Sentence-split policy tag (DEC f1024568): versioned because the policy is a
+# SKELETON IDENTITY input — any change to the split rule must bump it, or
+# re-runs would silently collide with spines a different rule produced.
+# 'capability' (B.5, DEC cc904eee): sentence boundaries now come from a
+# sentence-segmentation CAPABILITY (pySBD first) as char spans over the
+# authoritative text — the v1-v3 token heuristic (closer/abbreviation/stub
+# lists) is RETIRED. The segmenter's identity (capability name + config hash)
+# joins the skeleton-identity composite beside this tag.
+SENTENCE_SPLIT_POLICY = "sentence-split/capability"
+
 
 def _strip_punct(
     text: str,  # Text to normalize
@@ -89,8 +99,13 @@ def assign_words_to_chunks(
 ) -> List[int]:  # Chunk index for each FA word
     """Assign each FA word to a VAD chunk by timestamp overlap.
 
-    Words whose start_time falls within a chunk's [start, end] are assigned to
-    that chunk; words in silence gaps go to the nearest chunk by time proximity.
+    Words whose start_time falls within a chunk's [start, end) are assigned to
+    that chunk — HALF-OPEN, so a word starting exactly on a shared boundary
+    belongs to the chunk that STARTS there (sentence-split cuts land exactly on
+    the next word's start when FA words are contiguous; the old inclusive end
+    pulled that word one chunk LEFT — the off-by-one the 2026-07-22 probe drive
+    caught). Words in silence gaps (incl. exactly at the last chunk's end) go
+    to the nearest chunk by time proximity.
     """
     if not vad_chunks:
         return [0] * len(fa_items)
@@ -101,7 +116,7 @@ def assign_words_to_chunks(
         best_idx = 0
         best_dist = float("inf")
         for i, chunk in enumerate(vad_chunks):
-            if chunk.start_time <= t <= chunk.end_time:
+            if chunk.start_time <= t < chunk.end_time:
                 best_idx = i
                 break
             dist = min(abs(t - chunk.start_time), abs(t - chunk.end_time))
@@ -164,3 +179,79 @@ def tier1_alignment_checks(
             f"{empty}/{len(segments)} segment(s) have EMPTY text (VAD chunk with no aligned words)"
         )
     return warnings
+
+
+def sentence_end_word_indices(
+    spans: List[Tuple[int, int]],           # FA-word char spans from map_fa_words_to_text (ordered)
+    sentence_spans: List[Tuple[int, int]],  # Sentence char spans over the SAME text (ordered, non-overlapping)
+) -> Set[int]:  # Indices of FA words that END a sentence
+    """Map capability-delivered sentence boundaries onto FA words (B.5: the
+    successor of the v1-v3 `_ends_sentence` token heuristic).
+
+    A word ends a sentence when it is the LAST word whose span STARTS before
+    that sentence's end_char. Both lists are ordered over the same text, so a
+    single forward merge walk suffices; a sentence no word starts in
+    contributes nothing, and the trailing word of the text marks its sentence
+    but can never produce a cut (cuts live BETWEEN consecutive words)."""
+    out: Set[int] = set()
+    wi = 0
+    for ss, se in sentence_spans:
+        last = None
+        while wi < len(spans) and spans[wi][0] < se:
+            if spans[wi][0] >= ss:  # the word must START inside the sentence
+                last = wi
+            wi += 1
+        if last is not None:
+            out.add(last)
+    return out
+
+
+def split_chunks_at_sentence_gaps(
+    vad_chunks: List[VADChunk],  # The VAD skeleton (segment-local times)
+    fa_items: List[FAWord],      # The AUTHORITATIVE transcriber's FA words (segment-local times)
+    end_words: Set[int],         # FA-word indices that END a sentence (sentence_end_word_indices)
+    min_chunk_s: float = 0.5,    # Min sub-chunk duration — a split never mints a sliver
+) -> List[VADChunk]:  # The refined skeleton, re-indexed (identical content when nothing splits)
+    """The sentence-split stage (SENTENCE_SPLIT_POLICY, DEC f1024568): refine the
+    VAD skeleton by cutting any chunk whose assigned text crosses a sentence end.
+
+    Runs POST-FA, PRE-fold: a chunk holding a sentence-ending word that is not
+    its last word splits at the corresponding FA word gap (midpoint between the
+    ending word's end and the next word's start — the pause the VAD's min-sil
+    threshold failed to cut, finding bc69e3e6). Sentence ends arrive
+    PRECOMPUTED (B.5): the segmentation capability's char spans over the
+    authoritative text, mapped onto FA words by `sentence_end_word_indices` —
+    this function no longer inspects text. The split decision reads ONLY the
+    authoritative transcriber (montage/textless chunks have no words here and
+    pass through untouched); every transcriber then re-folds over the refined
+    skeleton, so variants stay per-chunk consistent by construction. Both
+    sides of an accepted cut must be >= `min_chunk_s` at accept time (greedy
+    left-to-right), so FA jitter cannot mint unplayable slivers.
+    """
+    assignments = assign_words_to_chunks(fa_items, vad_chunks)
+    by_chunk: Dict[int, List[int]] = {}
+    for wi, ci in enumerate(assignments):
+        by_chunk.setdefault(ci, []).append(wi)
+
+    refined: List[VADChunk] = []
+    for chunk in vad_chunks:
+        words = by_chunk.get(chunk.index, [])
+        cuts: List[float] = []
+        cur_start = chunk.start_time
+        for p in range(len(words) - 1):
+            wi, wj = words[p], words[p + 1]
+            if wi not in end_words:
+                continue
+            cut = (fa_items[wi].end_time + fa_items[wj].start_time) / 2.0
+            if not (chunk.start_time < cut < chunk.end_time):
+                continue
+            if cut - cur_start < min_chunk_s or chunk.end_time - cut < min_chunk_s:
+                continue
+            cuts.append(cut)
+            cur_start = cut
+        bounds = [chunk.start_time] + cuts + [chunk.end_time]
+        for k in range(len(bounds) - 1):
+            refined.append(VADChunk(index=0, start_time=bounds[k], end_time=bounds[k + 1]))
+    for i, c in enumerate(refined):
+        c.index = i
+    return refined

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core/cli.py

@@ -59,6 +59,21 @@ def build_parser() -> argparse.ArgumentParser:  # Configured CLI parser
                           "default: the manifest's sole transcriber)")
     run.add_argument("--sysmon-capability", default=None, help="monitor capability for GPU subtree attribution (CR-7); loaded first; default: no monitor")
     run.add_argument("--language", default="English", help="Forced-alignment language")
+    run.add_argument("--sentence-split", action=argparse.BooleanOptionalAction, default=True,
+                     help="Run the post-FA sentence-split stage (DEC f1024568): chunks whose "
+                          "text crosses a sentence end split at the FA word gap; commits a "
+                          "PARALLEL spine (new skeleton hash) — existing spines are untouched. "
+                          "DEFAULT-ON (DEC 552bde8d); --no-sentence-split opts out")
+    run.add_argument("--seg-capability", default="cjm-capability-pysbd",
+                     help="Sentence-segmentation capability name (B.5; skipped with --no-sentence-split)")
+    run.add_argument("--split-min-chunk-s", type=float, default=0.5,
+                     help="Sentence-split min sub-chunk duration guard, seconds (identity input)")
+    run.add_argument("--respine", action="store_true",
+                     help="Mint a FRESH skeleton spine under the SAME config (DEC 9241564f): "
+                          "the run id joins the Segment identity input, so the new spine "
+                          "coexists with — never collides into — the config-identical one. "
+                          "The recovery for post-upgrade re-runs the verify-collide refuses "
+                          "(finding e8458f6e); provenance = this run's manifest")
     run.add_argument("--force", action="store_true", help="Bypass capability-side caches (VAD + FA)")
     run.add_argument("-y", "--yes", action="store_true", help="Auto-accept HITL seams (headless mode)")
     run.add_argument("--output", default=None, help="Decomp-manifest output path (single-manifest runs only; default: <output-dir>/<run_id>.json)")
@@ -132,6 +147,10 @@ async def run_command(
         language=args.language,
         force=args.force,
         assume_yes=args.yes,
+        sentence_split=args.sentence_split,
+        split_min_chunk_s=args.split_min_chunk_s,
+        seg_capability=args.seg_capability,
+        respine=args.respine,
     )
 
     # CR-7 GPU subtree attribution is opt-in: --sysmon-capability threads the monitor
@@ -142,12 +161,25 @@ async def run_command(
         sysmon_capability_name=args.sysmon_capability,
     )
     instance_ids = [cfg.vad_capability, cfg.fa_capability, cfg.graph_capability]
+    if cfg.sentence_split:
+        # B.5: the segmentation capability loads only when the split stage runs.
+        instance_ids.insert(2, cfg.seg_capability)
     load_order = ([args.sysmon_capability] if args.sysmon_capability else []) + instance_ids
     # F10: --graph-db-path threads a caller-wins config into the graph load
     # (the C8 pattern correction-core already used; scratch-graph loop-backs).
     configs = ({cfg.graph_capability: {"db_path": args.graph_db_path}}
                if args.graph_db_path else None)
-    load_capabilities(manager, load_order, configs=configs)
+    try:
+        load_capabilities(manager, load_order, configs=configs)
+    except Exception as e:
+        # Sentence-split is DEFAULT-ON (DEC 552bde8d): an env without the
+        # segmentation capability must refuse with both outs, not crash.
+        if cfg.sentence_split and cfg.seg_capability in str(e):
+            raise SystemExit(
+                f"sentence-split is default-on and needs {cfg.seg_capability}: {e}\n"
+                f"either install it (cjm-ctl install-all with the capabilities yaml "
+                f"adds the env + manifest additively) or pass --no-sentence-split")
+        raise
 
     queue = JobQueue(deps=manager, sysmon_capability_name=args.sysmon_capability)
     await queue.start()

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core/graph.py

@@ -66,9 +66,10 @@ def resolve_root_ids(
 def build_extension_payload(
     source_entry: Dict[str, Any],             # One source entry from the transcription manifest
     capabilities_info: Dict[str, Dict[str, Any]],  # The transcription manifest's capabilities block
-    vad_config_hash: str,                     # THIS run's VAD capability config hash (skeleton identity input)
+    skeleton_config_hash: str,                # THIS run's skeleton-config hash (Segment identity input; = the VAD config hash when no split stage ran)
     text_from: str,                           # Authoritative transcriber (layer-0 text designation)
     segments: List[DecompSegment],            # Ordered aligned segments (per-transcriber variants attached)
+    split_policy: Optional[str] = None,       # Split policy+version that refined the skeleton (node metadata, never identity)
 ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], Dict[str, Any]]:  # (nodes, edges, ids)
     """Build the fine-spine EXTENSION payload (pure; no capability calls).
 
@@ -100,12 +101,12 @@ def build_extension_payload(
                                              end_char=var.end_char, text=var.text))
             used_transcripts.add(tid)
         node = SegmentNode(
-            rendition=a["rendition"], vad_config_hash=vad_config_hash,
+            rendition=a["rendition"], vad_config_hash=skeleton_config_hash,
             chunk_start=seg.chunk_start, chunk_end=seg.chunk_end,
             index=seg.index, start_time=seg.start_time, end_time=seg.end_time,
             text=seg.text, audio_hash=a["model_input_hash"], source=source_id,
             text_from=(a["transcripts"].get(text_from) if seg.text.strip() else None),
-            text_slices=slices,
+            split_policy=split_policy, text_slices=slices,
         )
         nodes.append(node.to_graph_node())
         seg_ids.append(node.id)
@@ -153,6 +154,7 @@ async def verify_source(
     graph_id: str,            # Graph-storage capability id
     source_id: str,           # Source node id to verify
     rendition_ids: List[str], # The AudioRendition ids the run extended (the fine spine is scoped to these)
+    segment_ids: Optional[List[str]] = None,  # THIS run's committed Segment ids — id-scopes the fine-layer checks (parallel spines); None = all segments under the renditions
 ) -> Optional[SourceVerification]:  # Result, or None if the Source is not found
     """Verify a Source's committed extension via server-side AGGREGATES (D13/D19).
 
@@ -204,21 +206,49 @@ async def verify_source(
         res = await graph_task(queue, graph_id, "query_nodes", query=q.to_dict())
         return int(res.count or 0)
 
-    n_segs = await _ncount()
-    seg_next = await _ecount(relation_type=SpineRelations.NEXT, source_related=part_of_rend)
-    seg_part_of = await _ecount(relation_type=SpineRelations.PART_OF, target_ids=rendition_ids)
-    rend_starts = await _ecount(relation_type=SpineRelations.STARTS_WITH, source_ids=rendition_ids)
-    missing_start = await _ncount(where=[PropertyPredicate("start_time", "is_null")])
-    missing_end = await _ncount(where=[PropertyPredicate("end_time", "is_null")])
-
-    # Bounded projection: sources + owning rendition in ONE pass.
-    sq = NodeQuery(label=TranscriptGraphLabels.SEGMENT, related=part_of_rend,
-                   project=["sources", "rendition_id"])
-    res = await graph_task(queue, graph_id, "query_nodes", query=sq.to_dict())
+    proj_rows: List[Dict[str, Any]] = []
+    if segment_ids is None:
+        n_segs = await _ncount()
+        seg_next = await _ecount(relation_type=SpineRelations.NEXT, source_related=part_of_rend)
+        seg_part_of = await _ecount(relation_type=SpineRelations.PART_OF, target_ids=rendition_ids)
+        rend_starts = await _ecount(relation_type=SpineRelations.STARTS_WITH, source_ids=rendition_ids)
+        missing_start = await _ncount(where=[PropertyPredicate("start_time", "is_null")])
+        missing_end = await _ncount(where=[PropertyPredicate("end_time", "is_null")])
+        # Bounded projection: sources + owning rendition in ONE pass.
+        sq = NodeQuery(label=TranscriptGraphLabels.SEGMENT, related=part_of_rend,
+                       project=["sources", "rendition_id"])
+        res = await graph_task(queue, graph_id, "query_nodes", query=sq.to_dict())
+        proj_rows = list(res.rows or [])
+    else:
+        # Id-scoped mode (parallel spines, DEC f1024568): every fine-layer
+        # aggregate counts ONLY this run's committed segments — a coexisting
+        # sibling skeleton under the same renditions (its own NEXT chain +
+        # STARTS_WITH anchor) must not fail the structural checks. Batched
+        # (bounded reads; the 500-id convention).
+        async def _icount(ids, **kw):
+            q = NodeQuery(ids=list(ids), label=TranscriptGraphLabels.SEGMENT,
+                          count=True, **kw)
+            res = await graph_task(queue, graph_id, "query_nodes", query=q.to_dict())
+            return int(res.count or 0)
+
+        n_segs = seg_next = seg_part_of = rend_starts = missing_start = missing_end = 0
+        for i in range(0, len(segment_ids), 500):
+            b = list(segment_ids[i:i + 500])
+            n_segs += await _icount(b)
+            seg_next += await _ecount(relation_type=SpineRelations.NEXT, source_ids=b)
+            seg_part_of += await _ecount(relation_type=SpineRelations.PART_OF, source_ids=b)
+            rend_starts += await _ecount(relation_type=SpineRelations.STARTS_WITH, target_ids=b)
+            missing_start += await _icount(b, where=[PropertyPredicate("start_time", "is_null")])
+            missing_end += await _icount(b, where=[PropertyPredicate("end_time", "is_null")])
+            pq = NodeQuery(ids=b, label=TranscriptGraphLabels.SEGMENT,
+                           project=["sources", "rendition_id"])
+            res = await graph_task(queue, graph_id, "query_nodes", query=pq.to_dict())
+            proj_rows.extend(res.rows or [])
+
     missing_sources = 0
     locators = set()
     owning_renditions = set()
-    for r in (res.rows or []):
+    for r in proj_rows:
         sources = r.get("sources") or []
         if not sources:
             missing_sources += 1

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core/models.py

@@ -117,6 +117,10 @@ class DecompConfig:
     media_type: str = "audio"  # Source media type
     force: bool = False        # Bypass capability-side caches (VAD + FA)
     assume_yes: bool = False   # Auto-accept HITL seams (headless mode)
+    sentence_split: bool = True     # Run the post-FA sentence-split stage (DEC f1024568; parallel spine) — DEFAULT-ON per DEC 552bde8d (hiding splits just hides model failures)
+    split_min_chunk_s: float = 0.5  # Sentence-split min sub-chunk duration guard (seconds)
+    seg_capability: str = "cjm-capability-pysbd"  # Sentence-segmentation capability id (B.5; loaded only when sentence_split)
+    respine: bool = False           # Mint a FRESH skeleton under the SAME config (DEC 9241564f): the run id joins the identity input, so the new spine never collides with the config-identical one (post-upgrade re-runs, finding e8458f6e)
 
     def to_dict(self) -> Dict[str, Any]:  # Plain-dict snapshot for the manifest
         """Serialize to a plain dict."""
@@ -153,9 +157,11 @@ class DecompManifest:
     source_version: str = ""  # Upstream manifest schema version
     capabilities: Dict[str, Dict[str, Any]] = field(default_factory=dict)  # instance_id -> identity/db_path/config_hash
     sources: List[DecompSourceRecord] = field(default_factory=list)   # Extended sources, input order
+    skeleton_config_hash: str = ""      # Segment identity input (0.2.2): VAD config hash, or the composite when a split stage ran
+    split_policy: Optional[str] = None  # Split policy+version that refined this run's skeleton (None = raw VAD)
 
     FORMAT: str = field(default="cjm-transcript-decomp-core/run-manifest", repr=False)  # Format tag
-    VERSION: str = field(default="0.2.1", repr=False)                                   # Schema version
+    VERSION: str = field(default="0.2.3", repr=False)                                   # Schema version (0.2.3: capability-driven sentence split — seg capability in `capabilities` + segmenter identity in the skeleton composite)
 
     def to_dict(self) -> Dict[str, Any]:  # Plain-dict form for JSON serialization
         """Serialize to a plain dict with nested sources."""
@@ -169,6 +175,8 @@ class DecompManifest:
             "source_format": self.source_format,
             "source_version": self.source_version,
             "capabilities": self.capabilities,
+            "skeleton_config_hash": self.skeleton_config_hash,
+            "split_policy": self.split_policy,
             "sources": [s.to_dict() for s in self.sources],
         }
 

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core/pipeline.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from cjm_capability_primitives.forced_alignment import ForcedAlignResult
+from cjm_capability_primitives.sentence_segmentation import SentenceSegmentationResult
 from cjm_capability_primitives.vad import VADResult
 from cjm_context_graph_layer.declare import Derivation, derivation_to_graph
 from cjm_context_graph_layer.journal import journal_extend, sidecar_journal_path, wires_handlers
@@ -20,7 +21,10 @@ from cjm_substrate.core.queue import JobQueue, JobStatus
 from cjm_substrate.core.workspace import resolve_recorded_tree
 from cjm_transcript_decomp_core.alignment import (assign_words_to_chunks,
                                                   build_segments_from_alignment,
-                                                  map_fa_words_to_text, tier1_alignment_checks)
+                                                  map_fa_words_to_text, sentence_end_word_indices,
+                                                  SENTENCE_SPLIT_POLICY,
+                                                  split_chunks_at_sentence_gaps,
+                                                  tier1_alignment_checks)
 from cjm_transcript_decomp_core.graph import (build_extension_payload, resolve_root_ids,
                                               verify_source)
 from cjm_transcript_decomp_core.models import (DecompConfig, DecompManifest, DecompSegment,
@@ -28,12 +32,13 @@ from cjm_transcript_decomp_core.models import (DecompConfig, DecompManifest, Dec
                                                SegmentVariant, VADChunk)
 
 # Typed wire-kind registration (stage 2): importing the DTO classes is what
-# lets the proxy's wire_decode hand this host process TYPED results. Both result
-# nouns live in cjm-capability-primitives (Option C / PILLAR 1c — the tool/host
-# depend on the data noun, never the adapter machinery). The tuple keeps these
-# SIDE-EFFECT imports referenced so the canonical emit cannot prune them.
+# lets the proxy's wire_decode hand this host process TYPED results. All three
+# result nouns live in cjm-capability-primitives (Option C / PILLAR 1c — the
+# tool/host depend on the data noun, never the adapter machinery). The tuple
+# keeps these SIDE-EFFECT imports referenced so the canonical emit cannot
+# prune them.
 
-_REGISTERED_WIRE_KINDS = (VADResult, ForcedAlignResult)
+_REGISTERED_WIRE_KINDS = (VADResult, ForcedAlignResult, SentenceSegmentationResult)
 
 logger = logging.getLogger(__name__)
 
@@ -105,18 +110,26 @@ def build_alignment_composition(
     fa_id: str,                # Forced-alignment capability instance id
     transcribers: List[str],   # Transcriber names to align (manifest `transcripts` keys, stable order)
     force: bool = False,       # Per-call cache-bypass control flag
+    seg_id: Optional[str] = None,        # Sentence-segmentation capability instance id (B.5; None = no split stage)
+    seg_text_from: Optional[str] = None,  # Authoritative transcriber whose text the segmenter reads
 ) -> Tuple[Composition, List[Dict[str, Any]]]:  # (composition, per-pseg meta rows)
-    """Build the whole-source M×(VAD ∥ T×FA) composition (D8 fan-in, stage-5 variants).
+    """Build the whole-source M×(VAD ∥ T×FA ∥ SEG) composition (D8 fan-in, stage-5 variants).
 
     Each pipeline segment contributes one VAD node + one FA node PER TRANSCRIBER
     with non-empty text — VAD is audio-only (run once; the shared skeleton), FA
-    maps each transcriber's text onto it. All nodes are independent; the host's
-    alignment fold fans them in. Pipeline segments where EVERY transcriber's
-    text is empty are recorded as skipped meta rows and contribute no nodes.
-
-    Stage 8 (Option C): every node rides the TASK CHANNEL now — VAD on
-    vad/detect_speech, FA on forced_alignment/align — and per-call `force` rides
-    `control` (the adapters own caching). The native-routed path is gone.
+    maps each transcriber's text onto it. With the sentence-split stage on
+    (`seg_id` + `seg_text_from`, B.5), each pipeline segment where the
+    authoritative transcriber has text also contributes one sentence-
+    segmentation node over that text (the text is known from the manifest, so
+    segmentation rides the SAME composition as VAD/FA — no second round trip).
+    All nodes are independent; the host's alignment fold fans them in. Pipeline
+    segments where EVERY transcriber's text is empty are recorded as skipped
+    meta rows and contribute no nodes.
+
+    Stage 8 (Option C): every node rides the TASK CHANNEL — VAD on
+    vad/detect_speech, FA on forced_alignment/align, segmentation on
+    sentence_segmentation/segment_text — and per-call `force` rides `control`
+    (the adapters own caching; the segmentation adapter is cache-free).
     """
     nodes: List[CompositionNode] = []
     metas: List[Dict[str, Any]] = []
@@ -152,8 +165,18 @@ def build_alignment_composition(
                                          task_name="forced_alignment", method="align",
                                          control={"force": force}))
             fa_nodes[t] = fa_n
-        metas.append({"skipped": False, "seg_start": seg_start, "pseg_index": i,
-                      "vad_node": vad_n, "fa_nodes": fa_nodes, "texts": nonempty})
+        meta = {"skipped": False, "seg_start": seg_start, "pseg_index": i,
+                "vad_node": vad_n, "fa_nodes": fa_nodes, "texts": nonempty}
+        if seg_id and seg_text_from in nonempty:
+            seg_n = f"seg_{i:04d}"
+            # Sentence segmentation via the task channel over the AUTHORITATIVE
+            # transcriber's text (the split stage reads only that transcriber).
+            nodes.append(CompositionNode(seg_n, seg_id,
+                                         {"text": nonempty[seg_text_from]},
+                                         task_name="sentence_segmentation",
+                                         method="segment_text"))
+            meta["seg_node"] = seg_n
+        metas.append(meta)
     return Composition(nodes=nodes), metas
 
 
@@ -178,7 +201,9 @@ async def decompose_source(
     seg_list = list(source.get("segments") or [])
 
     comp, metas = build_alignment_composition(
-        seg_list, cfg.vad_capability, cfg.fa_capability, transcribers, force=cfg.force)
+        seg_list, cfg.vad_capability, cfg.fa_capability, transcribers, force=cfg.force,
+        seg_id=(cfg.seg_capability if cfg.sentence_split else None),
+        seg_text_from=text_from)
     results: Dict[str, Any] = {}
     if comp.nodes:
         comp_id = await queue.submit_composition(comp)
@@ -200,15 +225,37 @@ async def decompose_source(
             continue
         vad_chunks = vad_chunks_from_result(results[m["vad_node"]])
 
+        # Normalize each transcriber's FA output once (words + char spans).
+        per_t_words: Dict[str, List[FAWord]] = {}
+        per_t_spans: Dict[str, List[Tuple[int, int]]] = {}
+        for t, fa_n in m["fa_nodes"].items():
+            per_t_words[t] = fa_words_from_result(results[fa_n])
+            per_t_spans[t] = map_fa_words_to_text(m["texts"][t], per_t_words[t])
+
+        # Sentence-split stage (DEC f1024568 / B.5 capability form): refine the
+        # shared skeleton at the AUTHORITATIVE transcriber's sentence ends BEFORE
+        # any fold — every transcriber re-folds over the same refined skeleton,
+        # so variants stay per-chunk consistent by construction. Sentence
+        # boundaries come from the segmentation capability's char spans over the
+        # authoritative text, mapped onto FA words. Chunks the authoritative
+        # transcriber has no words for (montage/textless) pass through whole.
+        if cfg.sentence_split and text_from in per_t_words and m.get("seg_node"):
+            sentence_spans = sentence_spans_from_result(results[m["seg_node"]])
+            end_words = sentence_end_word_indices(per_t_spans[text_from], sentence_spans)
+            n_before = len(vad_chunks)
+            vad_chunks = split_chunks_at_sentence_gaps(
+                vad_chunks, per_t_words[text_from], end_words,
+                min_chunk_s=cfg.split_min_chunk_s)
+            if len(vad_chunks) != n_before:
+                logger.info(f"[src {source_index}] pseg @ {seg_start:.1f}s: "
+                            f"sentence-split {n_before} -> {len(vad_chunks)} chunk(s)")
+
         # Per-transcriber fold over the SHARED skeleton.
         per_t_segments: Dict[str, List[Any]] = {}
-        for t, fa_n in m["fa_nodes"].items():
-            text = m["texts"][t]
-            fa_words = fa_words_from_result(results[fa_n])
-            spans = map_fa_words_to_text(text, fa_words)
-            assignments = assign_words_to_chunks(fa_words, vad_chunks)
+        for t in m["fa_nodes"]:
             per_t_segments[t] = build_segments_from_alignment(
-                text=text, spans=spans, assignments=assignments,
+                text=m["texts"][t], spans=per_t_spans[t],
+                assignments=assign_words_to_chunks(per_t_words[t], vad_chunks),
                 num_chunks=len(vad_chunks), source_provider_id=t,
             )
         auth = per_t_segments.get(text_from)
@@ -382,9 +429,29 @@ async def run_decomp(
         run_id=run_id, created_at=time.time(), config=cfg.to_dict(),
         source_manifest=str(source_manifest_path),
         source_format=src.get("format", ""), source_version=src.get("version", ""),
-        capabilities=collect_capability_info(manager, [cfg.vad_capability, cfg.fa_capability, cfg.graph_capability]),
+        capabilities=collect_capability_info(manager, [cfg.vad_capability, cfg.fa_capability, cfg.graph_capability]
+                                             + ([cfg.seg_capability] if cfg.sentence_split else [])),
     )
     vad_config_hash = str((manifest.capabilities.get(cfg.vad_capability) or {}).get("config_hash") or "")
+    # Skeleton identity (DEC f1024568): the Segment identity input WIDENS to a
+    # skeleton-config hash — the raw VAD hash when no split stage runs (legacy-
+    # identical ids), a composite over {vad config hash, split policy + params}
+    # when sentence-split is on, so split spines COEXIST with the originals by
+    # construction (no node id is shared across skeletons).
+    split_policy = SENTENCE_SPLIT_POLICY if cfg.sentence_split else None
+    # B.5: the SEGMENTER's identity (capability name + effective-config hash)
+    # joins the composite — two spines cut by different segmenters (or the
+    # same segmenter reconfigured) can never share node ids. --respine widens
+    # the identity with THIS run's id (fresh spine, same config, DEC 9241564f).
+    seg_config_hash = (str((manifest.capabilities.get(cfg.seg_capability) or {}).get("config_hash") or "")
+                       if split_policy else "")
+    skeleton_config_hash = compute_skeleton_hash(
+        vad_config_hash, split_policy=split_policy,
+        split_min_chunk_s=cfg.split_min_chunk_s,
+        seg_capability=cfg.seg_capability, seg_config_hash=seg_config_hash,
+        respine_token=run_id if cfg.respine else None)
+    manifest.skeleton_config_hash = skeleton_config_hash
+    manifest.split_policy = split_policy
     # Pipeline writes append through to the graph db's SIDECAR journal (DEC ccbab9f5 /
     # finding 4219da27): unjournaled ingestion would erode db-rebuildability.
     graph_db_path = (manifest.capabilities.get(cfg.graph_capability) or {}).get("db_path")
@@ -417,7 +484,8 @@ async def run_decomp(
                 break
 
             nodes, edges, ids = build_extension_payload(
-                source, src_capabilities, vad_config_hash, text_from, aligned)
+                source, src_capabilities, skeleton_config_hash, text_from, aligned,
+                split_policy=split_policy)
 
             if not confirm_seam("commit-review",
                                 [f"{title}: extending Source {ids['source'][:8]}… with "
@@ -450,8 +518,11 @@ async def run_decomp(
                                      actor="pipeline:cjm-transcript-decomp-core", run=run_id,
                                      args={"method": "alignment-fold/v1"})
 
-            # Fine spine hangs under the run's renditions — verify scopes there.
-            vr = await verify_source(queue, cfg.graph_capability, ids["source"], ids["renditions"])
+            # Fine spine hangs under the run's renditions — verify scopes there,
+            # id-scoped to THIS run's segments (a coexisting sibling spine under
+            # the same renditions must not fail the structural checks).
+            vr = await verify_source(queue, cfg.graph_capability, ids["source"],
+                                     ids["renditions"], segment_ids=ids["segments"])
             if vr is None:
                 logger.error(f"[src {i}] verify: Source {ids['source']} NOT FOUND in graph")
             else:
@@ -501,3 +572,41 @@ def decomp_replay_handlers() -> Dict[str, Any]:  # verb -> async handler(queue,
     `apply_wires` (identity-comparable across cores: transcription also emits
     `derivation`, and the shared handler keeps that collision legal)."""
     return wires_handlers("spine-extension", "derivation")
+
+
+def sentence_spans_from_result(
+    result: "SentenceSegmentationResult",  # Typed segmentation result (wire-decoded at the proxy)
+) -> List[Tuple[int, int]]:  # Ordered (start_char, end_char) sentence spans
+    """Normalize a typed sentence-segmentation result into char-span tuples (pure; B.5)."""
+    return [(int(s.start_char), int(s.end_char)) for s in result.spans]
+
+
+def compute_skeleton_hash(
+    vad_config_hash: str,                 # The VAD stage's effective-config hash (the legacy identity)
+    split_policy: Optional[str] = None,   # Split policy+version when the split stage ran (None = no split)
+    split_min_chunk_s: float = 0.5,       # Split guard (identity input when splitting)
+    seg_capability: str = "",             # Segmenter capability name (identity input when splitting, B.5)
+    seg_config_hash: str = "",            # Segmenter effective-config hash (identity input when splitting)
+    respine_token: Optional[str] = None,  # Distinct-spine token (--respine, DEC 9241564f); None = normal identity
+) -> str:  # The skeleton-config hash every Segment id + skeleton_hash prop derive from
+    """Skeleton identity, pure (DEC f1024568 + 9241564f).
+
+    The raw VAD hash when no split stage runs (legacy-identical ids); a
+    composite over {vad, split policy+params, segmenter identity} when
+    sentence-split is on. `respine_token` WIDENS whichever identity applies:
+    same config, FRESH spine, as a deliberate act — the minted hash can never
+    collide with the config-identical spine (the e8458f6e post-upgrade
+    verify-collide), and the token (the decomp run id) keeps the re-spine
+    provenance-visible in the manifest."""
+    h = vad_config_hash
+    if split_policy:
+        h = compute_config_hash({
+            "vad_config_hash": vad_config_hash,
+            "split_policy": split_policy,
+            "split_min_chunk_s": split_min_chunk_s,
+            "seg_capability": seg_capability,
+            "seg_config_hash": seg_config_hash,
+        })
+    if respine_token:
+        h = compute_config_hash({"base_skeleton_hash": h, "respine": str(respine_token)})
+    return h

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5/cjm_transcript_decomp_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-decomp-core
-Version: 0.0.4
+Version: 0.0.5
 Summary: A frontend-agnostic core for the transcript decomposition workflow — composes isolated capability workers (forced alignment, VAD, graph storage) into a headless pipeline that decomposes transcription run manifests into a VAD-aligned context-graph spine with traceable provenance, and a CLI as its first driver.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cjm_substrate>=0.0.57
 Requires-Dist: cjm_context_graph_primitives>=0.0.15
-Requires-Dist: cjm_capability_primitives>=0.0.10
+Requires-Dist: cjm_capability_primitives>=0.0.11
 Requires-Dist: cjm-context-graph-layer>=0.0.11
 Requires-Dist: cjm-transcript-graph-schema>=0.0.7
 Dynamic: license-file
@@ -38,6 +38,8 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `assign_words_to_chunks` _function_ — Assign each FA word to a VAD chunk by timestamp overlap.
 - `build_segments_from_alignment` _function_ — Build a TextSegment per VAD chunk by grouping words by chunk assignment.
 - `map_fa_words_to_text` _function_ — Map forced-alignment words back to character spans in the original text.
+- `sentence_end_word_indices` _function_ — Map capability-delivered sentence boundaries onto FA words (B.5: the
+- `split_chunks_at_sentence_gaps` _function_ — The sentence-split stage (SENTENCE_SPLIT_POLICY, DEC f1024568): refine the
 - `tier1_alignment_checks` _function_ — Tier-1 deterministic pre-filters for the alignment-review seam (no AI).
 
 ### `cjm_transcript_decomp_core.cli`
@@ -68,14 +70,16 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.pipeline`
 
-- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA) composition (D8 fan-in, stage-5 variants).
+- `build_alignment_composition` _function_ — Build the whole-source M×(VAD ∥ T×FA ∥ SEG) composition (D8 fan-in, stage-5 variants).
 - `collect_capability_info` _function_ — Record capability identity + data-DB pointers for the run manifest (provenance).
+- `compute_skeleton_hash` _function_ — Skeleton identity, pure (DEC f1024568 + 9241564f).
 - `confirm_seam` _function_ — HITL approval seam in its cheapest viable form (log + optional CLI prompt).
 - `decomp_replay_handlers` _function_ — The decomp core's replay vocabulary (DEC 426658f1, replay stays DOMAIN-OWNED).
 - `decompose_source` _function_ — Decompose one source into aligned fine segments with per-transcriber variants.
 - `fa_words_from_result` _function_ — Normalize a typed forced-alignment result into FA words (pure; stage 3).
 - `load_source_manifest` _function_ — Load + lightly validate a transcription-core run manifest.
 - `run_decomp` _function_ — Extend every source in a transcription run manifest with its fine spine.
+- `sentence_spans_from_result` _function_ — Normalize a typed sentence-segmentation result into char-span tuples (pure; B.5).
 - `submit_and_wait` _function_ — Submit one capability job, wait for it, and return its result (raise on failure).
 - `vad_chunks_from_result` _function_ — Normalize a typed VAD result into segment-local VAD chunks.
 

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/cjm_transcript_decomp_core.egg-info/requires.txt

@@ -1,5 +1,5 @@
 cjm_substrate>=0.0.57
 cjm_context_graph_primitives>=0.0.15
-cjm_capability_primitives>=0.0.10
+cjm_capability_primitives>=0.0.11
 cjm-context-graph-layer>=0.0.11
 cjm-transcript-graph-schema>=0.0.7

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
 ]
-dependencies = ['cjm_substrate>=0.0.57', 'cjm_context_graph_primitives>=0.0.15', 'cjm_capability_primitives>=0.0.10', 'cjm-context-graph-layer>=0.0.11', 'cjm-transcript-graph-schema>=0.0.7']
+dependencies = ['cjm_substrate>=0.0.57', 'cjm_context_graph_primitives>=0.0.15', 'cjm_capability_primitives>=0.0.11', 'cjm-context-graph-layer>=0.0.11', 'cjm-transcript-graph-schema>=0.0.7']
 
 [project.urls]
 Repository = "https://github.com/cj-mills/cjm-transcript-decomp-core"

cjm_transcript_decomp_core-0.0.5/tests/test_alignment.py

@@ -0,0 +1,194 @@
+"""Tests for cjm_transcript_decomp_core.alignment — pure forced-alignment logic.
+
+Projected from the alignment notebook's smoke-check cell at the golden-reference flip
+(pure logic; deterministic)."""
+from cjm_transcript_decomp_core.alignment import (
+    assign_words_to_chunks,
+    build_segments_from_alignment,
+    map_fa_words_to_text,
+    sentence_end_word_indices,
+    split_chunks_at_sentence_gaps,
+    tier1_alignment_checks,
+)
+from cjm_transcript_decomp_core.models import FAWord, VADChunk
+
+TEXT = "Hello world. Foo bar."
+FA = [FAWord("hello", 0.0, 0.5), FAWord("world", 0.5, 1.0),
+      FAWord("foo", 2.0, 2.5), FAWord("bar", 2.5, 3.0)]
+CHUNKS = [VADChunk(0, 0.0, 1.2), VADChunk(1, 1.9, 3.1)]
+
+
+def test_map_fa_words_to_text_spans():
+    spans = map_fa_words_to_text(TEXT, FA)
+    assert len(spans) == 4
+    assert TEXT[spans[0][0]:spans[0][1]] == "Hello"
+    assert TEXT[spans[1][0]:spans[1][1]] == "world."
+
+
+def test_assign_words_to_chunks_by_timestamp():
+    assert assign_words_to_chunks(FA, CHUNKS) == [0, 0, 1, 1]
+
+
+def test_build_segments_per_chunk():
+    spans = map_fa_words_to_text(TEXT, FA)
+    assign = assign_words_to_chunks(FA, CHUNKS)
+    segs = build_segments_from_alignment(TEXT, spans, assign, num_chunks=2)
+    assert len(segs) == 2
+    assert segs[0].text == "Hello world."
+    assert segs[1].text == "Foo bar."
+    assert tier1_alignment_checks(segs, CHUNKS) == []
+
+
+def test_empty_chunk_yields_empty_segment_warning():
+    # empty-chunk case -> empty-segment warning
+    spans = map_fa_words_to_text(TEXT, FA)
+    segs2 = build_segments_from_alignment(TEXT, spans, [0, 0, 0, 0], num_chunks=2)
+    assert segs2[1].text == ""
+    assert any("EMPTY" in w for w in tier1_alignment_checks(segs2, CHUNKS))
+
+
+def test_sentence_split_cuts_at_fa_word_gap():
+    # One fluent chunk holding two sentences (the bc69e3e6 shape): the cut lands
+    # at the midpoint of the FA gap after the sentence-ending word.
+    text = "Hello world. Foo bar."
+    fa = [FAWord("hello", 0.0, 0.5), FAWord("world", 0.5, 1.0),
+          FAWord("foo", 1.4, 2.5), FAWord("bar", 2.5, 3.0)]
+    chunks = [VADChunk(0, 0.0, 3.1)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(
+        spans, sent_spans(text, "Hello world.", "Foo bar."))
+    assert end_words == {1, 3}
+    refined = split_chunks_at_sentence_gaps(chunks, fa, end_words)
+    assert [(c.start_time, c.end_time) for c in refined] == [(0.0, 1.2), (1.2, 3.1)]
+    assert [c.index for c in refined] == [0, 1]
+    # ...and the standard fold over the refined skeleton yields <=1 sentence per chunk.
+    segs = build_segments_from_alignment(
+        text, spans, assign_words_to_chunks(fa, refined), num_chunks=2)
+    assert [s.text for s in segs] == ["Hello world.", "Foo bar."]
+
+
+def test_sentence_split_no_op_cases():
+    text = "Hello world. Foo bar."
+    fa = [FAWord("hello", 0.0, 0.5), FAWord("world", 0.5, 1.0),
+          FAWord("foo", 2.0, 2.5), FAWord("bar", 2.5, 3.0)]
+    chunks = [VADChunk(0, 0.0, 1.2), VADChunk(1, 1.9, 3.1)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(
+        spans, sent_spans(text, "Hello world.", "Foo bar."))
+    # Already one sentence per chunk: the sentence ends fall on chunk-final
+    # words, so nothing splits and the skeleton passes through re-indexed.
+    refined = split_chunks_at_sentence_gaps(chunks, fa, end_words)
+    assert [(c.start_time, c.end_time) for c in refined] == [(0.0, 1.2), (1.9, 3.1)]
+    # Textless/montage chunks (no words assigned anywhere) pass through whole.
+    assert [(c.start_time, c.end_time)
+            for c in split_chunks_at_sentence_gaps(chunks, [], set())] \
+        == [(0.0, 1.2), (1.9, 3.1)]
+
+
+def test_sentence_split_min_duration_guard():
+    # The sentence gap sits 0.25s from the chunk end — a cut would mint a
+    # sliver, so the guard refuses it and the chunk survives whole.
+    text = "Hello world. Hi."
+    fa = [FAWord("hello", 0.0, 0.5), FAWord("world", 0.5, 2.6),
+          FAWord("hi", 2.7, 2.9)]
+    chunks = [VADChunk(0, 0.0, 2.9)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(
+        spans, sent_spans(text, "Hello world.", "Hi."))
+    refined = split_chunks_at_sentence_gaps(chunks, fa, end_words, min_chunk_s=0.5)
+    assert [(c.start_time, c.end_time) for c in refined] == [(0.0, 2.9)]
+    # A permissive guard lets the same cut through.
+    loose = split_chunks_at_sentence_gaps(chunks, fa, end_words, min_chunk_s=0.1)
+    assert [(round(c.start_time, 2), round(c.end_time, 2)) for c in loose] \
+        == [(0.0, 2.65), (2.65, 2.9)]
+
+
+def test_sentence_split_three_way_cut():
+    # Three capability-delivered sentences in one chunk ('dispatch."' / 'Why?' /
+    # 'Because.') -> two cuts at the FA gaps after each sentence-ending word.
+    text = 'He said "dispatch." Why? Because.'
+    fa = [FAWord("he", 0.0, 0.3), FAWord("said", 0.3, 0.6),
+          FAWord("dispatch", 0.6, 1.5), FAWord("why", 2.1, 2.8),
+          FAWord("because", 3.5, 4.2)]
+    chunks = [VADChunk(0, 0.0, 4.4)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(
+        spans, sent_spans(text, 'He said "dispatch."', "Why?", "Because."))
+    assert end_words == {2, 3, 4}
+    refined = split_chunks_at_sentence_gaps(chunks, fa, end_words)
+    assert [(round(c.start_time, 2), round(c.end_time, 2)) for c in refined] \
+        == [(0.0, 1.8), (1.8, 3.15), (3.15, 4.4)]
+
+
+def test_sentence_split_capability_spans_drive_the_decision():
+    # (1) The v2-era abbreviation class ('U.S.' mid-sentence) is now the
+    # SEGMENTER's problem: one capability span covering the whole text means
+    # no end-word lands mid-chunk, so nothing cuts (segmenter correctness for
+    # this class is pinned in the cjm-capability-pysbd suite).
+    text = "Sitting down with the U.S. Secretary of Energy."
+    fa = [FAWord("sitting", 0.0, 0.4), FAWord("down", 0.4, 0.8),
+          FAWord("with", 0.8, 1.1), FAWord("the", 1.1, 1.3),
+          FAWord("us", 1.3, 2.0), FAWord("secretary", 2.0, 2.9),
+          FAWord("of", 2.9, 3.1), FAWord("energy", 3.1, 3.8)]
+    chunks = [VADChunk(0, 0.0, 4.0)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(spans, sent_spans(text, text))
+    assert [(c.start_time, c.end_time)
+            for c in split_chunks_at_sentence_gaps(chunks, fa, end_words)] \
+        == [(0.0, 4.0)]
+
+    # (2) Contiguous FA words (zero gap at the cut): the boundary word must land
+    # RIGHT of the cut — text and audio agree (the off-by-one drive finding).
+    text2 = "Stagnant on energy growth. Any fundamental reason?"
+    fa2 = [FAWord("stagnant", 0.0, 0.6), FAWord("on", 0.6, 0.8),
+           FAWord("energy", 0.8, 1.2), FAWord("growth", 1.2, 1.8),
+           FAWord("any", 1.8, 2.1), FAWord("fundamental", 2.1, 2.8),
+           FAWord("reason", 2.8, 3.3)]
+    chunks2 = [VADChunk(0, 0.0, 3.5)]
+    spans2 = map_fa_words_to_text(text2, fa2)
+    end_words2 = sentence_end_word_indices(
+        spans2, sent_spans(text2, "Stagnant on energy growth.",
+                           "Any fundamental reason?"))
+    refined = split_chunks_at_sentence_gaps(chunks2, fa2, end_words2)
+    assert [(c.start_time, c.end_time) for c in refined] == [(0.0, 1.8), (1.8, 3.5)]
+    segs = build_segments_from_alignment(
+        text2, spans2, assign_words_to_chunks(fa2, refined), num_chunks=2)
+    assert [s.text for s in segs] == ["Stagnant on energy growth.",
+                                      "Any fundamental reason?"]
+
+
+def test_sentence_end_word_indices_merge_walk():
+    # The word<->sentence merge walk directly: the 'Mr. Gorbachev' class is one
+    # capability span (no mid-sentence end word); a real sentence end right
+    # after a title stub still marks its last word.
+    text = "He met Dr. Smith. Then he left."
+    fa = [FAWord("he", 0.0, 0.3), FAWord("met", 0.3, 0.6),
+          FAWord("dr", 0.6, 0.9), FAWord("smith", 0.9, 1.6),
+          FAWord("then", 2.4, 2.7), FAWord("he", 2.7, 2.9),
+          FAWord("left", 2.9, 3.3)]
+    spans = map_fa_words_to_text(text, fa)
+    end_words = sentence_end_word_indices(
+        spans, sent_spans(text, "He met Dr. Smith.", "Then he left."))
+    assert end_words == {3, 6}  # 'Smith.' and 'left.' — never 'Dr.'
+    chunks = [VADChunk(0, 0.0, 3.5)]
+    assert [(c.start_time, c.end_time)
+            for c in split_chunks_at_sentence_gaps(chunks, fa, end_words)] \
+        == [(0.0, 2.0), (2.0, 3.5)]
+    # A sentence no word starts in (e.g. segmenter output beyond the FA tail)
+    # contributes nothing; empty inputs stay empty.
+    assert sentence_end_word_indices(spans, [(900, 950)]) == set()
+    assert sentence_end_word_indices([], [(0, 10)]) == set()
+    assert sentence_end_word_indices(spans, []) == set()
+
+
+def sent_spans(text, *sentences):
+    """Char spans for the given sentence strings within `text` — what the
+    segmentation capability delivers for this text (B.5: the tests feed the
+    capability's OUTPUT SHAPE; segmenter correctness lives in the
+    cjm-capability-pysbd suite)."""
+    spans, pos = [], 0
+    for s in sentences:
+        start = text.index(s, pos)
+        spans.append((start, start + len(s)))
+        pos = start + len(s)
+    return spans

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/tests/test_graph.py

@@ -106,3 +106,20 @@ def test_provenance_refs_and_text_from():
     n2 = nodes[2]
     assert len(n2["sources"]) == 1 and "text_from" not in n2["properties"]
     assert n2["properties"]["text"] == ""
+
+
+def test_parallel_spines_disjoint_ids_and_split_metadata():
+    # DEC f1024568: a split run passes a DIFFERENT skeleton hash — every node id
+    # forks, so the split spine coexists with the original by construction.
+    base_nodes, _, base_ids = build_extension_payload(
+        SOURCE_ENTRY, CAPABILITIES, "sha256:vad", "voxtral", _segments())
+    split_nodes, _, split_ids = build_extension_payload(
+        SOURCE_ENTRY, CAPABILITIES, "sha256:skel-split", "voxtral", _segments(),
+        split_policy="sentence-split/v1")
+    assert set(base_ids["segments"]).isdisjoint(split_ids["segments"])
+    # The identity input rides every node as the queryable skeleton_hash prop;
+    # split runs also record their policy tag (base runs carry no split_policy).
+    assert all(n["properties"]["skeleton_hash"] == "sha256:vad" for n in base_nodes)
+    assert all("split_policy" not in n["properties"] for n in base_nodes)
+    assert all(n["properties"]["skeleton_hash"] == "sha256:skel-split" for n in split_nodes)
+    assert all(n["properties"]["split_policy"] == "sentence-split/v1" for n in split_nodes)

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/tests/test_models.py

@@ -38,7 +38,9 @@ def test_manifest_shape_and_run_id():
     m = DecompManifest(run_id="r", created_at=0.0, config={}, source_manifest="/tmp/s.json")
     md = m.to_dict()
     assert md["format"] == "cjm-transcript-decomp-core/run-manifest"
-    assert md["version"] == "0.2.1" and md["sources"] == []
+    assert md["version"] == "0.2.3" and md["sources"] == []
+    # 0.2.2: skeleton identity rides the manifest (empty/None until run_decomp fills them)
+    assert md["skeleton_config_hash"] == "" and md["split_policy"] is None
     rec = DecompSourceRecord(source_node_id="sid", source_path="/a.mp3", title="a",
                              segment_count=2, segment_ids=["s1", "s2"])
     assert rec.to_dict()["source_node_id"] == "sid"

{cjm_transcript_decomp_core-0.0.4 → cjm_transcript_decomp_core-0.0.5}/tests/test_pipeline.py

@@ -64,3 +64,54 @@ def test_alignment_nodes_ride_the_task_channel():
     assert comp.nodes[2].control == {"force": False}
     run = new_composition_run(comp, "r")
     assert set(run.ready_nodes()) == {"vad_0000", "fa_t0_0000", "fa_t1_0000", "vad_0002", "fa_t0_0002"}
+
+
+def test_alignment_composition_seg_nodes():
+    # B.5: with a segmentation capability + authoritative transcriber, each
+    # non-skipped pseg where the authoritative transcriber has text also gets
+    # one sentence_segmentation/segment_text node over that text — riding the
+    # SAME composition (the text comes from the manifest, not from FA).
+    comp, metas = build_alignment_composition(
+        SEGS, "silero", "qwen3", ["whisper", "voxtral"],
+        seg_id="pysbd", seg_text_from="voxtral")
+    by_name = {n.id: n for n in comp.nodes}
+    # pseg0: voxtral has text -> seg node; pseg1: skipped; pseg2: voxtral empty -> none.
+    assert metas[0]["seg_node"] == "seg_0000"
+    seg = by_name["seg_0000"]
+    assert seg.kwargs == {"text": "Alpha."}
+    assert seg.task_name == "sentence_segmentation" and seg.method == "segment_text"
+    assert "seg_node" not in metas[2]
+    assert len(comp.nodes) == 6
+    # Without a seg capability the composition is unchanged (no seg nodes).
+    comp2, metas2 = build_alignment_composition(SEGS, "silero", "qwen3",
+                                                ["whisper", "voxtral"])
+    assert len(comp2.nodes) == 5 and all("seg_node" not in m for m in metas2)
+
+
+def test_compute_skeleton_hash_identity_and_respine():
+    """DEC f1024568 + 9241564f: no-split = the raw VAD hash (legacy-identical
+    ids); split = the B.5 composite; --respine widens EITHER identity with the
+    run token — distinct from the config-identical spine, deterministic per
+    token, and never equal across tokens."""
+    from cjm_transcript_decomp_core.pipeline import compute_skeleton_hash
+    vad = "vadhash123"
+    assert compute_skeleton_hash(vad) == vad
+    split = compute_skeleton_hash(vad, split_policy="pysbd-sentence-v2",
+                                  split_min_chunk_s=0.5,
+                                  seg_capability="cjm-capability-pysbd",
+                                  seg_config_hash="seghash")
+    assert split != vad
+    assert split == compute_skeleton_hash(vad, split_policy="pysbd-sentence-v2",
+                                          split_min_chunk_s=0.5,
+                                          seg_capability="cjm-capability-pysbd",
+                                          seg_config_hash="seghash")
+    r1 = compute_skeleton_hash(vad, respine_token="decomp_run_1")
+    r2 = compute_skeleton_hash(vad, respine_token="decomp_run_2")
+    assert r1 != vad and r2 != vad and r1 != r2
+    assert r1 == compute_skeleton_hash(vad, respine_token="decomp_run_1")
+    rs = compute_skeleton_hash(vad, split_policy="pysbd-sentence-v2",
+                               split_min_chunk_s=0.5,
+                               seg_capability="cjm-capability-pysbd",
+                               seg_config_hash="seghash",
+                               respine_token="decomp_run_1")
+    assert rs not in (split, r1, vad)

cjm_transcript_decomp_core-0.0.4/cjm_transcript_decomp_core/__init__.py

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

cjm_transcript_decomp_core-0.0.4/tests/test_alignment.py

@@ -1,45 +0,0 @@
-"""Tests for cjm_transcript_decomp_core.alignment — pure forced-alignment logic.
-
-Projected from the alignment notebook's smoke-check cell at the golden-reference flip
-(pure logic; deterministic)."""
-from cjm_transcript_decomp_core.alignment import (
-    assign_words_to_chunks,
-    build_segments_from_alignment,
-    map_fa_words_to_text,
-    tier1_alignment_checks,
-)
-from cjm_transcript_decomp_core.models import FAWord, VADChunk
-
-TEXT = "Hello world. Foo bar."
-FA = [FAWord("hello", 0.0, 0.5), FAWord("world", 0.5, 1.0),
-      FAWord("foo", 2.0, 2.5), FAWord("bar", 2.5, 3.0)]
-CHUNKS = [VADChunk(0, 0.0, 1.2), VADChunk(1, 1.9, 3.1)]
-
-
-def test_map_fa_words_to_text_spans():
-    spans = map_fa_words_to_text(TEXT, FA)
-    assert len(spans) == 4
-    assert TEXT[spans[0][0]:spans[0][1]] == "Hello"
-    assert TEXT[spans[1][0]:spans[1][1]] == "world."
-
-
-def test_assign_words_to_chunks_by_timestamp():
-    assert assign_words_to_chunks(FA, CHUNKS) == [0, 0, 1, 1]
-
-
-def test_build_segments_per_chunk():
-    spans = map_fa_words_to_text(TEXT, FA)
-    assign = assign_words_to_chunks(FA, CHUNKS)
-    segs = build_segments_from_alignment(TEXT, spans, assign, num_chunks=2)
-    assert len(segs) == 2
-    assert segs[0].text == "Hello world."
-    assert segs[1].text == "Foo bar."
-    assert tier1_alignment_checks(segs, CHUNKS) == []
-
-
-def test_empty_chunk_yields_empty_segment_warning():
-    # empty-chunk case -> empty-segment warning
-    spans = map_fa_words_to_text(TEXT, FA)
-    segs2 = build_segments_from_alignment(TEXT, spans, [0, 0, 0, 0], num_chunks=2)
-    assert segs2[1].text == ""
-    assert any("EMPTY" in w for w in tier1_alignment_checks(segs2, CHUNKS))