cjm-transcript-decomp-core 0.0.1__py3-none-any.whl

cjm_transcript_decomp_core/__init__.py

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

cjm_transcript_decomp_core/alignment.py

@@ -0,0 +1,166 @@
+"""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 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)
+
+
+def _strip_punct(
+    text: str,  # Text to normalize
+) -> str:  # Text with punctuation removed
+    """Strip punctuation from text for comparison with FA output."""
+    return _PUNCT_RE.sub("", text)
+
+
+def map_fa_words_to_text(
+    text: str,             # Original text with punctuation
+    fa_items: List[FAWord],  # FA word-level alignment results
+) -> List[Tuple[int, int]]:  # (start_char, end_char) spans into the original text
+    """Map forced-alignment words back to character spans in the original text.
+
+    Walks the original text, matching each FA word (punctuation-stripped) against
+    original-text tokens; returns character offset pairs for each FA word.
+    """
+    spans = []
+    pos = 0  # Current position in original text
+
+    for item in fa_items:
+        fa_word = item.text.lower()
+
+        # Skip whitespace to find next token start
+        while pos < len(text) and text[pos].isspace():
+            pos += 1
+        if pos >= len(text):
+            break
+
+        # Find the end of the current token (run of non-space characters)
+        token_start = pos
+        token_end = pos
+        while token_end < len(text) and not text[token_end].isspace():
+            token_end += 1
+
+        orig_token = text[token_start:token_end]
+        stripped_token = _strip_punct(orig_token).lower()
+
+        if stripped_token == fa_word:
+            spans.append((token_start, token_end))
+            pos = token_end
+        else:
+            # Multi-token FA words (e.g. "p.m." -> "pm") or punctuation-split tokens:
+            # consume up to 3 extra tokens until the stripped concatenation matches.
+            concat = stripped_token
+            scan_end = token_end
+            matched = False
+            for _ in range(3):
+                if concat.lower() == fa_word:
+                    spans.append((token_start, scan_end))
+                    pos = scan_end
+                    matched = True
+                    break
+                while scan_end < len(text) and text[scan_end].isspace():
+                    scan_end += 1
+                if scan_end >= len(text):
+                    break
+                next_start = scan_end
+                while scan_end < len(text) and not text[scan_end].isspace():
+                    scan_end += 1
+                concat += _strip_punct(text[next_start:scan_end])
+
+            if not matched:
+                if concat.lower() == fa_word:
+                    spans.append((token_start, scan_end))
+                    pos = scan_end
+                else:
+                    # Fallback: take the single token and move on (handles
+                    # insertions/deletions between transcript and FA output).
+                    spans.append((token_start, token_end))
+                    pos = token_end
+
+    return spans
+
+
+def assign_words_to_chunks(
+    fa_items: List[FAWord],     # FA word-level alignment results
+    vad_chunks: List[VADChunk],  # VAD chunks with start/end times
+) -> 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.
+    """
+    if not vad_chunks:
+        return [0] * len(fa_items)
+
+    assignments = []
+    for item in fa_items:
+        t = item.start_time
+        best_idx = 0
+        best_dist = float("inf")
+        for i, chunk in enumerate(vad_chunks):
+            if chunk.start_time <= t <= chunk.end_time:
+                best_idx = i
+                break
+            dist = min(abs(t - chunk.start_time), abs(t - chunk.end_time))
+            if dist < best_dist:
+                best_dist = dist
+                best_idx = i
+        assignments.append(best_idx)
+    return assignments
+
+
+def build_segments_from_alignment(
+    text: str,                      # Original text with punctuation
+    spans: List[Tuple[int, int]],   # Character spans from map_fa_words_to_text
+    assignments: List[int],         # Chunk index per word from assign_words_to_chunks
+    num_chunks: int,                # Total number of VAD chunks
+    source_id: Optional[str] = None,           # Source row id for traceability
+    source_provider_id: Optional[str] = None,  # Source provider identifier
+) -> List[TextSegment]:  # One segment per VAD chunk
+    """Build a TextSegment per VAD chunk by grouping words by chunk assignment.
+
+    Each chunk's text is the original (punctuated) slice from the first to the
+    last word assigned to it; chunks with no words become empty segments.
+    """
+    chunk_spans: Dict[int, List[Tuple[int, int]]] = {}
+    for span, chunk_idx in zip(spans, assignments):
+        chunk_spans.setdefault(chunk_idx, []).append(span)
+
+    segments = []
+    for chunk_idx in range(num_chunks):
+        word_spans = chunk_spans.get(chunk_idx, [])
+        if word_spans:
+            seg_start = word_spans[0][0]
+            seg_end = word_spans[-1][1]
+            seg_text = text[seg_start:seg_end].strip()
+        else:
+            seg_text = ""
+            seg_start = None
+            seg_end = None
+        segments.append(TextSegment(
+            index=chunk_idx, text=seg_text,
+            source_id=source_id, source_provider_id=source_provider_id,
+            start_char=seg_start, end_char=seg_end,
+        ))
+    return segments
+
+
+def tier1_alignment_checks(
+    segments: List[TextSegment],  # Segments produced by build_segments_from_alignment
+    vad_chunks: List[VADChunk],   # The VAD chunks they were aligned to
+) -> List[str]:  # Human-readable warnings (empty = all clear)
+    """Tier-1 deterministic pre-filters for the alignment-review seam (no AI)."""
+    warnings: List[str] = []
+    if len(segments) != len(vad_chunks):
+        warnings.append(
+            f"segment/chunk count mismatch: {len(segments)} vs {len(vad_chunks)}"
+        )
+    empty = sum(1 for s in segments if not s.text.strip())
+    if empty:
+        warnings.append(
+            f"{empty}/{len(segments)} segment(s) have EMPTY text (VAD chunk with no aligned words)"
+        )
+    return warnings

