cjm-transcript-graph-schema 0.0.8__tar.gz → 0.0.11__tar.gz

{cjm_transcript_graph_schema-0.0.8/cjm_transcript_graph_schema.egg-info → cjm_transcript_graph_schema-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-graph-schema
-Version: 0.0.8
+Version: 0.0.11
 Summary: Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcript, and Segment nodes with deterministic identity tuples and graph-node mapping, shared by the transcription, decomposition, and correction workflow cores.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -32,6 +32,7 @@ Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcri
 - `AudioRenditionNode` _class_ — A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
 - `AudioSegmentNode` _class_ — Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
 - `CollectionNode` _class_ — An intrinsic collection (book, podcast series, lecture course) — the
+- `RespinedChunkEntry` _class_ — One chunk respine as the Source records it (0b4d5cfa (4)): the entry the
 - `SegmentNode` _class_ — Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
 - `SourceNode` _class_ — The provenance root: one ingested media file.
 - `TranscriptGraphLabels` _class_ — Node labels of the audio-transcript layer schema.

{cjm_transcript_graph_schema-0.0.8 → cjm_transcript_graph_schema-0.0.11}/README.md

@@ -15,6 +15,7 @@ Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcri
 - `AudioRenditionNode` _class_ — A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
 - `AudioSegmentNode` _class_ — Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
 - `CollectionNode` _class_ — An intrinsic collection (book, podcast series, lecture course) — the
+- `RespinedChunkEntry` _class_ — One chunk respine as the Source records it (0b4d5cfa (4)): the entry the
 - `SegmentNode` _class_ — Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
 - `SourceNode` _class_ — The provenance root: one ingested media file.
 - `TranscriptGraphLabels` _class_ — Node labels of the audio-transcript layer schema.

cjm_transcript_graph_schema-0.0.11/cjm_transcript_graph_schema/__init__.py

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

{cjm_transcript_graph_schema-0.0.8 → cjm_transcript_graph_schema-0.0.11}/cjm_transcript_graph_schema/schema.py

@@ -20,11 +20,13 @@ class TranscriptGraphLabels:
     TRANSCRIPT = "Transcript"          # Per-transcriber text variant of one AudioRendition
     SEGMENT = "Segment"                # Fine spine member: one VAD chunk (immutable audio + correctable text), per-rendition
     COLLECTION = "Collection"          # Intrinsic collection (book / series / course): the fractal spine layer ABOVE Source
+    REFERENCE = "Reference"            # Human-added resource link attached to a Source (publisher page / author post / related notes / cited work): Source -HAS_REFERENCE-> Reference (ruling a7ca900d (3), item ae103970)
 
     @classmethod
     def all(cls) -> list:  # All schema labels
         """All schema labels."""
-        return [cls.SOURCE, cls.AUDIO_SEGMENT, cls.AUDIO_RENDITION, cls.TRANSCRIPT, cls.SEGMENT, cls.COLLECTION]
+        return [cls.SOURCE, cls.AUDIO_SEGMENT, cls.AUDIO_RENDITION, cls.TRANSCRIPT, cls.SEGMENT, cls.COLLECTION,
+                cls.REFERENCE]
 
 
 def source_node_id(
@@ -78,17 +80,61 @@ def transcript_node_id(
     return derive_node_id("transcript", rendition_id, transcriber, config_hash)
 
 
+EXTERNAL_TRANSCRIBER_MARKER = "/manual"  # Suffix naming an operator-landed (pasted) transcript producer
+
+
+def external_transcriber_name(
+    model_id: str,  # The external model that produced the text (e.g. "gemini-2.5-pro")
+) -> str:  # The transcriber name an external landing files under
+    """Transcriber name for an EXTERNAL landing (ruling 9ffce5f7 (1)): the model id
+    plus a manual marker, so a pasted transcript is a THIRD TRANSCRIBER beside the
+    local capabilities — decomp folds it per chunk like any other variant, and the
+    marker keeps it distinguishable from a capability run of the same model."""
+    mid = (model_id or "").strip()
+    if not mid:
+        raise ValueError("external_transcriber_name: model_id is required")
+    return mid + EXTERNAL_TRANSCRIBER_MARKER
+
+
+def external_config_hash(
+    model_id: str,     # The external model id
+    prompt_hash: str,  # Hash of the prompt template the operator used ("" = no prompt recorded)
+) -> str:  # "sha256:<hex>" — the config-hash slot of an external landing
+    """The config hash an external landing carries where a capability's effective
+    config hash goes: sha256 over (model id, prompt hash). The prompt is DATA
+    (f304d31d), so a different prompt template is a different variant — and the
+    Transcript identity (rendition, transcriber, config_hash) stays recomputable
+    from the derived manifest alone."""
+    import hashlib
+    h = hashlib.sha256()
+    h.update((model_id or "").strip().encode("utf-8"))
+    h.update(b"\n")
+    h.update((prompt_hash or "").strip().encode("utf-8"))
+    return "sha256:" + h.hexdigest()
+
+
 def segment_node_id(
     rendition_id: str,     # Owning AudioRendition node id
-    vad_config_hash: str,  # VAD capability config hash (skeleton identity input)
+    vad_config_hash: str,  # Skeleton config hash (identity input: VAD config, + split policy when a split stage ran)
     chunk_start: float,    # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float,      # VAD chunk end (chunk-local seconds)
+    identity_salt: Optional[str] = None,  # Respine salt (0b4d5cfa (3)): joins the id ONLY; None = the spine's original derivation
 ) -> str:  # Deterministic Segment node id
     """Fine Segment identity = audio-side only (audio rendition, VAD config, chunk
     range) — so the skeleton's ids are SHARED across transcribers by
     construction (C4 "store agreement once" falls out of identity design). Keyed
     on the RENDITION: each rendition has its own fine spine (vocals isolation can
-    yield different VAD chunk boundaries than raw)."""
+    yield different VAD chunk boundaries than raw).
+
+    A CHUNK RESPINE (0b4d5cfa) re-derives one coarse chunk into the LIVE spine
+    from a landed external transcript: its segments keep the live skeleton hash
+    (every picker groups spines by it) and fork identity through `identity_salt`
+    = the landed Transcript's node id, so the same landing twice collides into
+    a no-op and a different landing mints fresh segments. None (the default)
+    reproduces every pre-salt id unchanged."""
+    if identity_salt:
+        return derive_node_id("segment", rendition_id, vad_config_hash, chunk_start, chunk_end,
+                              identity_salt)
     return derive_node_id("segment", rendition_id, vad_config_hash, chunk_start, chunk_end)
 
 
@@ -220,6 +266,8 @@ class TranscriptNode:
     audio_hash: str               # Content hash of the consumed model-input WAV (the rendition's)
     metadata: Dict[str, Any] = field(default_factory=dict)  # Transcriber-reported metadata
     asserted_at: Optional[float] = None  # Derivation timestamp; None = now
+    actor: Optional[str] = None   # Attribution actor; None = "capability:<transcriber>" (an EXTERNAL landing names the operator, 9ffce5f7 (1))
+    method: str = "transcribe"    # Attribution method ("transcribe" for a capability run; "external-landing" for pasted text)
 
     @property
     def id(self) -> str:  # Deterministic node id
@@ -236,7 +284,7 @@ class TranscriptNode:
         }
         if self.metadata:
             props["metadata"] = dict(self.metadata)
-        props.update(attribution(f"capability:{self.transcriber}", method="transcribe",
+        props.update(attribution(self.actor or f"capability:{self.transcriber}", method=self.method,
                                  asserted_at=self.asserted_at))
         return {
             "id": self.id,
@@ -251,6 +299,18 @@ class TranscriptNode:
         """DERIVED_FROM edge: this Transcript derives from its AudioRendition."""
         return make_edge(self.id, self.rendition, OverlayRelations.DERIVED_FROM)
 
+    def supersedes_edge(
+        self,
+        prior_transcript_id: str,  # The Transcript variant this one replaces (same rendition + transcriber, an older config)
+    ) -> Dict[str, Any]:  # Edge wire dict
+        """SUPERSEDES edge: this variant replaces a prior one for the same (rendition,
+        transcriber) — a chunk-targeted re-run under a new config, or a re-landed
+        external transcript (ruling 910f3692 (2)). The prior node STAYS as append-only
+        history; readers treat a variant with an incoming SUPERSEDES edge as NOT LIVE."""
+        if prior_transcript_id == self.id:
+            raise ValueError("supersedes_edge: a Transcript cannot supersede itself")
+        return make_edge(self.id, prior_transcript_id, OverlayRelations.SUPERSEDES)
+
 
 @dataclass
 class TranscriptSliceRef:
@@ -273,14 +333,23 @@ class TranscriptSliceRef:
 class SegmentNode:
     """Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
     text (the immutable-audio/mutable-text spine seam). PART_OF its AudioRendition
-    (each rendition has its own fine spine).
+    (each rendition has its own fine spine). Parallel SPINES coexist under one
+    rendition (sentence-split, DEC f1024568): the skeleton hash feeds every node
+    id AND rides the queryable `skeleton_hash` prop, so spine-scoped reads never
+    mix coexisting skeletons (pre-split nodes lack the prop = the legacy spine).
 
     Layer-0 `text` is the ACCURACY transcriber's alignment; the designation is
     per-segment provenance, not global config (`text_from` names the
     authoritative Transcript; every transcriber's char range rides
-    `text_slices`, the authoritative one included)."""
+    `text_slices`, the authoritative one included).
+
+    A CHUNK RESPINE (0b4d5cfa) replaces one coarse chunk's segments INSIDE the
+    live spine: the new segments carry `identity_salt` (joins the id only —
+    `skeleton_hash` stays the live spine's, so no reader splits the spine),
+    the old ones are stamped `superseded_by` (the respine op id) and leave the
+    live view — readers filter `superseded_by is null`; nothing is deleted."""
     rendition: str            # Owning AudioRendition node id
-    vad_config_hash: str      # VAD config hash (skeleton identity input)
+    vad_config_hash: str      # Skeleton config hash (identity input: VAD config, + split policy when a split stage ran)
     chunk_start: float        # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float          # VAD chunk end (chunk-local seconds)
     index: int                # Source-wide fine-spine index (0-based)
@@ -290,13 +359,18 @@ class SegmentNode:
     audio_hash: str = ""      # Content hash of the owning rendition's model-input WAV
     source: Optional[str] = None     # Source node id (convenience for direct filters)
     text_from: Optional[str] = None  # Authoritative Transcript node id (None when text is empty)
+    split_policy: Optional[str] = None  # Split policy+version that refined the skeleton (None = raw VAD chunks)
     text_slices: List[TranscriptSliceRef] = field(default_factory=list)  # All per-transcriber slice refs
+    identity_salt: Optional[str] = None  # Respine salt (the landed Transcript id): joins the id ONLY (0b4d5cfa (3)); None = original derivation
+    superseded_by: Optional[str] = None  # Respine op id that retired this segment from the live view (stamped post-hoc; None = live)
 
     @property
     def id(self) -> str:  # Deterministic node id
-        """Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."""
+        """Deterministic node id (audio-side identity; shared across transcribers, per-rendition;
+        forked by `identity_salt` on a chunk respine)."""
         return segment_node_id(self.rendition, self.vad_config_hash,
-                               self.chunk_start, self.chunk_end)
+                               self.chunk_start, self.chunk_end,
+                               identity_salt=self.identity_salt)
 
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
         """Build the Segment node wire dict (audio ref + per-transcriber text slice refs)."""
@@ -308,11 +382,18 @@ class SegmentNode:
             "chunk_start": self.chunk_start,
             "chunk_end": self.chunk_end,
             "rendition_id": self.rendition,
+            "skeleton_hash": self.vad_config_hash,
         }
