cjm-transcript-decomp-core 0.0.6__tar.gz → 0.0.9__tar.gz

{cjm_transcript_decomp_core-0.0.6/cjm_transcript_decomp_core.egg-info → cjm_transcript_decomp_core-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-decomp-core
-Version: 0.0.6
+Version: 0.0.9
 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
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cjm_substrate>=0.0.61
+Requires-Dist: cjm_substrate>=0.0.63
 Requires-Dist: pyyaml
 Requires-Dist: cjm_context_graph_primitives>=0.0.15
 Requires-Dist: cjm_capability_primitives>=0.0.11
@@ -102,6 +102,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `event_spans_from_propset` _function_ — Load a proposal set BY POINTER and select its carve spans (respine trial
 - `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.
+- `resolve_event_propsets` _function_ — Join each proposal set to ITS source by the set manifest's own source
 - `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).

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/README.md

@@ -82,6 +82,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `event_spans_from_propset` _function_ — Load a proposal set BY POINTER and select its carve spans (respine trial
 - `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.
+- `resolve_event_propsets` _function_ — Join each proposal set to ITS source by the set manifest's own source
 - `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).

cjm_transcript_decomp_core-0.0.9/cjm_transcript_decomp_core/__init__.py

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

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core/cli.py

@@ -78,9 +78,12 @@ def build_parser() -> argparse.ArgumentParser:  # Configured CLI parser
                      help="Run the post-FA event-carve stage (respine trial DEC 6cc10fb7): model "
                           "event spans from --event-propset become gaps between chunks "
                           "(cut-don't-label); typically paired with --no-sentence-split")
-    run.add_argument("--event-propset", default=None,
-                     help="ProposalSetManifest pointer (manifest json or its set dir); "
-                          "REQUIRED with --event-split")
+    run.add_argument("--event-propset", nargs="+", default=None, metavar="POINTER",
+                     help="ProposalSetManifest pointer(s) (manifest json or its set dir); "
+                          "REQUIRED with --event-split. ONE per source: each set carves "
+                          "the source its own manifest names (content hash, else path) — "
+                          "a multi-source run takes one pointer per source, any order; "
+                          "an uncovered source or a stray pointer refuses loudly")
     run.add_argument("--event-classes", nargs="+", default=["inhale"],
                      help="Proposal classes that carve (default: inhale; word-bearing "
                           "classes must never cut)")
@@ -168,12 +171,16 @@ async def run_command(
         seg_capability=args.seg_capability,
         respine=args.respine,
         event_split=args.event_split,
-        event_propset=(args.event_propset or ""),
+        # One pointer per source (0.2.6): the single form stays the config
+        # snapshot's `event_propset` so 0.2.5 consumers read it unchanged.
+        event_propset=(args.event_propset[0] if args.event_propset
+                       and len(args.event_propset) == 1 else ""),
+        event_propsets=list(args.event_propset or []),
         event_classes=list(args.event_classes),
         word_rescue=args.word_rescue,
     )
-    if cfg.event_split and not cfg.event_propset:
-        raise SystemExit("error: --event-split requires --event-propset")
+    if cfg.event_split and not cfg.event_propsets:
+        raise SystemExit("error: --event-split requires --event-propset (one per source)")
 
     # 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

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core/launch.py

@@ -158,8 +158,12 @@ def batch_argv(
         # classes render explicitly — the printed argv is the full contract.
         # The GROUP's resolved propset wins (per-source picker, DEC ae450551);
         # the CLI flag is the scripted path's pin.
+        # A group's propset is ONE pointer per source (0.2.6): a str for a
+        # single-source group, a list/tuple for a multi-source run.
+        ps = batch.get("event_propset") or args.event_propset
+        pointers = [ps] if isinstance(ps, str) else list(ps or [])
         argv += ["--event-split",
-                 "--event-propset", batch.get("event_propset") or args.event_propset,
+                 "--event-propset", *pointers,
                  "--event-classes", *args.event_classes]
     if args.actor:
         argv += ["--actor", args.actor]

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core/models.py

@@ -122,7 +122,8 @@ class DecompConfig:
     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)
     event_split: bool = False       # Run the post-FA event-carve stage (respine trial DEC 6cc10fb7): model event spans from `event_propset` become gaps between chunks (cut-don't-label); composable with sentence_split, but the trial runs it INSTEAD
