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

cjm_transcript_decomp_tui/__init__.py

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

cjm_transcript_decomp_tui/app.py

@@ -0,0 +1,487 @@
+"""The decomp-batch TUI: pick transcription runs into an ordered batch, then a
+headless hand-off to the decomp core's batch runner (work item 0ff6bf0f).
+
+v0 is deliberately the analogy's THIN slice: the felt pain was queueing — the
+decomp CLI took one transcription-run manifest per invocation — so the app is
+one selection stage over the run-manifest corpus plus a read-only results
+view; which comparison/inspection views decomp actually needs stays
+demand-driven from real decomp sessions, not mirrored speculatively from the
+transcription TUI. Presentation lessons carried: spans-only Rich styling (base
+styles bleed), no markup parsing of content strings (bare [/] would
+MarkupError), AUTO_FOCUS None so bindings own the keys, one-line listing rows,
+coalesced repaints (kit RepaintThrottle)."""
+
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from cjm_substrate_tui_kit.repaint import RepaintThrottle
+from cjm_substrate_tui_kit.viewport import tail, visible_slice
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Static
+
+from .runs import DecompIndex, group_batches, SourceRunIndex
+
+
+class DecompApp(App):
+    """Decomp-batch setup, v0 thinnest slice: one selection stage over the
+    transcription-run corpus (RUNS), a read-only decomp-results view (RESULTS),
+    then exit with a grouped batch plan.
+
+    RUNS lists the transcription core's own run manifests newest-first; enter
+    toggles a run into the ORDERED batch (the row shows its queue position),
+    t cycles a multi-transcriber run's authoritative text_from (default: the
+    accuracy slot), and the batch panel below previews exactly how many
+    headless invocations the selection folds into — one per distinct
+    text_from, each riding ONE loaded capability stack. The app itself never
+    loads a capability: confirm exits with the plan and the driver hands off
+    to the decomp core's batch CLI, so TUI-queued runs are byte-identical to
+    hand-launched ones. RESULTS reads the decomp core's own manifests back
+    (list -> per-source drill); segment TEXTS live in the graph, not the
+    manifest, so deeper inspection waits for real-session demand.
+    """
+
+    AUTO_FOCUS = None
+
+    CSS = """
+    #main { height: 1fr; }
+    #status { dock: bottom; height: 1; }
+    """
+
+    BINDINGS = [
+        Binding("j", "move(1)", "down"),
+        Binding("down", "move(1)", "down", show=False),
+        Binding("k", "move(-1)", "up"),
+        Binding("up", "move(-1)", "up", show=False),
+        Binding("enter", "select", "pick/open"),
+        Binding("space", "select", "pick", show=False),
+        Binding("t", "cycle_text_from", "text-from"),
+        Binding("v", "results", "decomp runs"),
+        Binding("r", "reload", "reload"),
+        Binding("n", "confirm", "confirm batch"),
+        Binding("b", "back", "back"),
+        Binding("q", "quit_app", "quit"),
+    ]
+
+    REPAINT_INTERVAL = 1 / 30  # Coalescing window: at most ~30 full repaints/s
+
+    def __init__(self, manifests_dir: str,          # Capability manifests directory
+                 *, runs_dir: str = "runs",         # Both cores' cwd-relative manifest dir
+                 sysmon_capability: Optional[str] = None,  # Monitor for GPU attribution (CR-7)
+                 graph_capability: str = "cjm-capability-graph-sqlite",  # Extension target
+                 graph_db_path: Optional[str] = None):     # Caller-wins graph db override
+        super().__init__()
+        self.manifests_dir = manifests_dir
+        self.sysmon_capability = sysmon_capability
+        self.graph_capability = graph_capability
+        self.graph_db_path = graph_db_path
+        self.src_index = SourceRunIndex(runs_dir)
+        self.dec_index = DecompIndex(runs_dir)
+        self.stage = "runs"
+        self.cursor = 0
+        # The batch is keyed by manifest _path (stable across r-reloads, where
+        # a list index would silently re-target after a re-sort).
+        self.picked: List[str] = []
+        self.text_from: Dict[str, str] = {}  # _path -> explicit t-cycle override
+        self._decomp_counts: Dict[str, int] = {}
+        self.results_run: Optional[int] = None  # None = decomp list; else drilled index
+        self.results_cursor = 0
+        self.results_src = 0
+        self.error: Optional[str] = None
+        self.notice: Optional[str] = None
+        self._throttle = RepaintThrottle(self._paint_now, self.set_timer,
+                                         self.REPAINT_INTERVAL)
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="main")
+        yield Static(id="status")
+
+    def on_mount(self) -> None:
+        self._reload_indexes()
+        self._paint()
+
+    def on_resize(self, event) -> None:
+        self._paint()
+
+    # ---- painting (spans only — a base style on a composed row bleeds) ----
+
+    def _paint(self) -> None:
+        """Request a repaint, coalescing bursts (kit RepaintThrottle)."""
+        self._throttle.request()
+
+    def _paint_now(self) -> None:
+        pane = {"runs": self._paint_runs,
+                "results": self._paint_results}[self.stage]()
+        self.query_one("#main", Static).update(pane)
+        status = Text()
+        # Decomp ALWAYS journals — extension IS graph writing — so the chip
+        # shows the target, never a NOT-JOURNALED state (that state cannot
+        # exist for this workflow).
+        status.append(f" graph→{self.graph_capability} ", style="green")
+        if self.graph_db_path:
+            status.append(f"@{tail(self.graph_db_path, 28)} ", style="dim")
+        if self.error:
+            status.append(f" {self.error} ", style="bold red")
+        elif self.notice:
+            status.append(f" {self.notice} ", style="cyan")
+        else:
+            hints = {
+                "runs": "enter/space pick · t text-from · v decomp runs · r reload · n confirm · q quit",
+                "results": ("enter open run · j/k walk · b back · q quit"
+                            if self.results_run is None
+                            else "j/k source · b decomp list · q quit"),
+            }[self.stage]
+            status.append(f" {self.stage.upper()}  ·  {hints}", style="dim")
+        status.truncate(max(20, self.size.width), overflow="ellipsis")
+        self.query_one("#status", Static).update(status)
+
+    def _paint_runs(self) -> Text:
+        # One screen line per listing row (row discipline: wrapped rows eat the
+        # windowing budget); the batch panel keeps a fixed tail below the list.
+        width = max(20, self.size.width)
+        out = Text()
+        runs = self.src_index.runs
+        out.append(f" Transcription runs ({len(runs)})  ·  {self.src_index.runs_dir}/\n\n",
+                   style="bold")
+        if not runs:
+            out.append("   (no transcription run manifests found — confirmed "
+                       "transcription runs land here)\n", style="dim")
+        batches = self._batches()
+        panel = (2 + len(batches)) if self.picked else 0
+        self.cursor = max(0, min(self.cursor, max(0, len(runs) - 1)))
+        # Detail region (614dd647): up to 4 source rows + the graph-db line.
+        detail = (min(4, len(runs[self.cursor].get("sources") or [])) + 3) if runs else 0
+        budget = max(3, max(4, self.size.height - 1) - 4 - panel - detail)
+        start, end, above, below = visible_slice(len(runs), self.cursor, budget)
+        if above:
+            out.append(f"   … {above} above\n", style="dim")
+        picked_set = set(self.picked)
+        for i in range(start, end):
+            m = runs[i]
+            focus = (i == self.cursor)
+            key = m["_path"]
+            line = Text()
+            line.append(" > " if focus else "   ", style="bold cyan" if focus else "dim")
+            if key in picked_set:
+                # Queue position, not just [x]: the batch is ORDERED.
+                line.append(f"[{self.picked.index(key) + 1}] ", style="green")
+            else:
+                line.append("[ ] ", style="dim")
+            when = time.strftime("%Y-%m-%d %H:%M",
+                                 time.localtime(float(m.get("created_at") or 0)))
+            line.append(str(m["run_id"]), style="bold" if focus else "")
+            line.append(f"  {when}  {len(m.get('sources') or [])} src · "
+                        f"{SourceRunIndex.segment_count(m)} seg", style="dim")
+            names = [t.removeprefix("cjm-capability-")
+                     for t in SourceRunIndex.transcribers(m)]
+            if names:
+                line.append("  " + "+".join(names), style="dim")
+            tf = self._resolved_text_from(m)
+            if len(names) > 1 and tf:
+                line.append(f"  tf={tf.removeprefix('cjm-capability-')}",
+                            style="yellow" if key in self.text_from else "dim cyan")
+            n = self._decomp_counts.get(str(Path(key).resolve()), 0)
+            if n:
+                line.append(f"  ·decomp×{n}", style="dim cyan")
+            line.truncate(width, overflow="ellipsis")
+            out.append_text(line)
+            out.append("\n")
+        if below:
+            out.append(f"   … {below} below\n", style="dim")
+        if runs:
+            # Focused-run detail (614dd647): WHAT was transcribed + WHICH graph
+            # it landed in, in-pane — identity must not need a round-trip to
+            # the transcription TUI.
+            focused = runs[self.cursor]
+            out.append("\n")
+            srcs = focused.get("sources") or []
+            for s in srcs[:4]:
+                nm = Path(str(s.get("source_path") or "?")).stem
+                row = Text()
+                row.append(f"   · {nm}", style="bold")
+                row.append(f"  {len(s.get('segments') or [])} seg", style="dim")
+                row.truncate(width, overflow="ellipsis")
+                out.append_text(row)
+                out.append("\n")
+            if len(srcs) > 4:
+                out.append(f"   … {len(srcs) - 4} more source(s)\n", style="dim")
+            db = self._resolved_graph_db(focused)
+            dbline = Text()
+            if db is None:
+                dbline.append("   ⚠ no graph db recorded in this manifest",
+                              style="bold red")
+            elif not Path(db).exists():
+                dbline.append(f"   ⚠ recorded graph db missing on disk: {tail(db, 40)}",
+                              style="bold red")
+            else:
+                dbline.append(f"   graph db: {tail(db, 48)}", style="dim cyan")
+            dbline.truncate(width, overflow="ellipsis")
+            out.append_text(dbline)
+            out.append("\n")
+        if self.picked:
+            out.append(f"\n Batch ({len(self.picked)} run(s) -> {len(batches)} "
+                       f"invocation(s)):\n", style="bold")
+            for bi, ((tf, db), paths) in enumerate(batches):
+                short = (tf or "?").removeprefix("cjm-capability-")
+                line = Text()
+                line.append(f"   {bi + 1}. text-from {short}", style="green")
+                if db is None:
+                    line.append("  ⚠ no graph db recorded", style="bold red")
+                elif not Path(db).exists():
+                    line.append(f"  ⚠ db missing: {tail(db, 24)}", style="bold red")
+                else:
+                    line.append(f"  db {tail(db, 24)}", style="dim")
+                line.append(": ", style="green")
+                line.append(", ".join(self._run_id_for(p) for p in paths), style="dim")
+                line.truncate(width, overflow="ellipsis")
+                out.append_text(line)
+                out.append("\n")
+        return out
+
+    def _paint_results(self) -> Text:
+        width = max(20, self.size.width)
+        out = Text()
+        runs = self.dec_index.runs
+        if self.results_run is None:
+            out.append(f" Decomp runs ({len(runs)})  ·  {self.dec_index.runs_dir}/\n\n",
+                       style="bold")
+            if not runs:
+                out.append("   (no decomp manifests found — batch hand-offs land here)\n",
+                           style="dim")
+            budget = max(3, max(4, self.size.height - 1) - 4)
+            start, end, above, below = visible_slice(len(runs), self.results_cursor,
+                                                     budget)
+            if above:
+                out.append(f"   … {above} above\n", style="dim")
+            for i in range(start, end):
+                m = runs[i]
+                focus = (i == self.results_cursor)
+                line = Text()
+                line.append(" > " if focus else "   ",
+                            style="bold cyan" if focus else "dim")
+                when = time.strftime("%Y-%m-%d %H:%M",
+                                     time.localtime(float(m.get("created_at") or 0)))
+                srcs = m.get("sources") or []
+                segs = sum(int(s.get("segment_count") or 0) for s in srcs)
+                line.append(str(m["run_id"]), style="bold" if focus else "")
+                line.append(f"  {when}  {len(srcs)} source(s) · {segs} seg", style="dim")
+                tf = (m.get("config") or {}).get("text_from")
+                if tf:
+                    line.append(f"  tf={str(tf).removeprefix('cjm-capability-')}",
+                                style="dim cyan")
+                line.truncate(width, overflow="ellipsis")
+                out.append_text(line)
+                out.append("\n")
+            if below:
+                out.append(f"   … {below} below\n", style="dim")
+            return out
+        m = runs[self.results_run]
+        header = Text()
+        header.append(f" {m['run_id']}", style="bold")
+        src_manifest = m.get("source_manifest")
+        if src_manifest:
+            header.append(f"   <- {tail(str(src_manifest), 48)}", style="dim")
+        header.truncate(width, overflow="ellipsis")
+        out.append_text(header)
+        out.append("\n\n")
+        srcs = m.get("sources") or []
+        if not srcs:
+            out.append("   (no sources extended — the run failed or was aborted "
+                       "before its first commit)\n", style="dim")
+        budget = max(3, max(4, self.size.height - 1) - 4)
+        self.results_src = max(0, min(self.results_src, max(0, len(srcs) - 1)))
+        start, end, above, below = visible_slice(len(srcs), self.results_src, budget)
+        if above:
+            out.append(f"   … {above} above\n", style="dim")
+        for i in range(start, end):
+            s = srcs[i]
+            focus = (i == self.results_src)
+            line = Text()
+            line.append(" > " if focus else "   ",
+                        style="bold cyan" if focus else "dim")
+            line.append(str(s.get("title") or "?"), style="bold" if focus else "")
+            line.append(f"  {int(s.get('segment_count') or 0)} fine segment(s)",
+                        style="dim")
+            node = str(s.get("source_node_id") or "")
+            if node:
+                line.append(f"  Source {node[:8]}…", style="dim cyan")
+            line.truncate(width, overflow="ellipsis")
+            out.append_text(line)
+            out.append("\n")
+        if below:
+            out.append(f"   … {below} below\n", style="dim")
+        return out
+
+    # ---- selection state helpers (pure reads over the indexes) ----
+
+    def _run_by_path(self, key: str) -> Optional[Dict[str, Any]]:
+        """The loaded transcription manifest at a _path key (None after eviction)."""
+        for m in self.src_index.runs:
+            if m["_path"] == key:
+                return m
+        return None
+
+    def _run_id_for(self, key: str) -> str:
+        m = self._run_by_path(key)
+        return str(m["run_id"]) if m else Path(key).stem
+
+    def _resolved_text_from(self, m: Dict[str, Any]) -> Optional[str]:
+        """Effective authority pick: the operator's t-cycle override, else the
+        convention default (sole transcriber / the accuracy slot)."""
+        return (self.text_from.get(m["_path"])
+                or SourceRunIndex.default_text_from(m))
+
+    def _resolved_graph_db(self, m: Dict[str, Any]) -> Optional[str]:
+        """Effective graph db for one run: the explicit override (flag/state)
+        wins, else the db the run RECORDED writing to (e087d059 — provenance-
+        following, never the decomp stack's own configured default)."""
+        return (self.graph_db_path
+                or SourceRunIndex.recorded_graph_db(m, self.graph_capability))
+
+    def _batches(self) -> List[Tuple[Tuple[Optional[str], Optional[str]], List[str]]]:
+        """The hand-off fold: key = (text_from, graph_db_path) — everything
+        that applies invocation-wide on the core CLI."""
+        picks: List[Tuple[str, Tuple[Optional[str], Optional[str]]]] = []
+        for key in self.picked:
+            m = self._run_by_path(key)
+            if m is not None:
+                picks.append((key, (self._resolved_text_from(m),
+                                    self._resolved_graph_db(m))))
+        return group_batches(picks)
+
+    def _reload_indexes(self) -> None:
+        self.src_index.load()
+        self.dec_index.load()
+        self._decomp_counts = self.dec_index.counts_by_source_manifest()
+        # A reload may evict manifests the batch still names; drop those picks
+        # rather than hand off paths the core would refuse.
+        self.picked = [p for p in self.picked if self._run_by_path(p) is not None]
+
+    # ---- stage actions (single key vocabulary, stage-dispatched) ----
+
+    def action_move(self, delta: int) -> None:
+        if self.stage == "runs":
+            if self.src_index.runs:
+                self.cursor = max(0, min(self.cursor + delta,
+                                         len(self.src_index.runs) - 1))
+        elif self.results_run is None:
+            if self.dec_index.runs:
+                self.results_cursor = max(0, min(self.results_cursor + delta,
+                                                 len(self.dec_index.runs) - 1))
+        else:
+            srcs = self.dec_index.runs[self.results_run].get("sources") or []
+            if srcs:
+                self.results_src = max(0, min(self.results_src + delta,
+                                              len(srcs) - 1))
+        self._paint()
+
+    def on_mouse_scroll_down(self, event) -> None:
+        """Wheel = the j/k cursor walk (transcription-TUI drive-2 lesson)."""
+        self.action_move(1)
+
+    def on_mouse_scroll_up(self, event) -> None:
+        self.action_move(-1)
+
+    def action_select(self) -> None:
+        if self.stage == "runs":
+            runs = self.src_index.runs
+            if not runs:
+                return
+            m = runs[self.cursor]
+            if not SourceRunIndex.transcribers(m):
+                # The core would refuse it at run time ("no transcribers");
+                # surfacing that at PICK time keeps the batch hand-off clean.
+                self.error = f"{m['run_id']}: manifest lists no transcribers"
+                self._paint()
+                return
+            key = m["_path"]
+            if key in self.picked:
+                self.picked.remove(key)
+            else:
+                self.picked.append(key)
+            self.error = None
+        elif self.results_run is None and self.dec_index.runs:
+            self.results_run = self.results_cursor
+            self.results_src = 0
+        self._paint()
+
+    def action_cycle_text_from(self) -> None:
+        """Cycle the focused run's authoritative transcriber (t).
+
+        Only multi-transcriber runs have a choice to make — the layer-0 text
+        the fine spine commits comes from exactly one of them (--text-from),
+        so the pick belongs HERE, per run, not as one flag over the batch;
+        grouping folds equal picks back into shared invocations."""
+        if self.stage != "runs" or not self.src_index.runs:
+            return
+        m = self.src_index.runs[self.cursor]
+        ts = SourceRunIndex.transcribers(m)
+        if len(ts) < 2:
+            self.notice = "single-transcriber run — text-from is its sole transcriber"
+            self._paint()
+            return
+        cur = self._resolved_text_from(m)
+        nxt = ts[(ts.index(cur) + 1) % len(ts)] if cur in ts else ts[-1]
+        self.text_from[m["_path"]] = nxt
+        self.notice = None
+        self._paint()
+
+    def action_results(self) -> None:
+        """Open the decomp-runs view (v): re-reads the manifests so a batch
+        that just finished in another terminal shows without a restart."""
+        if self.stage != "runs":
+            return
+        self.notice = None
+        self.error = None
+        self._reload_indexes()
+        self.results_run = None
+        self.results_cursor = 0
+        self.stage = "results"
+        self._paint()
+
+    def action_reload(self) -> None:
+        if self.stage != "runs":
+            return
+        self._reload_indexes()
+        self.notice = (f"reloaded: {len(self.src_index.runs)} transcription / "
+                       f"{len(self.dec_index.runs)} decomp run(s)")
+        self._paint()
+
+    def action_back(self) -> None:
+        if self.stage == "results":
+            if self.results_run is not None:
+                self.results_run = None  # drilled run -> back to the decomp list
+            else:
+                self.stage = "runs"
+        self._paint()
+
+    def action_confirm(self) -> None:
+        if self.stage != "runs":
+            return
+        if not self.picked:
+            self.error = "pick at least one transcription run first"
+            self._paint()
+            return
+        for (tf, db), paths in self._batches():
+            if db is None:
+                # Proceeding without a db is the guaranteed-wrong-graph failure
+                # the first drive hit (e087d059) — block, don't warn.
+                self.error = (f"no graph db recorded for {self._run_id_for(paths[0])} "
+                              "— pass --graph-db-path to override")
+                self._paint()
+                return
+        self.exit({
+            "batches": [{"text_from": tf, "graph_db_path": db,
+                         "manifests": list(paths)}
+                        for (tf, db), paths in self._batches()],
+            "runs_dir": str(self.src_index.runs_dir),
+            "manifests_dir": self.manifests_dir,
+            "sysmon_capability": self.sysmon_capability,
+            "graph_capability": self.graph_capability,
+            "graph_db_path": self.graph_db_path,
+        })
+
+    def action_quit_app(self) -> None:
+        self.exit(None)

