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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-decomp-core
-Version: 0.0.6
+Version: 0.0.10
 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
@@ -26,7 +26,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ## Modules
 
-- **`cjm_transcript_decomp_core`**
+- **`cjm_transcript_decomp_core.__init__`**
 - **`cjm_transcript_decomp_core.alignment`** — 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).
 - **`cjm_transcript_decomp_core.cli`** — The CLI driver — the decomposition core's first (and currently only) frontend.
 - **`cjm_transcript_decomp_core.discovery`** — Capability-role discovery by manifest surface match — the journaling-by-
@@ -53,6 +53,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.cli`
 
+- `backfill_provenance_command` _function_ — Execute `backfill-provenance`: mint the Segment -> Transcript DERIVED_FROM
 - `build_parser` _function_ — Build the CLI parser (subcommands: run).
 - `load_capabilities` _function_ — Discover manifests + load each requested capability (default instance).
 - `main` _function_ — CLI entry point (console script: `cjm-transcript-decomp-core`).
@@ -67,7 +68,9 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 - `SourceVerification` _class_ — Skeptical-lens verification of one Source's fine-spine extension under a
 - `build_extension_payload` _function_ — Build the fine-spine EXTENSION payload (pure; no capability calls).
+- `provenance_edges_from_segment_wire` _function_ — Derive a Segment's Transcript provenance edges from the node itself:
 - `resolve_root_ids` _function_ — Recompute the transcription-emitted root node ids from manifest data.
+- `segment_provenance_edges` _function_ — Text provenance as EDGES (finding 89b16be6, the references-must-be-edges
 - `verify_source` _function_ — Verify a Source's committed extension via server-side AGGREGATES (D13/D19).
 
 ### `cjm_transcript_decomp_core.launch`
@@ -102,6 +105,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).
@@ -140,4 +144,4 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 ## Dependencies
 
 **Depends on:** `cjm-capability-primitives`, `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`, `pyyaml`
-**Used by:** `cjm-transcript-decomp-qt`, `cjm-transcript-decomp-tui`
+**Used by:** `cjm-transcript-decomp-qt`

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

@@ -6,7 +6,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ## Modules
 
-- **`cjm_transcript_decomp_core`**
+- **`cjm_transcript_decomp_core.__init__`**
 - **`cjm_transcript_decomp_core.alignment`** — 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).
 - **`cjm_transcript_decomp_core.cli`** — The CLI driver — the decomposition core's first (and currently only) frontend.
 - **`cjm_transcript_decomp_core.discovery`** — Capability-role discovery by manifest surface match — the journaling-by-
@@ -33,6 +33,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.cli`
 
+- `backfill_provenance_command` _function_ — Execute `backfill-provenance`: mint the Segment -> Transcript DERIVED_FROM
 - `build_parser` _function_ — Build the CLI parser (subcommands: run).
 - `load_capabilities` _function_ — Discover manifests + load each requested capability (default instance).
 - `main` _function_ — CLI entry point (console script: `cjm-transcript-decomp-core`).
@@ -47,7 +48,9 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 - `SourceVerification` _class_ — Skeptical-lens verification of one Source's fine-spine extension under a
 - `build_extension_payload` _function_ — Build the fine-spine EXTENSION payload (pure; no capability calls).
+- `provenance_edges_from_segment_wire` _function_ — Derive a Segment's Transcript provenance edges from the node itself:
 - `resolve_root_ids` _function_ — Recompute the transcription-emitted root node ids from manifest data.
+- `segment_provenance_edges` _function_ — Text provenance as EDGES (finding 89b16be6, the references-must-be-edges
 - `verify_source` _function_ — Verify a Source's committed extension via server-side AGGREGATES (D13/D19).
 
 ### `cjm_transcript_decomp_core.launch`
@@ -82,6 +85,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).
@@ -120,4 +124,4 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 ## Dependencies
 
 **Depends on:** `cjm-capability-primitives`, `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`, `pyyaml`