-    event_propset: str = ""         # ProposalSetManifest pointer (manifest json or its set dir) — the model-cut authority consumed BY POINTER; REQUIRED when event_split
+    event_propset: str = ""         # ProposalSetManifest pointer (manifest json or its set dir) — the model-cut authority consumed BY POINTER; the SINGLE-source form (kept for config-snapshot compatibility; REQUIRED when event_split and event_propsets is empty)
+    event_propsets: List[str] = field(default_factory=list)  # Per-source ProposalSetManifest pointers (0.2.6, multi-source runs): each set joins ITS source by the manifest's own source binding (content hash, else path) — resolve_event_propsets refuses an uncovered source or a stray pointer loudly
     event_classes: List[str] = field(default_factory=lambda: ["inhale"])  # Proposal classes that carve (word-bearing classes like hesitation-marker must never cut)
     word_rescue: bool = True        # Run the post-carve word-rescue stage (96edc646 verdict bc7ece7b): authoritative FA words stranded outside every chunk get chunks minted — DEFAULT-ON (mis-homing is silent data corruption; opting out hides it)
 
@@ -141,6 +142,9 @@ class DecompSourceRecord:
     title: str           # Source display title
     segment_count: int   # Number of fine Segment nodes committed
     segment_ids: List[str] = field(default_factory=list)  # Graph Segment node ids, in order
+    skeleton_config_hash: str = ""  # THIS source's Segment identity input (0.2.6): equals the run-level value unless the event stage carved per source
+    event_propset_id: str = ""      # The ProposalSetManifest THIS source's carve consumed (0.2.6; per-source propset -> skeleton chain join key)
+    event_propset: str = ""         # Recorded pointer of that set (0.2.6)
 
     def to_dict(self) -> Dict[str, Any]:  # Plain-dict form
         """Serialize to a plain dict."""
@@ -169,7 +173,7 @@ class DecompManifest:
     event_propset: str = ""             # Recorded path of the consumed ProposalSetManifest (0.2.4; the pointer)
 
     FORMAT: str = field(default="cjm-transcript-decomp-core/run-manifest", repr=False)  # Format tag
-    VERSION: str = field(default="0.2.5", repr=False)                                   # Schema version (0.2.5: word-rescue policy recorded; 0.2.4: event-carve respine — propset pointer + id + event policy recorded; 0.2.3: capability-driven sentence split)
+    VERSION: str = field(default="0.2.6", repr=False)                                   # Schema version (0.2.6: per-source skeleton hash + consumed propset on each source record — multi-source event carve; the run-level fields hold the value only when every source shares it; 0.2.5: word-rescue policy recorded; 0.2.4: event-carve respine — propset pointer + id + event policy recorded; 0.2.3: capability-driven sentence split)
 
     def to_dict(self) -> Dict[str, Any]:  # Plain-dict form for JSON serialization
         """Serialize to a plain dict with nested sources."""

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core/pipeline.py

@@ -481,27 +481,47 @@ async def run_decomp(
     # (the set IS the cut authority) and the pointer + id land in the manifest
     # (propset -> skeleton chain, DEC 16159e09 manifest-kinds-chainable).
     event_policy = EVENT_SPLIT_POLICY if cfg.event_split else None
-    event_spans: Optional[List[Tuple[float, float]]] = None
+    # Per-source carve authority (manifest 0.2.6): every source resolves ITS
+    # set by the set manifest's own source binding (resolve_event_propsets —
+    # the single-pointer config form is the one-element list), and each
+    # source's set id joins THAT source's skeleton identity. The run-level
+    # fields hold a value only when every source shares it, so single-source
+    # runs are byte-identical to 0.2.5 and multi-source runs never pretend
+    # one authority carved them all.
+    run_sources = src.get("sources", []) or []
+    per_source_propsets: List[Tuple[Dict[str, Any], List[Tuple[float, float]], str]] = []
     if cfg.event_split:
-        if not cfg.event_propset:
+        pointers = list(cfg.event_propsets) or ([cfg.event_propset] if cfg.event_propset else [])
+        if not pointers:
             raise RuntimeError("event_split requires event_propset (the ProposalSetManifest pointer)")
-        propset_manifest, event_spans = event_spans_from_propset(cfg.event_propset, cfg.event_classes)
-        manifest.event_propset_id = str(propset_manifest.get("proposal_set_id") or "")
-        manifest.event_propset = str(cfg.event_propset)
-        logger.info(f"run {run_id}: event-carve consuming {manifest.event_propset_id} "
-                    f"({len(event_spans)} span(s) across classes {cfg.event_classes})")
+        per_source_propsets = resolve_event_propsets(pointers, run_sources, cfg.event_classes)
+        set_ids = sorted({str(m.get("proposal_set_id") or "") for m, _, _ in per_source_propsets})
+        manifest.event_propset_id = set_ids[0] if len(set_ids) == 1 else ""
+        manifest.event_propset = per_source_propsets[0][2] if len(set_ids) == 1 else ""
+        for i, (m, spans, _ptr) in enumerate(per_source_propsets):
+            logger.info(f"run {run_id}: event-carve source {i} consuming "
+                        f"{m.get('proposal_set_id')} ({len(spans)} span(s) across "
+                        f"classes {cfg.event_classes})")
     word_rescue_policy = WORD_RESCUE_POLICY if cfg.word_rescue else None
-    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,
-        event_policy=event_policy,
-        event_propset_id=(manifest.event_propset_id if cfg.event_split else ""),
-        event_classes=(cfg.event_classes if cfg.event_split else None),
-        text_from_capability=str(text_from or ""),
-        text_from_config_hash=str((src_capabilities.get(text_from) or {}).get("config_hash") or ""),
-        word_rescue_policy=word_rescue_policy)
+
+    def _skeleton_hash(event_propset_id: str) -> str:
+        return 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,
+            event_policy=event_policy,
+            event_propset_id=(event_propset_id if cfg.event_split else ""),
+            event_classes=(cfg.event_classes if cfg.event_split else None),
+            text_from_capability=str(text_from or ""),
+            text_from_config_hash=str((src_capabilities.get(text_from) or {}).get("config_hash") or ""),
+            word_rescue_policy=word_rescue_policy)
+    source_skeletons = ([_skeleton_hash(str(m.get("proposal_set_id") or ""))
+                         for m, _, _ in per_source_propsets] if cfg.event_split
+                        else [_skeleton_hash("")] * len(run_sources))
+    distinct_skeletons = sorted(set(source_skeletons))
+    skeleton_config_hash = (distinct_skeletons[0] if len(distinct_skeletons) == 1
+                            else "" if distinct_skeletons else _skeleton_hash(""))
     manifest.skeleton_config_hash = skeleton_config_hash
     manifest.split_policy = split_policy
     manifest.event_split_policy = event_policy