cjm_transcript_decomp_tui/cli.py

@@ -0,0 +1,142 @@
+"""The console-script driver: run the batch-selection TUI, then hand each
+text-from group to the HEADLESS decomp core CLI in-process (terminal restored
+first). Every group's equivalent cjm-transcript-decomp-core command prints
+before execution — TUI-queued batches stay reproducible by copy-paste — and
+--plan-only stops at the printout."""
+
+import argparse
+import os
+import shlex
+from typing import Any, Dict, List, Optional
+
+from cjm_substrate.core.workspace import resolve_workspace
+from cjm_transcript_decomp_core.cli import main as core_main
+
+from .app import DecompApp
+from .discovery import discover_capability
+from .state import load_state, save_state
+
+
+def build_parser() -> argparse.ArgumentParser:  # Configured CLI parser
+    """The TUI driver's argument surface (batch-setup options + core passthrough)."""
+    p = argparse.ArgumentParser(
+        prog="cjm-transcript-decomp-tui",
+        description="Batch-setup TUI for the headless decomp pipeline: pick "
+                    "transcription runs into an ordered batch (with per-run "
+                    "authoritative-text choices), then hand off to "
+                    "cjm-transcript-decomp-core's batch runner — one loaded "
+                    "capability stack per text-from group.")
+    p.add_argument("--workspace", default=None,
+                   help="Workspace root (5daadfc4; default: CJM_WORKSPACE env, else upward walk "
+                        "from cwd). Supplies runs/manifests defaults and is exported so the "
+                        "core hand-off + capability workers resolve workspace-scoped paths")
+    p.add_argument("--runs-dir", default=None,
+                   help="Run-manifest directory (default: the workspace's runs/ when one is "
+                        "active, else runs/ under the cwd — both cores' legacy default)")
+    p.add_argument("--manifests-dir", default=None,
+                   help="Capability manifests directory (default: the workspace's "
+                        ".cjm/manifests when one is active, else .cjm/manifests under the cwd)")
+    p.add_argument("--vad-capability", default="cjm-capability-silero-vad",
+                   help="VAD capability name (forwarded to the core)")
+    p.add_argument("--fa-capability", default="cjm-capability-qwen3-forced-aligner",
+                   help="Forced-alignment capability name (forwarded to the core)")
+    p.add_argument("--graph-capability", default="cjm-capability-graph-sqlite",
+                   help="Graph-storage capability the fine spine extends "
+                        "(decomp REQUIRES one — there is no unjournaled decomp)")
+    p.add_argument("--graph-db-path", default=None,
+                   help="Explicit graph db path (default: last-used, else the "
+                        "capability's configured db_path)")
+    p.add_argument("--sysmon-capability", default=None,
+                   help="monitor capability for GPU attribution (default: last-used, "
+                        "else auto-discovered from manifests)")
+    p.add_argument("--no-sysmon", action="store_true",
+                   help="Explicitly disable the monitor (overrides state + discovery)")
+    p.add_argument("--language", default="English",
+                   help="Forced-alignment language (forwarded to the core)")
+    p.add_argument("--force", action="store_true",
+                   help="Bypass capability-side caches (forwarded to the core)")
+    p.add_argument("--actor", default=None,
+                   help="Forwarded journal attribution (default: cli:<user>)")
+    p.add_argument("--plan-only", action="store_true",
+                   help="Print each group's equivalent headless command and exit "
+                        "WITHOUT running anything")
+    return p
+
+
+def batch_argv(
+    batch: Dict[str, Any],       # One confirmed group: {"text_from", "graph_db_path", "manifests"}
+    args: argparse.Namespace,    # The TUI's parsed args (passthrough run options)
+    sysmon: Optional[str],       # Resolved monitor capability (None = disabled)
+) -> List[str]:  # cjm-transcript-decomp-core argv (the reproducibility contract)
+    """Render one hand-off group as headless decomp-core argv.
+
+    Everything the TUI decided (the ordered member manifests, the group's
+    authoritative transcriber, the group's graph db — the one the SOURCE runs
+    recorded writing to, e087d059) plus everything it merely passes through
+    (capabilities, language, force, sysmon, actor) lands in ONE argv — printed
+    before execution so any TUI-queued batch can be replayed by hand.
+    --output-dir pins decomp manifests to the SAME runs dir the TUI browsed
+    (7dfd1177: cwd-relative output blinded the results view and the coverage
+    chips).
+    """
+    argv = ["run", *batch["manifests"], "--yes",
+            "--manifests-dir", args.manifests_dir,
+            "--vad-capability", args.vad_capability,
+            "--fa-capability", args.fa_capability,
+            "--graph-capability", args.graph_capability,
+            "--language", args.language,
+            "--output-dir", args.runs_dir]
+    if batch.get("text_from"):
+        argv += ["--text-from", batch["text_from"]]
+    if batch.get("graph_db_path"):
+        argv += ["--graph-db-path", batch["graph_db_path"]]
+    if sysmon:
+        argv += ["--sysmon-capability", sysmon]
+    if args.force:
+        argv += ["--force"]
+    if args.actor:
+        argv += ["--actor", args.actor]
+    return argv
+
+
+def main() -> int:  # Console-script entry point (cjm-transcript-decomp-tui)
+    """Resolve settings (flags > persisted state > manifest discovery), run the
+    batch app, persist the confirmed choices, then print + run each group."""
+    args = build_parser().parse_args()
+    # 5daadfc4 workspace: resolve before anything reads paths; export so the
+    # in-process core hand-off + capability workers are workspace-scoped.
+    ws = resolve_workspace(explicit=args.workspace)
+    if ws is not None:
+        os.environ["CJM_WORKSPACE"] = str(ws.root)
+    if args.manifests_dir is None:
+        args.manifests_dir = (str(ws.substrate_data_dir / "manifests")
+                              if ws is not None else ".cjm/manifests")
+    if args.runs_dir is None:
+        args.runs_dir = str(ws.runs_dir) if ws is not None else "runs"
+    state = load_state(args.manifests_dir)
+    sysmon = None if args.no_sysmon else (
+        args.sysmon_capability or state.get("sysmon_capability")
+        or discover_capability(args.manifests_dir, "get_system_status"))
+    graph_db_path = args.graph_db_path or state.get("graph_db_path")
+    app = DecompApp(args.manifests_dir, runs_dir=args.runs_dir,
+                    sysmon_capability=sysmon,
+                    graph_capability=args.graph_capability,
+                    graph_db_path=graph_db_path)
+    plan = app.run()
+    if not plan:
+        print("no batch confirmed")
+        return 0
+    save_state(args.manifests_dir,
+               sysmon_capability=plan["sysmon_capability"],
+               graph_db_path=plan["graph_db_path"])
+    rc = 0
+    for i, batch in enumerate(plan["batches"]):
+        argv = batch_argv(batch, args, plan["sysmon_capability"])
+        print(f"batch {i + 1}/{len(plan['batches'])}: "
+              + shlex.join(["cjm-transcript-decomp-core"] + argv))
+        if args.plan_only:
+            continue
+        # Sequential by design: groups share the GPU; the core loads one stack
+        # per group and its exit code aggregates that group's members.
+        rc = max(rc, int(core_main(argv)))
+    return rc