-**Used by:** `cjm-transcript-decomp-qt`, `cjm-transcript-decomp-tui`
+**Used by:** `cjm-transcript-decomp-qt`

cjm_transcript_decomp_core-0.0.10/cjm_transcript_decomp_core/__init__.py

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

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

@@ -27,9 +27,13 @@ import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from cjm_context_graph_layer.journal import journal_extend, sidecar_journal_path
+from cjm_context_graph_layer.ops import graph_task
+from cjm_context_graph_primitives.query import NodeQuery
 from cjm_substrate.core.manager import CapabilityManager
 from cjm_substrate.core.queue import JobQueue
 from cjm_substrate.core.workspace import resolve_workspace
+from cjm_transcript_decomp_core.graph import provenance_edges_from_segment_wire
 from cjm_transcript_decomp_core.models import DecompConfig
 from cjm_transcript_decomp_core.pipeline import load_source_manifest, run_decomp
 
@@ -78,9 +82,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)")
@@ -104,6 +111,29 @@ def build_parser() -> argparse.ArgumentParser:  # Configured CLI parser
     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")
+
+    # ---- backfill-provenance: Segment -> Transcript DERIVED_FROM edges (finding 89b16be6) ----
+    bp = sub.add_parser(
+        "backfill-provenance",
+        help="Mint Segment -> Transcript DERIVED_FROM edges for Segments already on the graph "
+             "(text provenance as an edge, not only text_from metadata); journaled per source "
+             "under spine-extension, idempotent on re-run")
+    bp.add_argument("--source", default=None,
+                    help="Restrict to one Source node id (prefix ok; default: every Segment)")
+    bp.add_argument("--page-size", type=int, default=2000,
+                    help="Segments per query page (default 2000)")
+    bp.add_argument("--manifests-dir", default=".cjm/manifests", help="Capability manifests directory")
+    bp.add_argument("--graph-capability", default="cjm-capability-graph-sqlite",
+                    help="Graph-storage capability name")
+    bp.add_argument("--graph-db-path", default=None,
+                    help="Graph db path (default: the workspace capability config)")
+    bp.add_argument("--workspace", default=None,
+                    help="Workspace root (default: CJM_WORKSPACE env, else upward walk from cwd)")
+    bp.add_argument("--actor", default=None,
+                    help="Journal attribution (default: cli:<username>)")
+    bp.add_argument("--dry-run", action="store_true",
+                    help="Count the edges per source; touch neither graph nor journal")
+    bp.add_argument("-v", "--verbose", action="store_true", help="DEBUG-level logging")
     return parser
 
 
@@ -168,12 +198,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
@@ -256,4 +290,80 @@ def main(
     )
     if args.command == "run":
         return asyncio.run(run_command(args))
+    if args.command == "backfill-provenance":
+        return asyncio.run(backfill_provenance_command(args))
     raise SystemExit(f"unknown command: {args.command}")