@@ -526,7 +546,7 @@ async def run_decomp(
 
             source_path, aligned = await decompose_source(
                 queue, cfg, source, i, transcribers, text_from,
-                event_spans=event_spans)
+                event_spans=(per_source_propsets[i][1] if cfg.event_split else None))
             title = Path(source_path).stem or f"source-{i}"
 
             empty = sum(1 for a in aligned if not a.text.strip())
@@ -543,7 +563,7 @@ async def run_decomp(
             policy_label = "+".join(
                 p for p in (split_policy, event_policy, word_rescue_policy) if p) or None
             nodes, edges, ids = build_extension_payload(
-                source, src_capabilities, skeleton_config_hash, text_from, aligned,
+                source, src_capabilities, source_skeletons[i], text_from, aligned,
                 split_policy=policy_label)
 
             if not confirm_seam("commit-review",
@@ -605,7 +625,11 @@ async def run_decomp(
 
             manifest.sources.append(DecompSourceRecord(
                 source_node_id=ids["source"], source_path=source_path, title=title,
-                segment_count=len(ids["segments"]), segment_ids=ids["segments"]))
+                segment_count=len(ids["segments"]), segment_ids=ids["segments"],
+                skeleton_config_hash=source_skeletons[i],
+                event_propset_id=(str(per_source_propsets[i][0].get("proposal_set_id") or "")
+                                  if cfg.event_split else ""),
+                event_propset=(per_source_propsets[i][2] if cfg.event_split else "")))
     except BaseException as e:
         # The journal exists for exactly this row: a run that DIED records
         # how far it got (failures stop being the unattributed case).
@@ -749,3 +773,47 @@ def event_spans_from_propset(
             spans.append((s, e))
     spans.sort()
     return manifest, spans
+
+
+def resolve_event_propsets(
+    pointers: List[Union[str, Path]],  # ProposalSetManifest pointers (manifest json or set dir), any order
+    sources: List[Dict[str, Any]],     # The transcription run's sources, manifest order
+    classes: List[str],                # Proposal classes that carve
+) -> List[Tuple[Dict[str, Any], List[Tuple[float, float]], str]]:  # Per source, manifest order: (set manifest, carve spans, the pointer as given)
+    """Join each proposal set to ITS source by the set manifest's own source
+    binding (multi-source event carve, manifest 0.2.6): a set matches a run
+    source when its source.content_hash equals the source's content_hash,
+    else when its source.path equals the source's source_path. One set
+    carves ONE source, so every refusal is LOUD: a source no pointer covers
+    (propose over it first), a pointer claiming none of the run's sources
+    (a wrong pick), two pointers claiming one source (ambiguous authority).
+    A lone pointer over a lone source with NEITHER key matching is refused
+    too — that is exactly the silent-wrong-spans class the batch guard
+    existed for (a set whose manifest names a different media file)."""
+    loaded = [(str(p),) + event_spans_from_propset(p, classes) for p in pointers]
+    out: List[Tuple[Dict[str, Any], List[Tuple[float, float]], str]] = []
+    claimed: Dict[str, int] = {}
+    for i, src in enumerate(sources):
+        h = str(src.get("content_hash") or "")
+        path = str(src.get("source_path") or "")
+        hits = [(ptr, m, spans) for ptr, m, spans in loaded
+                if (h and str((m.get("source") or {}).get("content_hash") or "") == h)
+                or (path and str((m.get("source") or {}).get("path") or "") == path)]
+        name = Path(path).name if path else (h or f"source-{i}")
+        if not hits:
+            raise RuntimeError(
+                f"event-split: no proposal set covers source {i} ({name}) — "
+                f"propose over it first (pointers given: {[p for p, _, _ in loaded]})")
+        if len(hits) > 1:
+            raise RuntimeError(
+                f"event-split: {len(hits)} proposal sets claim source {i} ({name}): "
+                f"{[p for p, _, _ in hits]} — pass exactly one set per source")
+        ptr, m, spans = hits[0]
+        claimed[ptr] = i
+        out.append((m, spans, ptr))
+    stray = [ptr for ptr, _, _ in loaded if ptr not in claimed]
+    if stray:
+        raise RuntimeError(
+            f"event-split: proposal set(s) {stray} bind to none of this run's "
+            f"{len(sources)} source(s) — a set carves only the source its manifest names")
+    return out

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core/runs.py

@@ -9,10 +9,12 @@ tag — the manifest-as-interchange contract (CR-20) — is what separates
 transcription runs from decomp runs living in one directory."""
 
 import json
+import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from cjm_substrate.core.workspace import resolve_recorded_tree
+from cjm_substrate.utils.lifecycle import partition_lifecycle
 
 
 def _load_manifests(
@@ -186,7 +188,8 @@ class PropsetIndex:
 
     def __init__(self, proposals_dir: str = "proposals"):  # Workspace proposals/ (else cwd-relative)
         self.proposals_dir = Path(proposals_dir)
-        self.sets: List[Dict[str, Any]] = []  # Manifest dicts, newest first (+ "_path")
+        self.sets: List[Dict[str, Any]] = []  # ACTIVE manifest dicts, newest first (+ "_path", "_lifecycle")
+        self.archived: List[Dict[str, Any]] = []  # Archived sets (lifecycle sidecar, b20cb911) — off every ring, still on disk
 
     def load(self) -> int:  # Number of proposal sets loaded
         """(Re)read every readable proposal-set manifest, newest first (the
@@ -206,8 +209,11 @@ class PropsetIndex:
             m["_path"] = str(f)
             rows.append(m)
         rows.sort(key=lambda m: float(m.get("created_at") or 0.0), reverse=True)
-        self.sets = rows
-        return len(rows)
+        # Lifecycle (b20cb911, DEC 14678fc9): an archived set leaves every
+        # ring and default (for_source reads `sets`) but stays on disk under
+        # `archived` — the sidecar seam in cjm_substrate.utils.lifecycle.
+        self.sets, self.archived = partition_lifecycle(rows)
+        return len(self.sets)
 
     def for_source(
         self,
@@ -251,7 +257,8 @@ class TrainingRunIndex:
 
     def __init__(self, training_runs_dir: str = "training-runs"):  # Workspace training-runs/ (else cwd-relative)
         self.training_runs_dir = Path(training_runs_dir)
-        self.runs: List[Dict[str, Any]] = []  # Manifest dicts, newest first (+ "_path")
+        self.runs: List[Dict[str, Any]] = []  # ACTIVE manifest dicts, newest first (+ "_path", "_lifecycle")
+        self.archived: List[Dict[str, Any]] = []  # Archived runs (lifecycle sidecar, b20cb911) — off the ladder, shown on demand
 
     def load(self) -> int:  # Number of training runs loaded
         """(Re)read every readable training-run manifest, newest first (run
@@ -271,8 +278,11 @@ class TrainingRunIndex:
             m["_path"] = str(f)
             rows.append(m)
         rows.sort(key=lambda m: str(m.get("run_id") or ""), reverse=True)
-        self.runs = rows
-        return len(rows)
+        # Lifecycle (b20cb911, DEC 14678fc9): an archived run leaves the
+        # ladder and the picker's default list but stays on disk under
+        # `archived` — the m picker's h toggle lists it dimmed, a/x act on it.
+        self.runs, self.archived = partition_lifecycle(rows)
+        return len(self.runs)
 
     def resolve(
         self,
@@ -294,3 +304,87 @@ class TrainingRunIndex:
         """Footer text for the two-step confirm: run id tail + trained classes."""
         classes = ",".join(m.get("classes") or []) or "?"
         return f"{str(m.get('run_id') or '?')[-8:]} [{classes}]"
+
+    def resolve_pick(
+        self,
+        pick: Optional[str] = None,  # In-session picker choice: a run's _path or run id (tail ok)
+        pin: Optional[str] = None,   # Workspace-marker pin (the standing default)
+    ) -> Tuple[Optional[Dict[str, Any]], str]:  # (run or None, the reason the confirm names)
+        """The propose-model ladder (work item a13ebc66): PICK > PIN > NEWEST.
+        A picker choice made in this sitting outranks the workspace marker's
+        flywheel.event_training_run pin — the pin demotes from the only
+        control to the fallback default, so swapping to a test run and back
+        no longer means hand-editing cjm-workspace.yaml (and the yaml's
+        provenance comments are never rewritten). Every miss is LOUD (None +
+        the reason): a pick whose run vanished from disk, or a pin matching
+        nothing, never silently falls through to a different model (the
+        b9717422 field-failure class the register retired overlay-v1 for)."""
+        if pick:
+            for m in self.runs:
+                rid = str(m.get("run_id") or "")
+                if m.get("_path") == pick or rid == pick or rid.endswith(pick):
+                    return m, "picked"
+            gone = self._archived_match(pick)
+            if gone is not None:
+                return None, (f"picked run …{str(gone.get('run_id') or '?')[-8:]} "
+                              f"is ARCHIVED — m picks another (h shows archived)")
+            return None, f"picked run {pick!r} no longer on disk"
+        if pin:
+            run = self.resolve(pin)
+            if run is not None:
+                return run, "workspace pin"
+            if self._archived_match(pin) is not None:
+                return None, (f"training-run pin {pin!r} matches an ARCHIVED "
+                              f"run — m picks another, or unarchive it")
+            return None, (f"training-run pin {pin!r} matches nothing under "
+                          f"{self.training_runs_dir}")
+        if self.runs:
+            return self.runs[0], "newest run, no pin"
+        return None, f"no training runs under {self.training_runs_dir}"
+
+    def _archived_match(
+        self,
+        handle: str,  # A run's _path, run id, or id tail
+    ) -> Optional[Dict[str, Any]]:  # The ARCHIVED run the handle names, or None
+        """The loud-miss lookup: a pick or pin that resolves to nothing in
+        `runs` may name a run that was ARCHIVED (b20cb911) — the reason
+        says so instead of 'no longer on disk' / 'matches nothing'."""
+        for m in self.archived:
+            rid = str(m.get("run_id") or "")
+            if m.get("_path") == handle or rid == handle or rid.endswith(handle):
+                return m
+        return None
+
+    @staticmethod
+    def describe(m: Dict[str, Any]) -> str:  # One picker-row line of manifest facts
+        """A picker row's facts, read off the manifest alone (capability-
+        generic): run id · base model · [classes] · the headline eval
+        (macro AUROC when the holdout block carries it, else the first
+        metric) · consumed dataset tail · mint date."""
+        parts = [str(m.get("run_id") or "?")]
+        base = str((m.get("base_model") or {}).get("model_id")
+                   or (m.get("config") or {}).get("base_model_id") or "")
+        if base:
+            segs = base.rstrip("/").split("/")
+            # a hub id ends in the model name; a local checkpoint path ends
+            # in a weights FILE — name its directory instead
+            ext = segs[-1].rsplit(".", 1)[-1].lower()
+            parts.append(segs[-2] if len(segs) > 1 and ext in
+                         ("bin", "ckpt", "pt", "pth", "safetensors")
+                         else segs[-1])
+        parts.append("[" + (",".join(m.get("classes") or []) or "?") + "]")
+        ev = m.get("eval") or {}
+        macro = ((ev.get("holdout") or {}).get("auroc") or {}).get("macro")
+        metrics = ev.get("metrics") or {}
+        if isinstance(macro, (int, float)):
+            parts.append(f"auroc {macro:.3f}")
+        elif metrics:
+            k, v = next(iter(metrics.items()))
+            parts.append(f"{k} {v:.3f}" if isinstance(v, float) else f"{k} {v}")
+        ds = str(m.get("dataset_id") or "")
+        if ds:
+            parts.append(f"ds …{ds[-8:]}")
+        created = m.get("created_at")
+        if created:
+            parts.append(time.strftime("%Y-%m-%d", time.localtime(float(created))))
+        return " · ".join(parts)

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9/cjm_transcript_decomp_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-decomp-core
-Version: 0.0.6
+Version: 0.0.9
 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
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cjm_substrate>=0.0.61
+Requires-Dist: cjm_substrate>=0.0.63
 Requires-Dist: pyyaml
 Requires-Dist: cjm_context_graph_primitives>=0.0.15
 Requires-Dist: cjm_capability_primitives>=0.0.11
@@ -102,6 +102,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 - `event_spans_from_propset` _function_ — Load a proposal set BY POINTER and select its carve spans (respine trial
 - `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.
+- `resolve_event_propsets` _function_ — Join each proposal set to ITS source by the set manifest's own source
 - `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).

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/cjm_transcript_decomp_core.egg-info/requires.txt

@@ -1,4 +1,4 @@
-cjm_substrate>=0.0.61
+cjm_substrate>=0.0.63
 pyyaml
 cjm_context_graph_primitives>=0.0.15
 cjm_capability_primitives>=0.0.11

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
 ]
-dependencies = ['cjm_substrate>=0.0.61', 'pyyaml', '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']
+dependencies = ['cjm_substrate>=0.0.63', 'pyyaml', '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.6 → cjm_transcript_decomp_core-0.0.9}/tests/test_batch_logic.py

@@ -293,3 +293,134 @@ def test_training_run_index_discovery_and_resolve(tmp_path):
     # Empty dir: no runs, loud None
     empty = TrainingRunIndex(str(tmp_path / "nowhere"))
     assert empty.load() == 0 and empty.resolve() is None
+
+
+def test_training_run_resolve_pick_ladder_and_describe(tmp_path):
+    """Work item a13ebc66 (the propose training-run picker): the model
+    ladder is PICK > PIN > NEWEST with the reason named alongside, and every
+    miss is a loud None (a vanished pick, a pin matching nothing) — never a
+    silent fall-through to a different model. describe() reads a picker
+    row off the manifest alone: id · base · [classes] · headline eval ·
+    dataset tail · date."""
+    from cjm_transcript_decomp_core.runs import TrainingRunIndex
+    d = tmp_path / "training-runs"
+
+    def _run(run_id, classes, extra=None):
+        rd = d / run_id
+        rd.mkdir(parents=True)
+        m = {"format": TrainingRunIndex.FORMAT, "run_id": run_id, "classes": classes}
+        m.update(extra or {})
+        (rd / "manifest.json").write_text(json.dumps(m))
+
+    _run("trainrun_20260731_002436_6f803b12", ["speech", "inhale"],
+         {"base_model": {"model_id": "pyannote/segmentation-3.0"},
+          "dataset_id": "dataset_20260730_e53b8daa", "created_at": 1785000000.0,
+          "eval": {"holdout": {"auroc": {"macro": 0.99659}},
+                   "metrics": {"loss/val": 0.0634}}})
+    _run("trainrun_20260805_104926_73000552", ["click", "inhale"],
+         {"eval": {"metrics": {"loss/val": 0.0812}}})
+    idx = TrainingRunIndex(str(d))
+    assert idx.load() == 2
+    # No pick, no pin: newest is only a default, and the reason says so
+    run, why = idx.resolve_pick(None, None)
+    assert run["run_id"].endswith("73000552") and why == "newest run, no pin"
+    # The pin is the standing default over recency
+    run, why = idx.resolve_pick(None, "6f803b12")
+    assert run["run_id"].endswith("6f803b12") and why == "workspace pin"
+    # A pick outranks the pin — by _path, full id, or tail
+    older = idx.runs[1]
+    for pick in (older["_path"], older["run_id"], "6f803b12"):
+        run, why = idx.resolve_pick(pick, "73000552")
+        assert run["run_id"].endswith("6f803b12") and why == "picked"
+    run, why = idx.resolve_pick("73000552", "6f803b12")
+    assert run["run_id"].endswith("73000552") and why == "picked"
+    # Misses are LOUD: a vanished pick never falls through to the pin
+    run, why = idx.resolve_pick("deadbeef", "6f803b12")
+    assert run is None and "deadbeef" in why and "no longer on disk" in why
+    run, why = idx.resolve_pick(None, "deadbeef")
+    assert run is None and "matches nothing" in why
+    empty = TrainingRunIndex(str(tmp_path / "nowhere"))
+    empty.load()
+    assert empty.resolve_pick(None, None) == (None, f"no training runs under {empty.training_runs_dir}")
+    # describe(): the row facts a picker paints
+    line = TrainingRunIndex.describe(older)
+    assert line.startswith("trainrun_20260731_002436_6f803b12 · segmentation-3.0 · [speech,inhale]")
+    assert "auroc 0.997" in line and "ds …e53b8daa" in line and "2026-07-" in line
+    # No holdout block: the first metric is the headline; no base/ds: elided
+    line = TrainingRunIndex.describe(idx.runs[0])
+    assert "loss/val 0.081" in line and "ds …" not in line and "segmentation" not in line
+
+
+def test_batch_argv_renders_one_pointer_per_source():
+    """Multi-source event carve (decomp manifest 0.2.6): a group's resolved
+    propset may be a LIST/TUPLE (one pointer per source of a multi-source
+    run) — batch_argv renders every pointer under one --event-propset, in
+    order, and the single-source str form renders exactly as before."""
+    args = resolve_split_flags(build_parser().parse_args(
+        ["--event-split", "--event-classes", "inhale"]))
+    multi = batch_argv({"text_from": None, "graph_db_path": None,
+                        "event_propset": ("/sets/p_src0", "/sets/p_src1"),
+                        "manifests": ["ab.json"]}, args, None)
+    i = multi.index("--event-propset")
+    assert multi[i + 1:i + 3] == ["/sets/p_src0", "/sets/p_src1"]
+    assert multi[i + 3] == "--event-classes"
+    single = batch_argv({"text_from": None, "graph_db_path": None,
+                         "event_propset": "/sets/p_only",
+                         "manifests": ["a.json"]}, args, None)
+    j = single.index("--event-propset")
+    assert single[j + 1] == "/sets/p_only" and single[j + 2] == "--event-classes"
+
+
+def test_lifecycle_archived_artifacts_leave_pickers_and_misses_are_loud(tmp_path):
+    """Work item b20cb911 (DEC 14678fc9): an archived training run / proposal
+    set (a lifecycle.json sidecar beside the manifest, the substrate seam)
+    leaves the index's default list — the ladder never resolves to it and
+    for_source skips it — but stays reachable via `archived`, and a pick or
+    pin that lands on one is a LOUD miss naming the archive, never a silent
+    fall-through to another model."""
+    from cjm_substrate.utils.lifecycle import ArtifactLifecycle
+    from cjm_transcript_decomp_core.runs import PropsetIndex, TrainingRunIndex
+    trs = tmp_path / "training-runs"
+    for rid in ("trainrun_1_6f803b12", "trainrun_2_fa3035c6"):
+        (trs / rid).mkdir(parents=True)
+        (trs / rid / "manifest.json").write_text(json.dumps(
+            {"format": TrainingRunIndex.FORMAT, "run_id": rid, "classes": ["speech"]}))
+    idx = TrainingRunIndex(str(trs))
+    assert idx.load() == 2 and idx.archived == []
+    ArtifactLifecycle(trs / "trainrun_2_fa3035c6").archive(reason="test run")
+    assert idx.load() == 1
+    assert [m["run_id"][-8:] for m in idx.runs] == ["6f803b12"]
+    assert [m["run_id"][-8:] for m in idx.archived] == ["fa3035c6"]
+    assert idx.runs[0]["_lifecycle"] == "active"
+    assert idx.archived[0]["_lifecycle"] == "archived"
+    # newest-no-pin skips the archived head; a pin or pick on it is loud
+    run, why = idx.resolve_pick(None, None)
+    assert run["run_id"].endswith("6f803b12") and why == "newest run, no pin"
+    run, why = idx.resolve_pick(None, "fa3035c6")
+    assert run is None and "ARCHIVED" in why and "fa3035c6" in why
+    run, why = idx.resolve_pick(idx.archived[0]["_path"], "6f803b12")
+    assert run is None and "ARCHIVED" in why and "fa3035c6" in why
+    run, why = idx.resolve_pick(None, "deadbeef")
+    assert run is None and "matches nothing" in why
+    # unarchive restores it as the newest default
+    ArtifactLifecycle(trs / "trainrun_2_fa3035c6").unarchive()
+    assert idx.load() == 2
+    assert idx.resolve_pick(None, None)[0]["run_id"].endswith("fa3035c6")
+    # proposal sets: the archived set leaves its source's ring, the older
+    # generation heads it again, and `archived` keeps it inspectable
+    props = tmp_path / "proposals"
+    for pid, created in (("propset_1_aaaaaaaa", 1.0), ("propset_2_bbbbbbbb", 2.0)):
+        (props / pid).mkdir(parents=True)
+        (props / pid / "manifest.json").write_text(json.dumps(
+            {"format": PropsetIndex.FORMAT, "proposal_set_id": pid,
+             "created_at": created, "counts": {"inhale": 1},
+             "source": {"content_hash": "sha256:xx", "path": "/x.wav"}}))
+    pidx = PropsetIndex(str(props))
+    assert pidx.load() == 2
+    assert [m["proposal_set_id"][-8:] for m in pidx.for_source("sha256:xx")] \
+        == ["bbbbbbbb", "aaaaaaaa"]
+    ArtifactLifecycle(props / "propset_2_bbbbbbbb").archive()
+    assert pidx.load() == 1
+    assert [m["proposal_set_id"][-8:] for m in pidx.for_source("sha256:xx")] \
+        == ["aaaaaaaa"]
+    assert [m["proposal_set_id"][-8:] for m in pidx.archived] == ["bbbbbbbb"]

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/tests/test_models.py

@@ -1,6 +1,8 @@
 """Tests for cjm_transcript_decomp_core.models — decomposition data shapes.
 
 Projected from the models notebook's smoke-check cell at the golden-reference flip."""
+import re
+
 from cjm_transcript_decomp_core.models import (
     DecompManifest,
     DecompSegment,
@@ -38,7 +40,11 @@ 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.5" and md["sources"] == []
+    # Compare to the dataclass default, not a literal: the literal pin went RED on the first
+    # run after every manifest bump (0.2.3 -> 0.2.6), training agents to ignore a red test
+    # (housekeeping 042b7805). The shape check below keeps the version a real semver.
+    assert md["version"] == m.VERSION and md["sources"] == []
+    assert re.fullmatch(r"\d+\.\d+\.\d+", m.VERSION)
     # 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
     # 0.2.4: event-carve chain fields (empty/None until an event_split run fills them)

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.9}/tests/test_pipeline.py

@@ -194,3 +194,54 @@ def test_event_carve_identity_and_propset_loading(tmp_path):
     import pytest
     with pytest.raises(RuntimeError):
         event_spans_from_propset(tmp_path / "missing", ["inhale"])
+
+
+def test_resolve_event_propsets_joins_each_set_to_its_source(tmp_path):
+    """Multi-source event carve (manifest 0.2.6): resolve_event_propsets joins
+    each proposal set to ITS source by the set manifest's own binding —
+    content hash first, path as the fallback — in any pointer order, and
+    every refusal is loud: an uncovered source, a stray pointer, two sets
+    claiming one source, and a lone mismatched pointer over a lone source
+    (the silent-wrong-spans class)."""
+    import json
+    import pytest
+    from cjm_transcript_decomp_core.pipeline import resolve_event_propsets
+
+    def _set(name, source, spans):
+        d = tmp_path / name
+        d.mkdir()
+        (d / "manifest.json").write_text(json.dumps({
+            "format": "cjm-capability-pyannote/proposal-set-manifest",
+            "proposal_set_id": name, "source": source,
+            "files": {"proposals": "proposals.jsonl"}}))
+        (d / "proposals.jsonl").write_text("\n".join(
+            json.dumps({"label": "inhale", "tier": 1, "start_time": s, "end_time": e})
+            for s, e in spans))
+        return str(d)
+
+    a = _set("propset_a", {"content_hash": "sha256:aaa", "path": "/media/a.wav"}, [(1.0, 1.5)])
+    b = _set("propset_b", {"content_hash": "sha256:bbb", "path": "/media/b.wav"}, [(2.0, 2.5), (3.0, 3.2)])
+    c_path_only = _set("propset_c", {"path": "/media/c.wav"}, [(4.0, 4.1)])
+    sources = [{"source_path": "/media/a.wav", "content_hash": "sha256:aaa"},
+               {"source_path": "/media/b.wav", "content_hash": "sha256:bbb"},
+               {"source_path": "/media/c.wav", "content_hash": "sha256:ccc"}]
+    # any pointer order; hash join for a/b, path fallback for c
+    out = resolve_event_propsets([c_path_only, b, a], sources, ["inhale"])
+    assert [m["proposal_set_id"] for m, _, _ in out] == ["propset_a", "propset_b", "propset_c"]
+    assert [spans for _, spans, _ in out] == [[(1.0, 1.5)], [(2.0, 2.5), (3.0, 3.2)], [(4.0, 4.1)]]
+    assert [ptr for _, _, ptr in out] == [a, b, c_path_only]
+    # single-source, single pointer: the 0.2.5 shape, unchanged
+    assert resolve_event_propsets([a], sources[:1], ["inhale"])[0][0]["proposal_set_id"] == "propset_a"
+    # uncovered source
+    with pytest.raises(RuntimeError, match="no proposal set covers source 2"):
+        resolve_event_propsets([a, b], sources, ["inhale"])
+    # stray pointer (binds to none of the run's sources)
+    with pytest.raises(RuntimeError, match="bind to none"):
+        resolve_event_propsets([a, b], sources[:1], ["inhale"])
+    # two sets claiming one source
+    a2 = _set("propset_a2", {"content_hash": "sha256:aaa", "path": "/media/a.wav"}, [(1.2, 1.4)])
+    with pytest.raises(RuntimeError, match="2 proposal sets claim source 0"):
+        resolve_event_propsets([a, a2], sources[:1], ["inhale"])
+    # lone mismatched pointer over a lone source is NOT tolerated
+    with pytest.raises(RuntimeError, match="no proposal set covers source 0"):
+        resolve_event_propsets([b], sources[:1], ["inhale"])

cjm_transcript_decomp_core-0.0.6/cjm_transcript_decomp_core/__init__.py

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