cjm_transcript_decomp_tui/discovery.py

@@ -0,0 +1,55 @@
+"""Capability-role discovery by manifest surface match — the journaling-by-
+default mechanism (sysmon here; the decomp core REQUIRES its graph capability,
+so only the monitor role auto-discovers). CARRIED COPY of the transcription
+TUI's candidates.py pair, kept deliberately close to verbatim: this second
+consumer is the N=2 promotion signal for cjm-substrate-tui-kit (cross-repo
+move v2 is the vehicle), and a drifted copy would fork the discovery contract
+before the move lands."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def manifests_with_method(
+    manifests_dir: str,  # Capability manifests directory (the core CLI's --manifests-dir)
+    method: str,         # Structural-surface method that identifies the role
+) -> Dict[str, Dict[str, Any]]:  # capability name -> its manifest `code` section
+    """Enumerate installed capabilities whose structural surface lists `method`.
+
+    Capabilities qualify by SURFACE, not by name — the same signal the
+    substrate's adapter auto-binding matches against a task protocol, read
+    cheaply off the manifest json (no worker spawn). Role key in use here:
+    `get_system_status` (system monitor). Adapter unit manifests carry no
+    `code` section and are skipped; unreadable files are skipped rather than
+    failing enumeration.
+    """
+    out: Dict[str, Dict[str, Any]] = {}
+    for f in sorted(Path(manifests_dir).glob("*.json")):
+        try:
+            manifest = json.loads(f.read_text())
+        except (OSError, ValueError):
+            continue
+        code = manifest.get("code") if isinstance(manifest, dict) else None
+        if not isinstance(code, dict):
+            continue
+        methods = ((code.get("structural_surface") or {}).get("methods") or [])
+        if any(m.get("name") == method for m in methods):
+            out[code.get("name") or f.stem] = code
+    return out
+
+
+def discover_capability(
+    manifests_dir: str,  # Capability manifests directory
+    method: str,         # Surface method that identifies the role
+) -> Optional[str]:  # First matching capability name (sorted), or None
+    """Pick a DEFAULT capability for a role by surface match.
+
+    Journaling-by-default's mechanism (transcription-TUI drive-1 finding):
+    when the runtime has a monitor installed, the TUI should use it without
+    being told — forgetting must take an explicit opt-out, not a forgotten
+    flag. Sorted-first keeps the pick deterministic when several qualify; the
+    operator's persisted choice (state.py) wins over discovery.
+    """
+    names = sorted(manifests_with_method(manifests_dir, method))
+    return names[0] if names else None

cjm_transcript_decomp_tui/runs.py

@@ -0,0 +1,174 @@
+"""Run-manifest indexes for the decomp-batch TUI (work item 0ff6bf0f): the
+transcription core's own runs/*.json read into a selectable batch (decomp
+consumes RUN MANIFESTS, not media files), the decomp core's own manifests read
+back as coverage chips + results rows, and the pure grouping fold the confirm
+hand-off uses. Pure logic, Textual-free (the transcription TUI's results.py
+precedent: everything below the paint path tests directly; the app only paints
+it). Both cores share the cwd-relative runs/ default, so the manifest FORMAT
+tag — the manifest-as-interchange contract (CR-20) — is what separates
+transcription runs from decomp runs living in one directory."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from cjm_substrate.core.workspace import resolve_recorded_tree
+
+
+def _load_manifests(
+    runs_dir: Path,   # Directory holding both cores' run manifests
+    format_tag: str,  # Substring the manifest's format tag must carry
+) -> List[Dict[str, Any]]:  # Matching manifest dicts, newest first (+ "_path")
+    """Read every readable manifest in runs_dir whose format tag matches.
+
+    The RunIndex forgiveness contract (transcription TUI results.py): the runs
+    dir is shared ground — unreadable/foreign jsons are skipped, never raised,
+    because one corrupt file must not hide the rest. The format-tag filter is
+    load-bearing here where RunIndex could skip it: BOTH cores write manifests
+    with run_id + sources into the same directory, so shape alone no longer
+    separates them."""
+    rows: List[Dict[str, Any]] = []
+    try:
+        files = sorted(runs_dir.glob("*.json"))
+    except OSError:
+        files = []
+    for f in files:
+        try:
+            # ${WS}/ recorded paths (5daadfc4 rung f) resolve at load,
+            # anchored at the manifest's own location.
+            m = resolve_recorded_tree(json.loads(f.read_text()), f)
+        except (OSError, ValueError):
+            continue
+        if not (isinstance(m, dict) and m.get("run_id")
+                and format_tag in str(m.get("format", ""))
+                and isinstance(m.get("sources"), list)):
+            continue
+        m["_path"] = str(f)
+        rows.append(m)
+    rows.sort(key=lambda m: float(m.get("created_at") or 0.0), reverse=True)
+    return rows
+
+
+class SourceRunIndex:
+    """Transcription-core run manifests — the decomp workflow's SOURCES — plus
+    the per-run facts the batch stage paints: transcriber lists, segment
+    totals, and the authoritative-text default. Reads what the transcription
+    runs wrote, no parallel record (results-layer principle)."""
+
+    FORMAT_TAG = "transcription-core"
+
+    def __init__(self, runs_dir: str = "runs"):  # Both cores' cwd-relative default
+        self.runs_dir = Path(runs_dir)
+        self.runs: List[Dict[str, Any]] = []  # Manifest dicts, newest first (+ "_path")
+
+    def load(self) -> int:  # Number of manifests loaded
+        """(Re)read every readable transcription-run manifest, newest first."""
+        self.runs = _load_manifests(self.runs_dir, self.FORMAT_TAG)
+        return len(self.runs)
+
+    @staticmethod
+    def transcribers(m: Dict[str, Any]) -> List[str]:  # Transcriber instance ids, manifest order
+        """The run's transcriber ids (config snapshot; pre-0.2.0 single-key
+        manifests fold to a one-element list — the pipeline's own tolerance)."""
+        cfg = m.get("config") or {}
+        ids = cfg.get("transcriber_capabilities") or []
+        out = [str(i) for i in ids] if isinstance(ids, list) else []
+        if not out and cfg.get("transcriber_capability"):
+            out = [str(cfg["transcriber_capability"])]
+        return out
+
+    @staticmethod
+    def segment_count(m: Dict[str, Any]) -> int:  # Pipeline segments across all sources
+        """Total pipeline segments in the run (the batch-size signal a row paints)."""
+        return sum(len(s.get("segments") or []) for s in m.get("sources") or [])
+
+    @classmethod
+    def default_text_from(cls, m: Dict[str, Any]) -> Optional[str]:  # Pre-picked authoritative transcriber
+        """The default --text-from pick: the sole transcriber, else the LAST.
+
+        The transcription TUI's confirmed pair lands [lightweight, accuracy],
+        so last = the accuracy model — the natural layer-0 authority. A
+        CONVENTION default only: the row paints it and t cycles it, so a
+        hand-built manifest with a different order is one keypress away."""
+        t = cls.transcribers(m)
+        return t[-1] if t else None
+
+    @staticmethod
+    def recorded_graph_db(
+        m: Dict[str, Any],      # A transcription-run manifest
+        graph_capability: str,  # The graph capability's instance id
+    ) -> Optional[str]:  # The db this run recorded writing to (None = not recorded)
+        """The graph db the transcription run RECORDED writing to.
+
+        The manifest's capabilities block is the provenance (finding e087d059:
+        defaulting to the decomp stack's own configured db pointed the first
+        live batch at the WRONG graph — 'Source root not found'). None means a
+        pre-provenance or unjournaled run: the caller must WARN, never
+        silently default."""
+        cap = (m.get("capabilities") or {}).get(graph_capability) or {}
+        db = cap.get("db_path")
+        return str(db) if db else None
+
+    @staticmethod
+    def source_names(m: Dict[str, Any]) -> List[str]:  # Source display names, manifest order
+        """Path stems of the run's sources (finding 614dd647: a run row must
+        say WHAT was transcribed without a transcription-TUI round-trip)."""
+        return [Path(str(s.get("source_path") or "?")).stem
+                for s in m.get("sources") or []]
+
+
+class DecompIndex:
+    """Decomp-core run manifests read back: coverage chips for the batch stage
+    (which transcription runs already have a decomp run) and the results
+    view's rows. v0 stops at the manifest's own facts — segment TEXTS live in
+    the graph, not the manifest, so deeper inspection views wait for real
+    decomp-session demand (the work item's deliberate unshaping)."""
+
+    FORMAT_TAG = "transcript-decomp-core"
+
+    def __init__(self, runs_dir: str = "runs"):  # Both cores' cwd-relative default
+        self.runs_dir = Path(runs_dir)
+        self.runs: List[Dict[str, Any]] = []  # Manifest dicts, newest first (+ "_path")
+
+    def load(self) -> int:  # Number of manifests loaded
+        """(Re)read every readable decomp-run manifest, newest first."""
+        self.runs = _load_manifests(self.runs_dir, self.FORMAT_TAG)
+        return len(self.runs)
+
+    def counts_by_source_manifest(self) -> Dict[str, int]:
+        """resolved transcription-manifest path -> decomp runs that consumed it.
+
+        Path-keyed and hash-free (the prior-run-chip pattern: browse-time chips
+        must stay cheap); the decomp core records source_manifest RESOLVED, so
+        resolving the browse key on lookup matches regardless of how the runs
+        dir was spelled."""
+        counts: Dict[str, int] = {}
+        for m in self.runs:
+            p = m.get("source_manifest")
+            if p:
+                key = str(Path(p).resolve())
+                counts[key] = counts.get(key, 0) + 1
+        return counts
+
+
+def group_batches(
+    picks: List[Tuple[str, Any]],  # Ordered (manifest_path, hand-off key) selection
+) -> List[Tuple[Any, List[str]]]:  # (key, member paths) per hand-off invocation
+    """Fold an ordered batch selection into headless hand-off groups.
+
+    The key is EVERYTHING that applies invocation-wide on the core CLI —
+    currently (text_from, graph_db_path): --text-from names one authority per
+    invocation, and --graph-db-path points one graph per invocation (finding
+    e087d059 — runs recorded against different dbs must not share a stack
+    config). One core invocation per DISTINCT key is the finest split that
+    keeps the ergonomic win: every manifest in a group rides the SAME loaded
+    capability stack. First-seen order of groups and members preserves the
+    operator's queueing order."""
+    order: List[Any] = []
+    groups: Dict[Any, List[str]] = {}
+    for path, key in picks:
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        groups[key].append(path)
+    return [(key, groups[key]) for key in order]