+        if self.split_policy:
+            props["split_policy"] = self.split_policy
         if self.source:
             props["source_id"] = self.source
         if self.text_from:
             props["text_from"] = self.text_from
+        if self.identity_salt:
+            props["identity_salt"] = self.identity_salt
+        if self.superseded_by:
+            props["superseded_by"] = self.superseded_by
         sources = [SourceRef(locator=GraphNodeRef(node_id=self.rendition),
                              content_hash=self.audio_hash,
                              slice=TimeSlice(start=self.chunk_start, end=self.chunk_end)).to_dict()]
@@ -325,6 +406,53 @@ class SegmentNode:
         }
 
 
+RESPINE_OP_VERB = "chunk-respine"                # The journaled spine-fact op that lands a chunk respine (0b4d5cfa (4))
+SOURCE_RESPINED_CHUNKS_PROP = "respined_chunks"  # Source prop: the list of RespinedChunkEntry dicts, append-only
+SEGMENT_SUPERSEDED_BY_PROP = "superseded_by"     # Segment prop stamped on the chunk's old segments (live readers filter it null)
+
+
+@dataclass
+class RespinedChunkEntry:
+    """One chunk respine as the Source records it (0b4d5cfa (4)): the entry the
+    `chunk-respine` op appends to the Source's `respined_chunks` list — WHICH
+    coarse chunk, WHICH landed Transcript re-derived it (= the new segments'
+    identity salt), under WHICH decomp run, when, and what the op did to the
+    dependents (stranded ids on explicit say-so; carried = the corrections the
+    chunk-scoped transfer re-homed by time: accepted event inserts, speaker
+    assignments). The op id is what `superseded_by` on the old segments names."""
+    audio_segment: str                                  # AudioSegment node id (the coarse chunk)
+    transcript: str                                     # The landed Transcript node id (= identity_salt of the new segments)
+    run: str                                            # The decomp run id the re-derivation ran under
+    op_id: str                                          # The chunk-respine op id (stamped as superseded_by)
+    ts: float                                           # Wall-clock seconds of the landing
+    old_segments: List[str] = field(default_factory=list)   # The superseded segment ids, index order
+    new_segments: List[str] = field(default_factory=list)   # The replacement segment ids, index order
+    stranded: List[str] = field(default_factory=list)   # Dependent Correction ids that stopped projecting (on say-so)
+    carried: List[str] = field(default_factory=list)    # Fresh Correction ids the transfer minted onto the new segments
+    straddles: List[str] = field(default_factory=list)  # New segment ids left unassigned because they straddle two donor speakers (4a7ec4f8 (3))
+
+    def to_dict(self) -> Dict[str, Any]:  # The wire entry
+        """The entry as it rides the Source prop (plain JSON, list order preserved)."""
+        return {"audio_segment": self.audio_segment, "transcript": self.transcript,
+                "run": self.run, "op_id": self.op_id, "ts": self.ts,
+                "old_segments": list(self.old_segments), "new_segments": list(self.new_segments),
+                "stranded": list(self.stranded), "carried": list(self.carried),
+                "straddles": list(self.straddles)}
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "RespinedChunkEntry":  # Parsed entry
+        """Read an entry back off the Source prop (missing lists read empty)."""
+        return cls(audio_segment=str(d.get("audio_segment") or ""),
+                   transcript=str(d.get("transcript") or ""),
+                   run=str(d.get("run") or ""), op_id=str(d.get("op_id") or ""),
+                   ts=float(d.get("ts") or 0.0),
+                   old_segments=[str(s) for s in (d.get("old_segments") or [])],
+                   new_segments=[str(s) for s in (d.get("new_segments") or [])],
+                   stranded=[str(s) for s in (d.get("stranded") or [])],
+                   carried=[str(s) for s in (d.get("carried") or [])],
+                   straddles=[str(s) for s in (d.get("straddles") or [])])
+
+
 def normalize_collection_title(
     title: str,  # Raw title (folder name, user input, ...)
 ) -> str:  # Normalized identity form