cjm_transcript_decomp_core/cli.py

@@ -0,0 +1,155 @@
+"""The CLI driver — the decomposition core's first (and currently only) frontend.
+
+Ships in-package as the `cjm-transcript-decomp-core` console script so the driver
+can never skew from the core. GUI presentation drivers come later and consume the
+same `pipeline` module; they never reimplement it (CLI-first / headless-core
+principle).
+
+Prerequisite runtime (once, from the repo root):
+
+    cjm-ctl --cjm-config cjm.yaml setup-runtime
+    cjm-ctl --cjm-config cjm.yaml install-all --capabilities capabilities_test.yaml --force
+
+Then decompose a transcription-core run manifest:
+
+    cjm-transcript-decomp-core run path/to/transcription-run.json --yes
+    # GPU runs: opt into CR-7 GPU subtree attribution
+    cjm-transcript-decomp-core run run.json --yes --sysmon-capability cjm-capability-monitor-nvidia
+"""
+
+import argparse
+import asyncio
+import getpass
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from cjm_substrate.core.manager import CapabilityManager
+from cjm_substrate.core.queue import JobQueue
+from cjm_transcript_decomp_core.models import DecompConfig
+from cjm_transcript_decomp_core.pipeline import load_source_manifest, run_decomp
+
+logger = logging.getLogger(__name__)
+
+
+def build_parser() -> argparse.ArgumentParser:  # Configured CLI parser
+    """Build the CLI parser (subcommands: run)."""
+    parser = argparse.ArgumentParser(
+        prog="cjm-transcript-decomp-core",
+        description="Headless transcript decomposition: VAD + forced alignment -> fine-spine graph extension.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    run = sub.add_parser("run", help="Extend a transcription-emitted graph root with the fine spine")
+    run.add_argument("manifest", help="Transcription-core run manifest JSON (the source to decompose)")
+    run.add_argument("--manifests-dir", default=".cjm/manifests", help="Capability manifests directory")
+    run.add_argument("--vad-capability", default="cjm-capability-silero-vad", help="VAD capability name")
+    run.add_argument("--fa-capability", default="cjm-capability-qwen3-forced-aligner", help="Forced-alignment capability name")
+    run.add_argument("--graph-capability", default="cjm-capability-graph-sqlite", help="Graph-storage capability name")
+    run.add_argument("--graph-db-path", default=None,
+                     help="Explicit graph DB path override (F10; scratch-graph loop-backs; default: the capability's configured db_path)")
+    run.add_argument("--text-from", default=None,
+                     help="Authoritative transcriber for layer-0 text (the ACCURACY model; "
+                          "required when the manifest carries multiple transcribers; "
+                          "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("--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 (default: runs/<run_id>.json)")
+    run.add_argument("--actor", default=None,
+                     help="Journal attribution for who/what initiated this run (default: cli:<username>)")
+    run.add_argument("-v", "--verbose", action="store_true", help="DEBUG-level logging")
+    return parser
+
+
+def load_capabilities(
+    manager: CapabilityManager,   # Freshly constructed manager
+    instance_ids: List[str],  # Capability names to load (default instances), in order
+    configs: Optional[Dict[str, Dict[str, Any]]] = None,  # Per-capability config overrides (caller-wins, C8)
+) -> None:
+    """Discover manifests + load each requested capability (default instance)."""
+    manager.discover_manifests()
+    discovered = {m.name: m for m in manager.discovered}
+    for iid in instance_ids:
+        meta = discovered.get(iid)
+        if meta is None:
+            raise SystemExit(
+                f"capability {iid!r} not found in manifests "
+                f"(discovered: {sorted(discovered)}) — run cjm-ctl install-all first"
+            )
+        if not manager.load_capability(meta, config=(configs or {}).get(iid)):
+            raise SystemExit(f"failed to load capability {iid!r}")
+        logger.info(f"loaded {iid}")
+
+
+async def run_command(
+    args: argparse.Namespace,  # Parsed CLI arguments for the `run` subcommand
+) -> int:  # Process exit code (0 = all sources extended + verified)
+    """Execute the `run` subcommand: extend a transcription-emitted root with the fine spine."""
+    manifest_path = str(Path(args.manifest).resolve())
+    if not Path(manifest_path).exists():
+        raise SystemExit(f"source manifest not found: {manifest_path}")
+
+    cfg = DecompConfig(
+        vad_capability=args.vad_capability,
+        fa_capability=args.fa_capability,
+        graph_capability=args.graph_capability,
+        text_from=args.text_from,
+        language=args.language,
+        force=args.force,
+        assume_yes=args.yes,
+    )
+
+    # CR-7 GPU subtree attribution is opt-in: --sysmon-capability threads the monitor
+    # name into BOTH the manager and the queue; the monitor loads FIRST so GPU
+    # capabilities' samples record gpu_memory_mb_peak (voxtral-vllm e2e pattern).
+    manager = CapabilityManager(
+        search_paths=[Path(args.manifests_dir)],
+        sysmon_capability_name=args.sysmon_capability,
+    )
+    instance_ids = [cfg.vad_capability, cfg.fa_capability, cfg.graph_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)
+
+    queue = JobQueue(deps=manager, sysmon_capability_name=args.sysmon_capability)
+    await queue.start()
+    try:
+        # CR-14 follow-up: actor attribution (operator identity by default;
+        # agents/services pass --actor explicitly).
+        actor = args.actor or f"cli:{getpass.getuser()}"
+        manifest = await run_decomp(manager, queue, cfg, manifest_path, actor=actor)
+    finally:
+        await queue.stop()
+        for iid in reversed(load_order):  # Reverse load order; the monitor unloads last
+            try:
+                manager.unload_capability(iid)
+            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)
+    n_manifest_sources = len(load_source_manifest(manifest_path).get("sources", []) or [])
+    n_sources = len(manifest.sources)
+    n_segs = sum(s.segment_count for s in manifest.sources)
+    print(f"decomp manifest: {out}")
+    print(f"sources extended: {n_sources}/{n_manifest_sources}  segment nodes: {n_segs}")
+    return 0 if n_sources == n_manifest_sources else 1
+
+
+def main(
+    argv: Optional[List[str]] = None,  # Argument list override (None = sys.argv)
+) -> int:  # Process exit code
+    """CLI entry point (console script: `cjm-transcript-decomp-core`)."""
+    args = build_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s :: %(message)s",
+    )
+    if args.command == "run":
+        return asyncio.run(run_command(args))
+    raise SystemExit(f"unknown command: {args.command}")