cjm_transcript_decomp_tui/state.py

@@ -0,0 +1,35 @@
+"""Sidecar TUI state: last-used batch settings persisted across sessions (the
+transcription TUI's state pattern — settings the operator picked once, the
+sysmon choice and the graph db override, must never need retyping). The file
+lives next to the manifests dir (one level up — .cjm/ in practice) so state is
+per-project, not per-user."""
+
+from pathlib import Path
+from typing import Any, Dict
+
+from cjm_substrate_tui_kit.state import SidecarState
+
+STATE_BASENAME = "decomp-tui-state.json"
+
+
+def state_path(
+    manifests_dir: str,  # Capability manifests directory (the state key)
+) -> Path:  # The sidecar state file (manifests dir's PARENT — .cjm/ in practice)
+    """Where this project's TUI state lives."""
+    return Path(manifests_dir).resolve().parent / STATE_BASENAME
+
+
+def load_state(
+    manifests_dir: str,  # Capability manifests directory (the state key)
+) -> Dict[str, Any]:  # Persisted state ({} when absent/unreadable — never raises)
+    """Read this project's persisted TUI state."""
+    return SidecarState(state_path(manifests_dir)).load()
+
+
+def save_state(
+    manifests_dir: str,  # Capability manifests directory (the state key)
+    **updates: Any,      # Keys to merge into the persisted state
+) -> Dict[str, Any]:  # The merged state as written
+    """Merge updates into the persisted state and write it back (best-effort:
+    a read-only location must not break the batch hand-off)."""
+    return SidecarState(state_path(manifests_dir)).save(**updates)