+
+
+async def backfill_provenance_command(
+    args: argparse.Namespace,  # Parsed CLI arguments for the `backfill-provenance` subcommand
+) -> int:  # Process exit code
+    """Execute `backfill-provenance`: mint the Segment -> Transcript DERIVED_FROM
+    edges (finding 89b16be6) for Segments already on the graph, deriving each
+    segment's edges from its own refs (`provenance_edges_from_segment_wire`,
+    the same derivation a fresh decomposition uses). Journaled per SOURCE under
+    the existing `spine-extension` verb (edges-only wires; the replay handler
+    is already registered, and `journal_extend`'s added-delta trim keeps a
+    re-run silent), args carry act=provenance-backfill so the ops read as what
+    they are. Pages the Segment table so a 100k-segment graph never sits in one
+    query; --source narrows to one Source id (prefix ok); --dry-run counts."""
+    ws = resolve_workspace(explicit=getattr(args, "workspace", None))
+    if ws is not None:
+        os.environ["CJM_WORKSPACE"] = str(ws.root)
+    manager = CapabilityManager(search_paths=[Path(args.manifests_dir)])
+    configs = ({args.graph_capability: {"db_path": args.graph_db_path}}
+               if args.graph_db_path else None)
+    load_capabilities(manager, [args.graph_capability], configs=configs)
+    effective = args.graph_db_path or (
+        (manager.instances[args.graph_capability].config or {}).get("db_path"))
+    if not effective:
+        raise SystemExit("no graph db path: pass --graph-db-path, or persist one on the "
+                         f"{args.graph_capability} instance in the active workspace's config store")
+    journal_path = sidecar_journal_path(str(effective))
+    actor = args.actor or f"cli:{getpass.getuser()}"
+    queue = JobQueue(deps=manager)
+    await queue.start()
+    try:
+        per_source: Dict[str, List[Dict[str, Any]]] = {}
+        seg_counts: Dict[str, int] = {}
+        offset = 0
+        while True:
+            nq = NodeQuery(label="Segment", project=["text_from", "source_id", "sources"],
+                           limit=args.page_size, offset=offset)
+            res = await graph_task(queue, args.graph_capability, "query_nodes", query=nq.to_dict())
+            rows = list(res.rows or [])
+            for row in rows:
+                sid = row.get("source_id") or "?"
+                if args.source and not sid.startswith(args.source):
+                    continue
+                seg_counts[sid] = seg_counts.get(sid, 0) + 1
+                per_source.setdefault(sid, []).extend(provenance_edges_from_segment_wire(row))
+            if len(rows) < args.page_size:
+                break
+            offset += len(rows)
+        total_edges = sum(len(v) for v in per_source.values())
+        if args.dry_run:
+            for sid in sorted(per_source):
+                print(f"{sid[:8]}  segments={seg_counts[sid]}  edges={len(per_source[sid])}")
+            print(f"dry run: {len(per_source)} sources, {sum(seg_counts.values())} segments, "
+                  f"{total_edges} DERIVED_FROM edges (nothing written)")
+            return 0
+        added = 0
+        for sid in sorted(per_source):
+            edges = per_source[sid]
+            if not edges:
+                continue
+            r = await journal_extend(queue, args.graph_capability, [], edges,
+                                     journal_path=journal_path, verb="spine-extension",
+                                     actor=actor,
+                                     args={"act": "provenance-backfill", "source_id": sid,
+                                           "segments": seg_counts[sid], "edges": len(edges)})
+            added += r.edges_added
+            print(f"{sid[:8]}  segments={seg_counts[sid]}  edges={len(edges)}  added={r.edges_added}")
+    finally:
+        await queue.stop()
+        manager.unload_capability(args.graph_capability)
+    print(f"backfilled DERIVED_FROM edges: {added} added of {total_edges} derived "
+          f"across {len(per_source)} sources (actor {actor})")
+    print(f"journal: {journal_path}")
+    return 0

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.10}/cjm_transcript_decomp_core/graph.py