cjm_transcript_decomp_core/graph.py

@@ -0,0 +1,245 @@
+"""Graph-spine EXTENSION + skeptical-lens verification (stage 5, CR-18 revolution 2). Decomp no longer creates a Document: it RECOMPUTES the transcription-emitted root's deterministic node ids from the consumed manifest (no search), verifies the root exists, and attaches the fine Segment spine under the existing AudioSegment nodes — PART_OF to the owning rendition, STARTS_WITH per rendition (the coarse-seam jump anchor), source-wide NEXT. Each Segment carries the audio TimeSlice ref plus per-transcriber CharSlice refs into the Transcript nodes (the D4/P10 framing, finally expressible). Commit goes through the layer's idempotent extend_graph."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+from cjm_context_graph_layer.grammar import grouped_spine_edges, SpineRelations
+from cjm_context_graph_layer.ops import graph_task
+from cjm_context_graph_primitives.graph import GraphNode
+from cjm_context_graph_primitives.provenance import SourceRef
+from cjm_context_graph_primitives.query import (EdgeQuery, EdgeQueryResult, NodeQuery,
+                                                NodeQueryResult, OrderBy, PropertyPredicate,
+                                                RelationPredicate)
+from cjm_substrate.core.queue import JobQueue
+from cjm_transcript_decomp_core.models import DecompSegment
+from cjm_transcript_graph_schema.schema import (audio_rendition_node_id, audio_segment_node_id,
+                                                SegmentNode, source_node_id, transcript_node_id,
+                                                TranscriptGraphLabels, TranscriptSliceRef)
+
+# Stage 4: typed query expressions + results — importing the result classes IS
+# the host-side wire registration (F8); the tuple keeps these SIDE-EFFECT
+# imports referenced so the canonical emit cannot prune them. Stage 5: the
+# graph-aware layer owns the shared plumbing (graph_task is THE shared copy
+# now) and the fractal spine grammar; the audio-transcript schema owns the
+# node nouns + deterministic identity tuples. cjm_graph_domains is GONE
+# (Document dissolved).
+_REGISTERED_WIRE_KINDS = (NodeQueryResult, EdgeQueryResult)
+
+
+def resolve_root_ids(
+    source_entry: Dict[str, Any],            # One source entry from the transcription manifest (0.3.0)
+    capabilities_info: Dict[str, Dict[str, Any]], # The transcription manifest's capabilities block (config hashes)
+) -> Dict[str, Any]:  # {"source", "chain", "audio_segments": [{audio_segment, rendition, start, end, model_input_hash, transcripts}]}
+    """Recompute the transcription-emitted root node ids from manifest data.
+
+    Deterministic identity makes the extender lookup a RECOMPUTATION, not a
+    search: Source = content hash; AudioSegment = (source, boundary range);
+    AudioRendition = (audio segment, preprocessing chain) — the per-source
+    `chain` ([] = raw convert-only) carried by the 0.3.0 manifest; Transcript =
+    (rendition, transcriber, config_hash). No stored-id coupling between the
+    cores. A pre-0.3.0 manifest (no `chain`) recomputes the raw rendition ids
+    (empty chain), which is correct for any non-preprocessed run.
+    """
+    content_hash = str(source_entry.get("content_hash") or "")
+    if not content_hash:
+        raise ValueError(
+            f"source {source_entry.get('source_path')!r} has no content_hash — "
+            "re-run transcription on the 0.3.0 manifest schema")
+    source_id = source_node_id(content_hash)
+    chain = list(source_entry.get("chain") or [])  # [] = raw convert-only rendition
+    asegs: List[Dict[str, Any]] = []
+    for pseg in source_entry.get("segments") or []:
+        start, end = float(pseg.get("start", 0.0)), float(pseg.get("end", 0.0))
+        aseg_id = audio_segment_node_id(source_id, start, end)
+        rendition_id = audio_rendition_node_id(aseg_id, chain)
+        transcripts = {
+            t: transcript_node_id(rendition_id, t, str((capabilities_info.get(t) or {}).get("config_hash") or ""))
+            for t in (pseg.get("transcripts") or {})
+        }
+        asegs.append({"audio_segment": aseg_id, "rendition": rendition_id,
+                      "start": start, "end": end,
+                      "model_input_hash": str(pseg.get("model_input_hash") or ""),
+                      "transcripts": transcripts})
+    return {"source": source_id, "chain": chain, "audio_segments": asegs}
+
+
+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)
+    text_from: str,                           # Authoritative transcriber (layer-0 text designation)
+    segments: List[DecompSegment],            # Ordered aligned segments (per-transcriber variants attached)
+) -> 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).
+
+    Segment identity is audio-side (audio RENDITION, VAD config, chunk range) —
+    shared across transcribers by construction, distinct per rendition (vocals
+    isolation can yield different VAD chunking than raw). Each Segment carries
+    the audio `TimeSlice` ref into its rendition + one `CharSlice` ref per
+    transcriber variant; `text_from` is recorded per segment as provenance
+    (which Transcript the layer-0 text came from), never as global config. Edges
+    come from `grouped_spine_edges`: PART_OF to the OWNING AudioRendition,
+    STARTS_WITH per rendition, NEXT chained source-wide across coarse boundaries.
+    """
+    roots = resolve_root_ids(source_entry, capabilities_info)
+    source_id = roots["source"]
+    asegs = roots["audio_segments"]
+
+    nodes: List[Dict[str, Any]] = []
+    seg_ids: List[str] = []
+    groups: Dict[int, List[str]] = {}
+    used_transcripts: set = set()
+    for seg in segments:
+        a = asegs[seg.pseg_index]
+        slices: List[TranscriptSliceRef] = []
+        for var in seg.variants:
+            tid = a["transcripts"].get(var.transcriber)
+            if tid is None or not var.text or var.start_char is None or var.end_char is None:
+                continue
+            slices.append(TranscriptSliceRef(transcript=tid, start_char=var.start_char,
+                                             end_char=var.end_char, text=var.text))
+            used_transcripts.add(tid)
+        node = SegmentNode(
+            rendition=a["rendition"], vad_config_hash=vad_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,
+        )
+        nodes.append(node.to_graph_node())
+        seg_ids.append(node.id)
+        groups.setdefault(seg.pseg_index, []).append(node.id)
+
+    # The fine spine hangs under each segment's RENDITION (PART_OF rendition).
+    edges = grouped_spine_edges([(asegs[i]["rendition"], groups[i]) for i in sorted(groups)])
+    ids = {"source": source_id, "segments": seg_ids,
+           "audio_segments": [a["audio_segment"] for a in asegs],
+           "renditions": [a["rendition"] for a in asegs],
+           "transcripts_used": sorted(used_transcripts)}
+    return nodes, edges, ids
+
+
+@dataclass
+class SourceVerification:
+    """Skeptical-lens verification of one Source's fine-spine extension under a
+    specific rendition set, computed by querying the graph directly (never
+    trusting run state)."""
+    source_id: str             # Verified Source node id
+    title: str                 # Source title (read back from the graph)
+    audio_segment_count: int   # AudioSegment nodes found under the Source (coarse spine; rendition-independent)
+    rendition_count: int       # AudioRendition nodes the fine spine was scoped to (the run's extended renditions)
+    segment_count: int         # Fine Segment nodes found under those renditions
+    source_starts_with: bool   # Exactly 1 STARTS_WITH Source -> first AudioSegment
+    aseg_next_complete: bool   # Coarse NEXT count == audio_segment_count - 1
+    seg_next_complete: bool    # Fine NEXT count == segment_count - 1 (source-wide chain)
+    part_of_complete: bool     # Fine PART_OF count == segment_count (Segment -> rendition)
+    rendition_starts_with_complete: bool  # STARTS_WITH from renditions == #renditions owning >=1 Segment
+    all_have_timing: bool      # Every Segment has start_time + end_time
+    all_have_sources: bool     # Every Segment has >=1 SourceRef (the audio ref at minimum)
+    source_locators: List[str] = field(default_factory=list)  # Distinct provenance locator URIs
+
+    @property
+    def ok(self) -> bool:  # True when every structural check passes
+        """All structural checks pass."""
+        return (self.source_starts_with and self.aseg_next_complete
+                and self.seg_next_complete and self.part_of_complete
+                and self.rendition_starts_with_complete and self.all_have_timing
+                and self.all_have_sources)
+
+
+async def verify_source(
+    queue: JobQueue,          # Started job queue
+    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)
+) -> Optional[SourceVerification]:  # Result, or None if the Source is not found
+    """Verify a Source's committed extension via server-side AGGREGATES (D13/D19).
+
+    Two-layer verification for the Source-rooted schema: the coarse spine
+    (Source → AudioSegments) is checked with id-list edge counts (rendition-
+    independent); the fine spine hangs under the run's AudioRendition set, so it
+    is scoped through the batched far-end constraint
+    `RelationPredicate("PART_OF", node_ids=rendition_ids)` (the C17 batch shape) —
+    never a whole-neighborhood materialization, and never mixing a sibling
+    rendition's spine (raw vs vocals coexist under the same AudioSegments). One
+    bounded projection pass (sources + rendition_id) yields missing-sources,
+    distinct locators, AND the per-rendition ownership set for the STARTS_WITH
+    check.
+    """
+    src = await graph_task(queue, graph_id, "get_node", node_id=source_id)
+    if src is None:
+        return None
+    props = src.properties if isinstance(src, GraphNode) else ((src or {}).get("properties") or {})
+
+    async def _ecount(**kw):
+        q = EdgeQuery(count=True, **kw)
+        res = await graph_task(queue, graph_id, "query_edges", query=q.to_dict())
+        return int(res.count or 0)
+
+    # Coarse layer: ordered AudioSegment ids under the Source (rendition-independent).
+    aq = NodeQuery(label=TranscriptGraphLabels.AUDIO_SEGMENT,
+                   related=RelationPredicate(SpineRelations.PART_OF, node_id=source_id),
+                   order_by=OrderBy("index"), project=["index"])
+    ares = await graph_task(queue, graph_id, "query_nodes", query=aq.to_dict())
+    aseg_ids = [r["id"] for r in (ares.rows or [])]
+    n_asegs = len(aseg_ids)
+    rendition_ids = list(rendition_ids or [])
+    if not aseg_ids or not rendition_ids:
+        return SourceVerification(
+            source_id=source_id, title=props.get("title", "Untitled"),
+            audio_segment_count=n_asegs, rendition_count=len(rendition_ids),
+            segment_count=0, source_starts_with=False,
+            aseg_next_complete=False, seg_next_complete=False, part_of_complete=False,
+            rendition_starts_with_complete=False, all_have_timing=False, all_have_sources=False)
+
+    src_starts = await _ecount(relation_type=SpineRelations.STARTS_WITH, source_id=source_id)
+    aseg_next = await _ecount(relation_type=SpineRelations.NEXT, source_ids=aseg_ids)
+
+    # Fine layer, scoped via the batched far-end constraint onto THIS run's renditions.
+    part_of_rend = RelationPredicate(SpineRelations.PART_OF, node_ids=rendition_ids)
+
+    async def _ncount(**kw):
+        q = NodeQuery(label=TranscriptGraphLabels.SEGMENT, related=part_of_rend, count=True, **kw)
+        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())
+    missing_sources = 0
+    locators = set()
+    owning_renditions = set()
+    for r in (res.rows or []):
+        sources = r.get("sources") or []
+        if not sources:
+            missing_sources += 1
+        for s in sources:
+            ref = SourceRef.from_dict(s) if isinstance(s, dict) else s
+            locators.add(ref.locator.to_uri())
+        if r.get("rendition_id"):
+            owning_renditions.add(r["rendition_id"])
+
+    return SourceVerification(
+        source_id=source_id,
+        title=props.get("title", "Untitled"),
+        audio_segment_count=n_asegs,
+        rendition_count=len(rendition_ids),
+        segment_count=n_segs,
+        source_starts_with=src_starts == 1,
+        aseg_next_complete=aseg_next == max(0, n_asegs - 1),
+        seg_next_complete=seg_next == max(0, n_segs - 1),
+        part_of_complete=seg_part_of == n_segs,
+        rendition_starts_with_complete=rend_starts == len(owning_renditions),
+        all_have_timing=(missing_start == 0 and missing_end == 0),
+        all_have_sources=missing_sources == 0,
+        source_locators=sorted(locators),
+    )