cjm_transcript_decomp_tui-0.0.1.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: cjm-transcript-decomp-tui
+Version: 0.0.1
+Summary: Decomp-batch TUI driver: browse transcription-core run manifests, queue an ordered multi-run batch with per-run authoritative-text picks, then hand off to cjm-transcript-decomp-core's headless batch runner (one capability stack for the whole batch). Born on-graph.
+Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/cj-mills/cjm-transcript-decomp-tui
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: cjm-substrate-tui-kit>=0.0.1
+Requires-Dist: cjm-transcript-decomp-core>=0.0.4
+Requires-Dist: textual
+
+# cjm-transcript-decomp-tui
+
+<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->
+
+Decomp-batch TUI driver for the transcript-decomposition workflow: browse the transcription core's run manifests, queue an ordered multi-run batch with per-run authoritative-text (text-from) picks, preview how the batch folds into headless invocations, then hand off to cjm-transcript-decomp-core's batch runner — one loaded capability stack per text-from group, every run byte-identical to a hand-launched one. Includes a read-only decomp-results view over the decomp core's own manifests.
+
+## Modules
+
+- **`cjm_transcript_decomp_tui.__init__`**
+- **`cjm_transcript_decomp_tui.app`**
+- **`cjm_transcript_decomp_tui.cli`**
+- **`cjm_transcript_decomp_tui.discovery`**
+- **`cjm_transcript_decomp_tui.runs`**
+- **`cjm_transcript_decomp_tui.state`**
+
+## API
+
+### `cjm_transcript_decomp_tui.app`
+
+- `DecompApp` _class_ — Decomp-batch setup, v0 thinnest slice: one selection stage over the
+
+### `cjm_transcript_decomp_tui.cli`
+
+- `batch_argv` _function_ — Render one text-from group as headless decomp-core argv.
+- `build_parser` _function_ — The TUI driver's argument surface (batch-setup options + core passthrough).
+- `main` _function_ — Resolve settings (flags > persisted state > manifest discovery), run the
+
+### `cjm_transcript_decomp_tui.discovery`
+
+- `discover_capability` _function_ — Pick a DEFAULT capability for a role by surface match.
+- `manifests_with_method` _function_ — Enumerate installed capabilities whose structural surface lists `method`.
+
+### `cjm_transcript_decomp_tui.runs`
+
+- `DecompIndex` _class_ — Decomp-core run manifests read back: coverage chips for the batch stage
+- `SourceRunIndex` _class_ — Transcription-core run manifests — the decomp workflow's SOURCES — plus
+- `group_by_text_from` _function_ — Fold an ordered batch selection into headless hand-off groups.
+
+### `cjm_transcript_decomp_tui.state`
+
+- `load_state` _function_ — Read this project's persisted TUI state.
+- `save_state` _function_ — Merge updates into the persisted state and write it back (best-effort:
+- `state_path` _function_ — Where this project's TUI state lives.
+
+## Dependencies
+
+**Depends on:** `cjm-substrate-tui-kit`, `cjm-transcript-decomp-core`, `textual`

cjm_transcript_decomp_tui-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+cjm_transcript_decomp_tui/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+cjm_transcript_decomp_tui/app.py,sha256=ChlobuDFVUMELAyFBc4u70IQ-HaQHJ-pkl7GqMNrf_A,22615
+cjm_transcript_decomp_tui/cli.py,sha256=QbqCin8rXJBPMTd02X664YA8SyhT9CYC7EjZCIaOSg0,7522
+cjm_transcript_decomp_tui/discovery.py,sha256=wIZaLGWwseUy55Srk6Lnd_VPkyF_ZnWTDVHmetHhgmM,2660
+cjm_transcript_decomp_tui/runs.py,sha256=dSUNJWnQv1Se8Wcbv5GrXmOqW2gLMmxT8HwlmP-biHE,8354
+cjm_transcript_decomp_tui/state.py,sha256=V_-y3AzNo_u_Qz-w2z8c2PqTe3NV2VaetVrnzC38lxU,1488
+cjm_transcript_decomp_tui-0.0.1.dist-info/METADATA,sha256=yCzu6e7m5P5sNqAFh6olH3qDk7Ik0alW9m5uhLNzW1w,3188
+cjm_transcript_decomp_tui-0.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+cjm_transcript_decomp_tui-0.0.1.dist-info/entry_points.txt,sha256=iQaZ--Z_KSaz3KbiaA83tHNz8BkIEzpiLGwP-Fo-Fm8,81
+cjm_transcript_decomp_tui-0.0.1.dist-info/top_level.txt,sha256=hYgNb0JTBjPC1hakYL1M__PDNHM85kOaTyNpw2GizWA,26
+cjm_transcript_decomp_tui-0.0.1.dist-info/RECORD,,

cjm_transcript_decomp_tui-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cjm_transcript_decomp_tui-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cjm-transcript-decomp-tui = cjm_transcript_decomp_tui.cli:main

cjm_transcript_decomp_tui-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cjm_transcript_decomp_tui