{cjm_transcript_graph_schema-0.0.8 → cjm_transcript_graph_schema-0.0.11/cjm_transcript_graph_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-graph-schema
-Version: 0.0.8
+Version: 0.0.11
 Summary: Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcript, and Segment nodes with deterministic identity tuples and graph-node mapping, shared by the transcription, decomposition, and correction workflow cores.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -32,6 +32,7 @@ Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcri
 - `AudioRenditionNode` _class_ — A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
 - `AudioSegmentNode` _class_ — Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
 - `CollectionNode` _class_ — An intrinsic collection (book, podcast series, lecture course) — the
+- `RespinedChunkEntry` _class_ — One chunk respine as the Source records it (0b4d5cfa (4)): the entry the
 - `SegmentNode` _class_ — Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
 - `SourceNode` _class_ — The provenance root: one ingested media file.
 - `TranscriptGraphLabels` _class_ — Node labels of the audio-transcript layer schema.

{cjm_transcript_graph_schema-0.0.8 → cjm_transcript_graph_schema-0.0.11}/tests/test_schema.py

@@ -174,3 +174,118 @@ def test_collection_identity_wire_shape_and_edges():
     # late-added member attaches to the SAME node without touching the chain
     late = collection_edges(cid, [source_node_id("sha256:ch2.5")])
     assert late[0]["relation_type"] == "PART_OF" and late[0]["target_id"] == cid
+
+
+def test_segment_skeleton_hash_prop_and_split_policy():
+    # Every new commit records its skeleton identity input as a QUERYABLE prop
+    # (spine-scoped reads filter on it; legacy nodes lack it entirely).
+    seg = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                      chunk_end=2.0, index=0, start_time=1.0, end_time=2.0, text="hi")
+    props = seg.to_graph_node()["properties"]
+    assert props["skeleton_hash"] == "sha256:skel"
+    assert "split_policy" not in props, "no split stage -> no split_policy prop"
+
+    split = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel2", chunk_start=1.0,
+                        chunk_end=1.6, index=0, start_time=1.0, end_time=1.6, text="hi",
+                        split_policy="sentence-split/v1")
+    sprops = split.to_graph_node()["properties"]
+    assert sprops["skeleton_hash"] == "sha256:skel2"
+    assert sprops["split_policy"] == "sentence-split/v1"
+
+    # split_policy is METADATA, never an identity input — the id stays a pure
+    # function of (rendition, skeleton hash, chunk range).
+    a = SegmentNode(rendition=R_RAW, vad_config_hash="h", chunk_start=1.0, chunk_end=2.0,
+                    index=0, start_time=1.0, end_time=2.0)
+    b = SegmentNode(rendition=R_RAW, vad_config_hash="h", chunk_start=1.0, chunk_end=2.0,
+                    index=0, start_time=1.0, end_time=2.0, split_policy="sentence-split/v1")
+    assert a.id == b.id
+    # ...while the skeleton hash itself DOES fork identity (parallel spines
+    # coexist because no node id is shared across skeletons).
+    c = SegmentNode(rendition=R_RAW, vad_config_hash="h2", chunk_start=1.0, chunk_end=2.0,
+                    index=0, start_time=1.0, end_time=2.0)
+    assert c.id != a.id
+
+
+def test_transcript_supersedes_edge_external_identity_and_operator_attribution():
+    """cf0b91d6 / ruling 910f3692: a re-run's new variant SUPERSEDES the prior variant for
+    the same (rendition, transcriber) with a deterministic edge id and refuses a self-edge;
+    an EXTERNAL landing files under `<model id>/manual` with a config hash derived from
+    (model id, prompt hash) — a different prompt is a different variant — and carries the
+    OPERATOR as actor (default attribution stays capability:<transcriber>/transcribe)."""
+    import pytest
+    from cjm_transcript_graph_schema.schema import (EXTERNAL_TRANSCRIBER_MARKER, external_config_hash,
+                                                    external_transcriber_name)
+
+    old = TranscriptNode(rendition=R_RAW, transcriber="voxtral", config_hash="cfg-old",
+                         text="some some some", audio_hash="sha256:wav0")
+    new = TranscriptNode(rendition=R_RAW, transcriber="voxtral", config_hash="cfg-new",
+                         text="the good prefix", audio_hash="sha256:wav0")
+    assert old.id != new.id
+    e = new.supersedes_edge(old.id)
+    assert (e["source_id"], e["target_id"], e["relation_type"]) == (new.id, old.id, "SUPERSEDES")
+    assert e["id"] == new.supersedes_edge(old.id)["id"], "deterministic edge id"
+    with pytest.raises(ValueError):
+        new.supersedes_edge(new.id)
+    # External landing identity.
+    name = external_transcriber_name("gemini-2.5-pro")
+    assert name == "gemini-2.5-pro" + EXTERNAL_TRANSCRIBER_MARKER == "gemini-2.5-pro/manual"
+    with pytest.raises(ValueError):
+        external_transcriber_name("  ")
+    h1 = external_config_hash("gemini-2.5-pro", "sha256:prompt-a")
+    h2 = external_config_hash("gemini-2.5-pro", "sha256:prompt-b")
+    assert h1.startswith("sha256:") and h1 != h2
+    assert h1 == external_config_hash("gemini-2.5-pro", "sha256:prompt-a"), "deterministic"
+    ext = TranscriptNode(rendition=R_RAW, transcriber=name, config_hash=h1, text="NCCL, not nickel",
+                         audio_hash="sha256:wav0", actor="human:operator", method="external-landing")
+    en = ext.to_graph_node()
+    assert en["id"] == transcript_node_id(R_RAW, name, h1)
+    assert en["properties"]["actor"] == "human:operator" and en["properties"]["method"] == "external-landing"
+    # The default attribution is unchanged for capability runs.
+    assert new.to_graph_node()["properties"]["actor"] == "capability:voxtral"
+    assert new.to_graph_node()["properties"]["method"] == "transcribe"
+
+
+def test_segment_identity_salt_and_superseded_by_respine_props():
+    """0b4d5cfa (3)/(4), schema 0.0.11: a chunk respine forks Segment identity through
+    `identity_salt` ONLY — the skeleton_hash prop stays the live spine's, so no reader
+    splits the spine; the salt is the landed Transcript id, so the same landing twice
+    collides into the same id (idempotent) and a different landing mints fresh ids.
+    `superseded_by` rides as a prop only when set (live segments carry none)."""
+    from cjm_transcript_graph_schema.schema import (RESPINE_OP_VERB, SEGMENT_SUPERSEDED_BY_PROP,
+                                                    SOURCE_RESPINED_CHUNKS_PROP, RespinedChunkEntry)
+
+    live = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                       chunk_end=2.0, index=7, start_time=301.0, end_time=302.0, text="hi")
+    t_a = transcript_node_id(R_RAW, "gemini-3.8-flash/manual", "sha256:cfg-a")
+    t_b = transcript_node_id(R_RAW, "gemini-3.8-flash/manual", "sha256:cfg-b")
+    salted = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                         chunk_end=2.0, index=7, start_time=301.0, end_time=302.0, text="hi",
+                         identity_salt=t_a)
+    again = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                        chunk_end=2.0, index=7, start_time=301.0, end_time=302.0, text="hi",
+                        identity_salt=t_a)
+    other = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                        chunk_end=2.0, index=7, start_time=301.0, end_time=302.0, text="hi",
+                        identity_salt=t_b)
+    assert live.id == segment_node_id(R_RAW, "sha256:skel", 1.0, 2.0), "pre-salt ids unchanged"
+    assert live.id == segment_node_id(R_RAW, "sha256:skel", 1.0, 2.0, identity_salt=None)
+    assert salted.id != live.id and salted.id == again.id and other.id != salted.id
+    assert salted.id == segment_node_id(R_RAW, "sha256:skel", 1.0, 2.0, identity_salt=t_a)
+    lp, sp = live.to_graph_node()["properties"], salted.to_graph_node()["properties"]
+    assert sp["skeleton_hash"] == lp["skeleton_hash"] == "sha256:skel", "the salt never touches the hash"
+    assert sp["identity_salt"] == t_a and "identity_salt" not in lp
+    assert SEGMENT_SUPERSEDED_BY_PROP not in lp and SEGMENT_SUPERSEDED_BY_PROP not in sp
+    old = SegmentNode(rendition=R_RAW, vad_config_hash="sha256:skel", chunk_start=1.0,
+                      chunk_end=2.0, index=7, start_time=301.0, end_time=302.0, text="hi",
+                      superseded_by="op-1")
+    assert old.id == live.id, "superseded_by is a stamp, never identity"
+    assert old.to_graph_node()["properties"][SEGMENT_SUPERSEDED_BY_PROP] == "op-1"
+    # The Source-side record round-trips (missing lists read empty).
+    assert (RESPINE_OP_VERB, SOURCE_RESPINED_CHUNKS_PROP) == ("chunk-respine", "respined_chunks")
+    entry = RespinedChunkEntry(audio_segment=A1, transcript=t_a, run="run-1", op_id="op-1",
+                               ts=1.5, old_segments=[live.id], new_segments=[salted.id],
+                               stranded=["c1"], carried=["c2"], straddles=[salted.id])
+    d = entry.to_dict()
+    assert RespinedChunkEntry.from_dict(d) == entry
+    assert RespinedChunkEntry.from_dict({"audio_segment": A1, "transcript": t_a,
+                                         "run": "r", "op_id": "o", "ts": 2}).stranded == []

cjm_transcript_graph_schema-0.0.8/cjm_transcript_graph_schema/__init__.py

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