@@ -3,7 +3,8 @@
 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.grammar import (grouped_spine_edges, make_edge, OverlayRelations,
+                                             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
@@ -80,7 +81,9 @@ def build_extension_payload(
     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.
+    STARTS_WITH per rendition, NEXT chained source-wide across coarse boundaries —
+    plus one DERIVED_FROM per sliced Transcript (text provenance as an edge,
+    finding 89b16be6; role=text_from marks the authoritative one).
     """
     roots = resolve_root_ids(source_entry, capabilities_info)
     source_id = roots["source"]
@@ -114,6 +117,13 @@ def build_extension_payload(
 
     # 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)])
+    # Text provenance is an EDGE, not only a property (finding 89b16be6): each
+    # Segment DERIVED_FROM every Transcript it slices (role=text_from on the
+    # authoritative one), so Segments are reachable from their Transcript by
+    # traversal the way they already were from their AudioRendition. Derived
+    # from the node's own refs — the same derivation the backfill verb uses.
+    for node in nodes:
+        edges.extend(provenance_edges_from_segment_wire(node))
     ids = {"source": source_id, "segments": seg_ids,
            "audio_segments": [a["audio_segment"] for a in asegs],
            "renditions": [a["rendition"] for a in asegs],
@@ -273,3 +283,48 @@ async def verify_source(
         all_have_sources=missing_sources == 0,
         source_locators=sorted(locators),
     )
+
+
+def segment_provenance_edges(
+    segment_id: str,                   # The Segment node id
+    transcript_ids: List[str],         # Transcript node ids the segment slices text from (any order; de-duplicated)
+    text_from: Optional[str] = None,   # The authoritative Transcript id (None when the segment carries no text)
+) -> List[Dict[str, Any]]:  # DERIVED_FROM edge wires, Segment -> Transcript, one per distinct transcript
+    """Text provenance as EDGES (finding 89b16be6, the references-must-be-edges
+    instance): a Segment's text comes from Transcript nodes, and until now that
+    link lived only in `text_from` metadata + the CharSlice source refs, so a
+    Segment was unreachable from its Transcript by traversal (the only
+    traceability edge went to the AudioRendition). One DERIVED_FROM per sliced
+    Transcript; the authoritative one carries role=text_from, the rest
+    role=variant. Ids are deterministic from the triple, so a backfill over
+    existing Segments and a fresh decomposition converge on the same edges."""
+    seen: set = set()
+    edges: List[Dict[str, Any]] = []
+    for tid in transcript_ids:
+        if not tid or tid in seen:
+            continue
+        seen.add(tid)
+        role = "text_from" if tid == text_from else "variant"
+        edges.append(make_edge(segment_id, tid, OverlayRelations.DERIVED_FROM, {"role": role}))
+    return edges
+
+
+def provenance_edges_from_segment_wire(
+    node: Dict[str, Any],  # A Segment node wire (or projected row): {"id", "properties"?, "sources", "text_from"?}
+) -> List[Dict[str, Any]]:  # The segment's DERIVED_FROM edges, derived from its own refs
+    """Derive a Segment's Transcript provenance edges from the node itself:
+    every `char`-sliced source ref's graph-node locator is a Transcript the
+    segment slices text from, and `text_from` (a property on a wire, a
+    projected field on a query row) names the authoritative one. ONE derivation
+    for both callers — `build_extension_payload` at decomposition time and the
+    `backfill-provenance` verb over Segments already on the graph — so the
+    backfill reproduces exactly what a fresh run would emit."""
+    props = node.get("properties") or {}
+    text_from = props.get("text_from", node.get("text_from"))
+    tids: List[str] = []
+    for ref in node.get("sources") or []:
+        sl = ref.get("slice") or {}
+        loc = ref.get("locator") or {}
+        if sl.get("kind") == "char" and loc.get("node_id"):
+            tids.append(loc["node_id"])
+    return segment_provenance_edges(node["id"], tids, text_from)

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.10}/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.10}/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.10}/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.10}/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.10/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.10
 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
@@ -26,7 +26,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ## Modules
 
-- **`cjm_transcript_decomp_core`**
+- **`cjm_transcript_decomp_core.__init__`**
 - **`cjm_transcript_decomp_core.alignment`** — 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).
 - **`cjm_transcript_decomp_core.cli`** — The CLI driver — the decomposition core's first (and currently only) frontend.
 - **`cjm_transcript_decomp_core.discovery`** — Capability-role discovery by manifest surface match — the journaling-by-
@@ -53,6 +53,7 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 ### `cjm_transcript_decomp_core.cli`
 
+- `backfill_provenance_command` _function_ — Execute `backfill-provenance`: mint the Segment -> Transcript DERIVED_FROM
 - `build_parser` _function_ — Build the CLI parser (subcommands: run).
 - `load_capabilities` _function_ — Discover manifests + load each requested capability (default instance).
 - `main` _function_ — CLI entry point (console script: `cjm-transcript-decomp-core`).
@@ -67,7 +68,9 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 
 - `SourceVerification` _class_ — Skeptical-lens verification of one Source's fine-spine extension under a
 - `build_extension_payload` _function_ — Build the fine-spine EXTENSION payload (pure; no capability calls).
+- `provenance_edges_from_segment_wire` _function_ — Derive a Segment's Transcript provenance edges from the node itself:
 - `resolve_root_ids` _function_ — Recompute the transcription-emitted root node ids from manifest data.
+- `segment_provenance_edges` _function_ — Text provenance as EDGES (finding 89b16be6, the references-must-be-edges
 - `verify_source` _function_ — Verify a Source's committed extension via server-side AGGREGATES (D13/D19).
 
 ### `cjm_transcript_decomp_core.launch`
@@ -102,6 +105,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).
@@ -140,4 +144,4 @@ A frontend-agnostic core for the transcript decomposition workflow — composes
 ## Dependencies
 
 **Depends on:** `cjm-capability-primitives`, `cjm-context-graph-layer`, `cjm-context-graph-primitives`, `cjm-substrate`, `cjm-transcript-graph-schema`, `pyyaml`
-**Used by:** `cjm-transcript-decomp-qt`, `cjm-transcript-decomp-tui`
+**Used by:** `cjm-transcript-decomp-qt`

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.10}/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.10}/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.10}/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.10}/tests/test_graph.py

@@ -123,3 +123,35 @@ def test_parallel_spines_disjoint_ids_and_split_metadata():
     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)
+
+
+def test_segment_transcript_provenance_edges():
+    # finding 89b16be6: a Segment's text provenance is an EDGE, not only metadata —
+    # DERIVED_FROM per sliced Transcript, the authoritative one role=text_from, the
+    # others role=variant; an empty (audio-only) segment derives no text edge; and the
+    # wire-derived form (the backfill's input) reproduces the builder's edges exactly.
+    from cjm_transcript_decomp_core.graph import (provenance_edges_from_segment_wire,
+                                                  segment_provenance_edges)
+    roots = resolve_root_ids(SOURCE_ENTRY, CAPABILITIES)
+    tv = roots["audio_segments"][0]["transcripts"]["voxtral"]
+    tw = roots["audio_segments"][0]["transcripts"]["whisper"]
+    nodes, edges, ids = build_extension_payload(SOURCE_ENTRY, CAPABILITIES, "sha256:vad", "voxtral", _segments())
+    derived = [e for e in edges if e["relation_type"] == "DERIVED_FROM"]
+    # seg 0 slices voxtral + whisper (2 edges), seg 1 voxtral only (1), seg 2 empty (0)
+    assert len(derived) == 3
+    by_src = {}
+    for e in derived:
+        by_src.setdefault(e["source_id"], []).append(e)
+    s0 = {e["target_id"]: e["properties"]["role"] for e in by_src[ids["segments"][0]]}
+    assert s0 == {tv: "text_from", tw: "variant"}
+    assert [(e["target_id"], e["properties"]["role"]) for e in by_src[ids["segments"][1]]] == [(tv, "text_from")]
+    assert ids["segments"][2] not in by_src
+    # Deterministic ids from the triple: a rebuilt edge collides into the same id.
+    again = segment_provenance_edges(ids["segments"][0], [tw, tv], tv)
+    assert {e["id"] for e in again} == {e["id"] for e in by_src[ids["segments"][0]]}
+    # The backfill derivation (from the node's own refs) == the builder's edges.
+    for n in nodes:
+        assert provenance_edges_from_segment_wire(n) == by_src.get(n["id"], [])
+    # A projected query row carries text_from as a field, not under properties.
+    row = {"id": nodes[0]["id"], "text_from": tv, "sources": nodes[0]["sources"]}
+    assert provenance_edges_from_segment_wire(row) == by_src[nodes[0]["id"]]

{cjm_transcript_decomp_core-0.0.6 → cjm_transcript_decomp_core-0.0.10}/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.10}/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"