audatron 0.2.0__tar.gz → 0.2.2__tar.gz

{audatron-0.2.0/src/audatron.egg-info → audatron-0.2.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: audatron
-Version: 0.2.0
-Summary: audatron — LLM-driven realtime Audacity: natural language drives track editing, noise removal, and mastering, with a headless DSP engine plus auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server.
+Version: 0.2.2
+Summary: audatron — headless, deterministic, provenance-attested LLM-driven Audacity: natural language drives track editing, noise removal, and mastering via a headless DSP engine with closed-loop listening (hear/listen), auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server.
 Author: DREAM PIXELS FORGE
 License: MIT
 Requires-Python: >=3.10
@@ -19,6 +19,11 @@ Requires-Dist: pytest>=8; extra == "test"
 
 # audatron
 
+[![CI](https://github.com/Dream-Pixels-Forge/audatron/actions/workflows/pr-validation.yml/badge.svg)](https://github.com/Dream-Pixels-Forge/audatron/actions)
+[![PyPI version](https://img.shields.io/pypi/v/audatron)](https://pypi.org/project/audatron/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Provenance: SLSA](https://img.shields.io/badge/provenance-SLSA%20attested-brightgreen.svg)](https://pypi.org/project/audatron/)
+
 **Natural-language audio production, mirrored live into Audacity.**
 
 audatron is a realtime, LLM-driven toolchain: you prompt an agent (or any
@@ -47,6 +52,14 @@ watch the edits land on the open project.
    └──────────────────────────────┘
 ```
 
+## Headless by design
+
+No GUI automation, no hidden state: audatron runs its entire DSP pipeline
+headless and deterministically — same input, same calls, same bytes. Every
+release is published to PyPI with SLSA provenance attestations, so what you
+`pip install` is verifiably what CI built. The Audacity bridge writes
+artifacts, not clicks.
+
 ## Install
 
 ```bash
@@ -124,6 +137,54 @@ audatron-mcp        # newline-delimited JSON-RPC 2.0 over stdio
 Wiring it into a coding agent — see **[dev-notes/MCP-SETUP.md](dev-notes/MCP-SETUP.md)** for
 Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 
+## Closed-Loop Listening
+
+audatron's most defensible trait: the agent can **hear the result** of every
+edit and reason from the numbers, instead of declaring success on faith.
+
+```
+   1. inspect ──► 2. edit (trim / noise_reduce / master / …) ──► 3. hear ──► 4. listen again
+                                                            │            verify the region
+                                                            ▼         (silence %, centroid,
+                                                           good?        onsets, peak dB)
+                                                            │
+                                          good → export/sync ──┘
+                                          bad  → undo/redo, retry
+```
+
+- `hear` — a **local, deterministic text-embedding** of a segment (log-mel
+  grid + silence map + onset grid + loudness/centroid). ~400 tokens, no audio
+  input required — works on *any* LLM, including text-only local models.
+- `listen` — a base64 WAV data-URI (16 kHz mono, 20 s cap) for
+  audio-capable backends; `hear` is the text-only fallback.
+
+```python
+from audatron.dsp import load_audio
+from audatron.session import Session
+from audatron.tools import dispatch
+
+s = Session(load_audio("in.wav"), Path("in.wav"))
+before = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0, "detail": "full"})
+dispatch(s, "noise_reduce", {"profile_seconds": 0.5, "strength": 1.0})
+after = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0})
+assert after["silence_pct"] < before["silence_pct"]   # the noise is gone
+```
+
+## How it differs
+
+| | audatron | Audacity-MCP (`xDarkzx/Audacity-MCP`) | cochlea | Ableton MCP (ableton-copilot-mcp) |
+|---|---|---|---|---|
+| GUI automation | no — headless | yes (drives the live Audacity GUI) | no | yes (live Ableton) |
+| Deterministic DSP | yes | n/a (GUI-driven) | yes | n/a |
+| MCP tool surface | yes (`audatron-mcp`) | yes | no | yes |
+| Native Audacity-4 SQLite `.aup3` | yes | n/a | no | n/a |
+| Closed-loop listening (`hear`/`listen`) | yes | no | no | no |
+
+audatron is the only tool in this set that is *headless*, *deterministic*, and
+*augmented with a feedback loop* — the agent verifies every destructive edit
+by hearing the numbers, not by trusting the operation succeeded. (Capability
+claims about competitors are from their public READMEs; verify before citing.)
+
 ## Tool surface
 
 | Tool           | What it does |
@@ -137,14 +198,17 @@ Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 | `master`       | loudness-normalize to target LUFS + peak ceiling |
 | `export`       | write wav / flac / mp3 / ogg |
 | `sync`         | generate the Audacity project + scripts |
-| `history` / `undo` | deck state |
+| `listen`       | WAV data-URI (16 kHz mono, 20 s cap) for audio-capable LLMs |
+| `hear`         | local text-embedding: log-mel + silence + onsets + numbers |
+| `status`       | session overview: stats + paths + sync state + undo depth |
+| `history` / `undo` / `redo` | deck state |
 | `load`         | replace the deck with a new file |
 
 ## Development
 
 ```bash
 pip install -e ".[test]"
-python -m pytest -q          # 102 tests, ~45s
+python -m pytest -q          # 100+ tests, ~45–80s
 ```
 
 Layout:
@@ -160,6 +224,7 @@ src/audatron/
   audacity.py     # .aup3 + TCL/Lua generation + Audacity lookup
   aup3.py        # native Audacity-4 SQLite .aup3 writer
   mcp_server.py   # MCP stdio JSON-RPC server
+  embed.py        # local text-embedding (hear) — log-mel + silence + onsets
   cli.py          # typer CLI
 tests/            # pytest: DSP, tools, agent (mocked), MCP, e2e, CLI, aup3, live
 ```

audatron-0.2.0/PKG-INFO → audatron-0.2.2/README.md

@@ -1,24 +1,10 @@
-Metadata-Version: 2.4
-Name: audatron
-Version: 0.2.0
-Summary: audatron — LLM-driven realtime Audacity: natural language drives track editing, noise removal, and mastering, with a headless DSP engine plus auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server.
-Author: DREAM PIXELS FORGE
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.26
-Requires-Dist: soundfile>=0.12
-Requires-Dist: typer>=0.12
-Requires-Dist: rich>=13
-Requires-Dist: httpx>=0.27
-Requires-Dist: pydub>=0.25
-Provides-Extra: noisereduce
-Requires-Dist: noisereduce>=3.0; extra == "noisereduce"
-Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
-
 # audatron
 
+[![CI](https://github.com/Dream-Pixels-Forge/audatron/actions/workflows/pr-validation.yml/badge.svg)](https://github.com/Dream-Pixels-Forge/audatron/actions)
+[![PyPI version](https://img.shields.io/pypi/v/audatron)](https://pypi.org/project/audatron/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Provenance: SLSA](https://img.shields.io/badge/provenance-SLSA%20attested-brightgreen.svg)](https://pypi.org/project/audatron/)
+
 **Natural-language audio production, mirrored live into Audacity.**
 
 audatron is a realtime, LLM-driven toolchain: you prompt an agent (or any
@@ -47,6 +33,14 @@ watch the edits land on the open project.
    └──────────────────────────────┘
 ```
 
+## Headless by design
+
+No GUI automation, no hidden state: audatron runs its entire DSP pipeline
+headless and deterministically — same input, same calls, same bytes. Every
+release is published to PyPI with SLSA provenance attestations, so what you
+`pip install` is verifiably what CI built. The Audacity bridge writes
+artifacts, not clicks.
+
 ## Install
 
 ```bash
@@ -124,6 +118,54 @@ audatron-mcp        # newline-delimited JSON-RPC 2.0 over stdio
 Wiring it into a coding agent — see **[dev-notes/MCP-SETUP.md](dev-notes/MCP-SETUP.md)** for
 Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 
+## Closed-Loop Listening
+
+audatron's most defensible trait: the agent can **hear the result** of every
+edit and reason from the numbers, instead of declaring success on faith.
+
+```
+   1. inspect ──► 2. edit (trim / noise_reduce / master / …) ──► 3. hear ──► 4. listen again
+                                                            │            verify the region
+                                                            ▼         (silence %, centroid,
+                                                           good?        onsets, peak dB)
+                                                            │
+                                          good → export/sync ──┘
+                                          bad  → undo/redo, retry
+```
+
+- `hear` — a **local, deterministic text-embedding** of a segment (log-mel
+  grid + silence map + onset grid + loudness/centroid). ~400 tokens, no audio
+  input required — works on *any* LLM, including text-only local models.
+- `listen` — a base64 WAV data-URI (16 kHz mono, 20 s cap) for
+  audio-capable backends; `hear` is the text-only fallback.
+
+```python
+from audatron.dsp import load_audio
+from audatron.session import Session
+from audatron.tools import dispatch
+
+s = Session(load_audio("in.wav"), Path("in.wav"))
+before = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0, "detail": "full"})
+dispatch(s, "noise_reduce", {"profile_seconds": 0.5, "strength": 1.0})
+after = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0})
+assert after["silence_pct"] < before["silence_pct"]   # the noise is gone
+```
+
+## How it differs
+
+| | audatron | Audacity-MCP (`xDarkzx/Audacity-MCP`) | cochlea | Ableton MCP (ableton-copilot-mcp) |
+|---|---|---|---|---|
+| GUI automation | no — headless | yes (drives the live Audacity GUI) | no | yes (live Ableton) |
+| Deterministic DSP | yes | n/a (GUI-driven) | yes | n/a |
+| MCP tool surface | yes (`audatron-mcp`) | yes | no | yes |
+| Native Audacity-4 SQLite `.aup3` | yes | n/a | no | n/a |
+| Closed-loop listening (`hear`/`listen`) | yes | no | no | no |
+
+audatron is the only tool in this set that is *headless*, *deterministic*, and
+*augmented with a feedback loop* — the agent verifies every destructive edit
+by hearing the numbers, not by trusting the operation succeeded. (Capability
+claims about competitors are from their public READMEs; verify before citing.)
+
 ## Tool surface
 
 | Tool           | What it does |
@@ -137,14 +179,17 @@ Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 | `master`       | loudness-normalize to target LUFS + peak ceiling |
 | `export`       | write wav / flac / mp3 / ogg |
 | `sync`         | generate the Audacity project + scripts |
-| `history` / `undo` | deck state |
+| `listen`       | WAV data-URI (16 kHz mono, 20 s cap) for audio-capable LLMs |
+| `hear`         | local text-embedding: log-mel + silence + onsets + numbers |
+| `status`       | session overview: stats + paths + sync state + undo depth |
+| `history` / `undo` / `redo` | deck state |
 | `load`         | replace the deck with a new file |
 
 ## Development
 
 ```bash
 pip install -e ".[test]"
-python -m pytest -q          # 102 tests, ~45s
+python -m pytest -q          # 100+ tests, ~45–80s
 ```
 
 Layout:
@@ -160,6 +205,7 @@ src/audatron/
   audacity.py     # .aup3 + TCL/Lua generation + Audacity lookup
   aup3.py        # native Audacity-4 SQLite .aup3 writer
   mcp_server.py   # MCP stdio JSON-RPC server
+  embed.py        # local text-embedding (hear) — log-mel + silence + onsets
   cli.py          # typer CLI
 tests/            # pytest: DSP, tools, agent (mocked), MCP, e2e, CLI, aup3, live
 ```

{audatron-0.2.0 → audatron-0.2.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "audatron"
-version = "0.2.0"
-description = "audatron — LLM-driven realtime Audacity: natural language drives track editing, noise removal, and mastering, with a headless DSP engine plus auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server."
+version = "0.2.2"
+description = "audatron — headless, deterministic, provenance-attested LLM-driven Audacity: natural language drives track editing, noise removal, and mastering via a headless DSP engine with closed-loop listening (hear/listen), auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }

{audatron-0.2.0 → audatron-0.2.2}/src/audatron/audacity.py

@@ -12,6 +12,7 @@ the waveforms change live.
 from __future__ import annotations
 
 import json
+import numpy as np
 import os
 import re
 import shutil
@@ -149,10 +150,12 @@ def build_project(
     sr: int = 44100,
     duration_s: float = 1.0,
     native: bool = True,
+    extra_tracks: list[tuple[str, Path]] | None = None,
 ) -> Path:
     """Write a minimal .aup3 project + manifest + script files.
 
-    Returns the project directory path.
+    Returns the project directory path. With `extra_tracks` ([(name, wav_path),
+    ...]) the native .aup3 gains one mono track per entry — multitrack sync.
     """
     project_dir.mkdir(parents=True, exist_ok=True)
     name = project_dir.name
@@ -215,6 +218,7 @@ def build_project(
         "sample_rate": sr,
         "duration": duration_s,
         "ops": [{"kind": o.kind, "args": o.args, "track": o.track} for o in ops],
+        "extra_tracks": [n for n, _ in (extra_tracks or [])],
         "tcl": str(project_dir / "audatron.tcl"),
         "lua": str(project_dir / "audatron.lua"),
     }
@@ -225,17 +229,19 @@ def build_project(
     (project_dir / "audatron.lua").write_text(gen_lua(plan))
 
     if native:
-        _write_native(project_dir, src_wav)
+        _write_native(project_dir, src_wav, extra_tracks=extra_tracks)
 
     return project_dir
 
 
-def _write_native(project_dir: Path, src_wav: str) -> Optional[Path]:
+def _write_native(project_dir: Path, src_wav: str,
+                  extra_tracks: list[tuple[str, Path]] | None = None) -> Optional[Path]:
     """Write a native Audacity-4 SQLite .aup3 next to the XML one.
 
     Reads the source WAV, converts to float32, and calls aup3.write_aup3.
-    The native file is `<name>.native.aup3` so it never collides with the
-    XML project. Returns the native path, or None (XML-only) when the WAV
+    With `extra_tracks` the native project is multitrack (one mono track per
+    entry). The native file is `<name>.native.aup3` so it never collides with
+    the XML project. Returns the native path, or None (XML-only) when the WAV
     can't be read - e.g. a manifest build with no source on disk.
     """
     from .dsp import load_audio
@@ -246,7 +252,23 @@ def _write_native(project_dir: Path, src_wav: str) -> Optional[Path]:
         # missing / unreadable WAV: fall back to XML-only project
         return None
     native_path = project_dir / f"{project_dir.name}.native.aup3"
-    _aup3.write_aup3(native_path, audio.samples, audio.sr, track_name=project_dir.name)
+    if extra_tracks:
+        # deck first, then one track per clip — a true timeline in Audacity
+        deck_name = project_dir.name
+        clips: list[tuple[str, np.ndarray]] = [(deck_name, audio.samples)]
+        ok = True
+        for n, w in extra_tracks:
+            try:
+                a = load_audio(w)
+            except Exception:
+                ok = False
+                break
+            clips.append((n, a.samples))
+        if not ok:
+            return None
+        _aup3.write_multitrack_aup3(native_path, clips, audio.sr)
+    else:
+        _aup3.write_aup3(native_path, audio.samples, audio.sr, track_name=project_dir.name)
     return native_path
 
 

{audatron-0.2.0 → audatron-0.2.2}/src/audatron/aup3.py

@@ -172,36 +172,14 @@ def encode_doc(events: list) -> tuple[bytes, bytes, list[str]]:
 
 
 # ---------------------------------------------------------------------------
-# project tree (classic 1.3.0 structure, one mono float32 track)
+# project tree (classic 1.3.0 structure; N mono float32 tracks)
 # ---------------------------------------------------------------------------
 
-def _project_events(
+def _track_events(
     sr: int, track_name: str, block_starts: list[int],
     block_ids: list[int], total_samples: int,
 ) -> list:
     e: list = []
-    e.append(("start", "project", [
-        ("xmlns", "s", "http://audacity.sourceforge.net/xml/"),
-        ("version", "s", "1.3.0"),
-        ("audacityversion", "s", AUDACITY_VERSION),
-        ("rate", "s", str(sr)),
-        ("selectionformat", "s", ""),
-        ("frequencyformat", "s", ""),
-        ("bandwidthformat", "s", ""),
-        ("time_signature_tempo", "s", "120"),
-        ("time_signature_upper", "i", 4),
-        ("time_signature_lower", "i", 4),
-        ("snapto", "s", "off"),
-        ("sel0", "s", "0"),
-        ("sel1", "s", "0"),
-        ("vpos", "i", 0),
-        ("h", "s", "0"),
-        ("zoom", "s", "0"),
-    ]))
-    e.append(("start", "effects", [("active", "b", 1)]))
-    e.append(("end", "effects"))
-    e.append(("start", "tags", []))
-    e.append(("end", "tags"))
     e.append(("start", "wavetrack", [
         ("name", "s", track_name),
         ("channel", "i", 0),
@@ -241,10 +219,79 @@ def _project_events(
     e.append(("start", "envelope", [("numpoints", "i", 0)]))
     e.append(("end", "envelope"))
     e.append(("end", "wavetrack"))
+    return e
+
+
+def _project_events(
+    sr: int, track_name: str, block_starts: list[int],
+    block_ids: list[int], total_samples: int,
+) -> list:
+    # Backward-compat: one mono track (the original single-clip shape).
+    e: list = []
+    e.append(("start", "project", [
+        ("xmlns", "s", "http://audacity.sourceforge.net/xml/"),
+        ("version", "s", "1.3.0"),
+        ("audacityversion", "s", AUDACITY_VERSION),
+        ("rate", "s", str(sr)),
+        ("selectionformat", "s", ""),
+        ("frequencyformat", "s", ""),
+        ("bandwidthformat", "s", ""),
+        ("time_signature_tempo", "s", "120"),
+        ("time_signature_upper", "i", 4),
+        ("time_signature_lower", "i", 4),
+        ("snapto", "s", "off"),
+        ("sel0", "s", "0"),
+        ("sel1", "s", "0"),
+        ("vpos", "i", 0),
+        ("h", "s", "0"),
+        ("zoom", "s", "0"),
+    ]))
+    e.append(("start", "effects", [("active", "b", 1)]))
+    e.append(("end", "effects"))
+    e.append(("start", "tags", []))
+    e.append(("end", "tags"))
+    e += _track_events(sr, track_name, block_starts, block_ids, total_samples)
     e.append(("end", "project"))
     return e
 
 
+def build_doc_multitrack(
+    sr: int, tracks: list[tuple[str, int, list[int], list[int]]],
+) -> tuple[bytes, bytes, list[str]]:
+    """Build (dict_blob, doc_blob, name_pool) for N mono tracks.
+
+    `tracks` is [(track_name, total_samples, block_starts, block_ids), ...].
+    Single-track call shape matches build_doc() exactly.
+    """
+    e: list = []
+    e.append(("start", "project", [
+        ("xmlns", "s", "http://audacity.sourceforge.net/xml/"),
+        ("version", "s", "1.3.0"),
+        ("audacityversion", "s", AUDACITY_VERSION),
+        ("rate", "s", str(sr)),
+        ("selectionformat", "s", ""),
+        ("frequencyformat", "s", ""),
+        ("bandwidthformat", "s", ""),
+        ("time_signature_tempo", "s", "120"),
+        ("time_signature_upper", "i", 4),
+        ("time_signature_lower", "i", 4),
+        ("snapto", "s", "off"),
+        ("sel0", "s", "0"),
+        ("sel1", "s", "0"),
+        ("vpos", "i", 0),
+        ("h", "s", "0"),
+        ("zoom", "s", "0"),
+    ]))
+    e.append(("start", "effects", [("active", "b", 1)]))
+    e.append(("end", "effects"))
+    e.append(("start", "tags", []))
+    e.append(("end", "tags"))
+    for name, total, starts, bids in tracks:
+        e += _track_events(sr, name, starts, bids, total)
+    e.append(("end", "project"))
+    return encode_doc(e)
+
+
 def build_doc(
     sr: int, track_name: str, block_starts: list[int],
     block_ids: list[int], total_samples: int,
@@ -363,26 +410,92 @@ def write_aup3(
 
     dict_b, doc_b, _pool = build_doc(sr, name, starts, block_ids, pos)
 
+    _write_db(p, sr, [(name, pos, starts, block_ids, blocks)], dict_b, doc_b)
+    return p
+
+
+def write_multitrack_aup3(
+    path: str | Path,
+    tracks: list[tuple[str, np.ndarray]],
+    sr: int,
+) -> Path:
+    """Write a native Audacity SQLite project with one mono track per clip.
+
+    `tracks` is [(name, float32_samples), ...]; all clips must share `sr`.
+    Block ids are contiguous across tracks (app convention); sampleblocks
+    rows are inserted in track order. Same framing as write_aup3.
+    """
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    if p.exists():
+        p.unlink()
+    for suffix in ("-wal", "-shm"):
+        stale = p.with_name(p.name + suffix)
+        if stale.exists():
+            stale.unlink()
+
+    per_track = []
+    blocks_by_track: list[list[tuple[int, bytes, np.ndarray]]] = []
+    bid = 1  # contiguous 1-based across tracks
+    for name, s in tracks:
+        chunks = split_sampleblocks(s)  # [(blockid, raw, f32), ...] 1-based
+        starts = []
+        pos = 0
+        renumbered = []
+        for _old_id, raw, chunk in chunks:
+            starts.append(pos)
+            pos += len(chunk)
+            renumbered.append((bid, raw, chunk))
+            bid += 1
+        block_ids = [b[0] for b in renumbered]
+        blocks_by_track.append(renumbered)
+        per_track.append((name, pos, starts, block_ids))
+
+    dict_b, doc_b, _pool = build_doc_multitrack(sr, per_track)
+
+    conn = sqlite3.connect(str(p))
+    cur2 = conn.cursor()
+    cur2.executescript(_SCHEMA)
+    cur2.execute(f"PRAGMA application_id = {APP_ID}")
+    cur2.execute(f"PRAGMA user_version = {USER_VERSION}")
+    cur2.execute("PRAGMA journal_mode = WAL")
+    for blist in blocks_by_track:
+        for _bid, _raw, chunk in blist:
+            _insert_block(cur2, _bid, chunk)
+    _write_db_tail(conn, cur2, dict_b, doc_b)
+    return p
+
+
+def _insert_block(cur, bid: int, chunk: np.ndarray) -> None:
+    f64 = chunk.astype(np.float64)
+    cur.execute(
+        "INSERT INTO sampleblocks (blockid, sampleformat, summin, summax, "
+        "sumrms, summary256, summary64k, samples) "
+        "VALUES (?,?,?,?,?,?,?,?)",
+        (
+            bid, SAMPLE_FORMAT,
+            float(f64.min()), float(f64.max()),
+            float(math.sqrt(float(np.mean(f64 ** 2)))),
+            _summary256(chunk), _summary64k(chunk), chunk.tobytes(),
+        ),
+    )
+
+
+def _write_db(p: Path, sr: int, tracks, dict_b: bytes, doc_b: bytes) -> None:
+    """Shared db body for single-track and multitrack writers."""
     conn = sqlite3.connect(str(p))
     cur = conn.cursor()
     cur.executescript(_SCHEMA)
     cur.execute(f"PRAGMA application_id = {APP_ID}")
     cur.execute(f"PRAGMA user_version = {USER_VERSION}")
     cur.execute("PRAGMA journal_mode = WAL")
+    for _name, _total, _st, bids, blist in tracks:
+        for (_bid, _raw, chunk) in blist:
+            _insert_block(cur, _bid, chunk)
+    _write_db_tail(conn, cur, dict_b, doc_b)
+
 
-    for bid, raw, chunk in blocks:
-        f64 = chunk.astype(np.float64)
-        cur.execute(
-            "INSERT INTO sampleblocks (blockid, sampleformat, summin, summax, "
-            "sumrms, summary256, summary64k, samples) "
-            "VALUES (?,?,?,?,?,?,?,?)",
-            (
-                bid, SAMPLE_FORMAT,
-                float(f64.min()), float(f64.max()),
-                float(math.sqrt(float(np.mean(f64 ** 2)))),
-                _summary256(chunk), _summary64k(chunk), raw,
-            ),
-        )
+def _write_db_tail(conn, cur, dict_b: bytes, doc_b: bytes) -> None:
     cur.execute("INSERT INTO project (id, dict, doc) VALUES (1, ?, ?)",
                 (dict_b, doc_b))
     cur.execute("INSERT INTO project_history (saved_at, dict, doc) VALUES (?,?,?)",
@@ -390,12 +503,13 @@ def write_aup3(
     conn.commit()
     cur.execute("PRAGMA wal_checkpoint(TRUNCATE)")
     conn.close()
-    return p
 
 
 __all__ = [
     "write_aup3",
+    "write_multitrack_aup3",
     "build_doc",
+    "build_doc_multitrack",
     "encode_doc",
     "encode_dict",
     "split_sampleblocks",

{audatron-0.2.0 → audatron-0.2.2}/src/audatron/mcp_server.py

@@ -43,7 +43,7 @@ def _get_session() -> Session:
 # ---------------------------------------------------------------------------
 
 PROTOCOL_VERSION = "2024-11-05"
-SERVER_INFO = {"name": "audatron", "version": "0.2.0", "title": "audatron — LLM-driven realtime Audacity"}
+SERVER_INFO = {"name": "audatron", "version": "0.2.2", "title": "audatron — LLM-driven realtime Audacity"}
 
 
 def _reply(msg_id: Any, result: Any) -> dict:

{audatron-0.2.0 → audatron-0.2.2}/src/audatron/session.py

@@ -13,6 +13,7 @@ from typing import Any, Optional
 
 from .audacity import AudacityOp, build_project, sync_plan
 from .dsp import Audio, master, normalize, noise_reduce, save_audio, trim, gain_db, analyze, inspect, load_audio, audio_data_uri
+import numpy as np
 
 
 @dataclass
@@ -41,6 +42,9 @@ class Session:
     # oldest checkpoints are dropped (their StepResults stay, but undo past
     # them degrades gracefully to "no checkpoint" errors).
     history_limit: int = 32
+    # len(history) captured at the last sync(); status reports "unsynced" when
+    # it no longer matches (None = never synced).
+    synced_history_len: Optional[int] = None
 
     @classmethod
     def new(cls, audio: Audio, src: Path) -> "Session":
@@ -222,35 +226,70 @@ class Session:
         tail = [AudacityOp("export", {"format": fmt, "path": "audatron-out.wav"}, 0)]
         return sync_plan(non_export + tail)
 
-    def sync(self, force: bool = False) -> dict:
+    def sync(self, force: bool = False, clip_indices: list[int] | None = None,
+             clip_paths: list[str] | None = None) -> dict:
         """Persist a clean copy of the deck, then build an Audacity project.
 
-        The project dir contains:
-          - deck.wav        (clean copy of current audio)
-          - <name>.aup3     (Audacity 3.0 project)
-          - audatron.tcl    (generated TCL script)
-          - audatron.lua    (generated Lua script)
-          - audatron.json   (machine-readable manifest)
+        With `clip_indices`, the native .aup3 is multitrack: the current deck
+        is one track plus one track per checkpoint clip (byte-exact history
+        states — a real timeline of the edit, not copies of the same deck).
+        With `clip_paths`, each file (resampled to the deck's sr) becomes one
+        extra track.
         """
         self.scratch.mkdir(parents=True, exist_ok=True)
         deck_wav = self.scratch / "deck.wav"
         save_audio(self.audio, deck_wav, format="wav")
         name = self.src.stem
+        extra_wavs = self._clip_wavs(clip_indices or [])
+        if clip_paths:
+            extra_wavs += self._path_wavs(clip_paths)
+        extra = [(f"clip_{i}", w) for i, w in zip(
+            list(range(len(extra_wavs))), extra_wavs)]
         self.project_dir = build_project(
             self.scratch / f"{name}-proj",
             src_wav=str(deck_wav),
             ops=self.to_ops(),
             sr=self.audio.sr,
             duration_s=self.audio.duration,
+            extra_tracks=extra,
         )
         # Also keep a convenience export of the "current" deck
         save_audio(self.audio, self.scratch / f"{name}-deck.wav", format="wav")
+        self.synced_history_len = len(self.history)
         return {
             "project_dir": str(self.project_dir),
             "deck": str(deck_wav),
             "manifest": str(self.project_dir / "audatron.json"),
+            "multitrack": bool(extra),
         }
 
+    def _clip_wavs(self, indices: list[int]) -> list[Path]:
+        """One WAV per valid checkpoint clip in `history` (deck = current)."""
+        out = []
+        for i in indices:
+            if i < 0 or i >= len(self.history):
+                continue
+            cp = self.history[i].checkpoint
+            if cp is None:  # bounded memory: too-old steps have no audio
+                continue
+            samples, sr = cp
+            wav = self.scratch / f"{self.src.stem}-clip-{i}.wav"
+            save_audio(Audio(samples, sr), wav, format="wav")
+            out.append(wav)
+        return out
+
+    def _path_wavs(self, paths: list[str]) -> list[Path]:
+        """One WAV per `clip_paths` entry, resampled to the deck's sr."""
+        from .dsp import _resample
+        out = []
+        for i, p in enumerate(paths):
+            a = load_audio(p)
+            if a.sr != self.audio.sr:
+                a = Audio(_resample(a.samples, a.sr, self.audio.sr), self.audio.sr)
+            wav = self.scratch / f"{Path(p).stem}-path-{i}.wav"
+            save_audio(a, wav, format="wav")
+            out.append(wav)
+        return out
 
 def _export_ext(history: list[StepResult]) -> str:
     for step in history:

{audatron-0.2.0 → audatron-0.2.2}/src/audatron/tools.py

@@ -74,8 +74,8 @@ def tool_export(session: Session, path: str = "audatron-export.wav", fmt: str |
     return {"ok": True, "step": step.summary, "path": str(p)}
 
 
-def tool_sync(session: Session) -> dict:
-    out = session.sync()
+def tool_sync(session: Session, clip_indices: list[int] | None = None, paths: list[str] | None = None) -> dict:
+    out = session.sync(clip_indices=clip_indices, clip_paths=paths)
     return {"ok": True, **out}
 
 
@@ -107,6 +107,23 @@ def tool_history(session: Session) -> dict:
     return {"steps": [s.__dict__ for s in session.history]}
 
 
+def tool_status(session: Session) -> dict:
+    """One-call project/session overview: audio stats + paths + sync state."""
+    synced = session.synced_history_len is not None
+    unsynced = (not synced) or len(session.history) != session.synced_history_len
+    return {
+        "ok": True,
+        **session.snapshot(),
+        "src": str(session.src),
+        "scratch": str(session.scratch),
+        "project_dir": str(session.project_dir) if session.project_dir else None,
+        "synced": synced,
+        "unsynced_changes": unsynced,
+        "history_steps": len(session.history),
+        "redo_stack": len(session.redo_stack),
+    }
+
+
 def tool_undo(session: Session) -> dict:
     step = session.undo()
     if step is None:
@@ -176,8 +193,11 @@ TOOL_SCHEMAS: list[dict[str, Any]] = [
     },
     {
         "name": "sync",
-        "description": "Generate an Audacity project + TCL/Lua scripts for the current deck.",
-        "parameters": {},
+        "description": "Generate an Audacity project + TCL/Lua scripts for the current deck. Optional clip_indices (0-based history step numbers, from `history`): the native .aup3 becomes multitrack — current deck + one track per checkpoint clip. Optional clip_paths (audio files): one additional track per file.",
+        "parameters": {
+            "clip_indices": {"type": "array", "items": {"type": "integer"}, "default": []},
+            "clip_paths": {"type": "array", "items": {"type": "string"}, "default": []},
+        },
     },
     {
         "name": "listen",
@@ -202,6 +222,11 @@ TOOL_SCHEMAS: list[dict[str, Any]] = [
         "description": "Return the list of steps applied to the deck.",
         "parameters": {},
     },
+    {
+        "name": "status",
+        "description": "Session/project overview in one call: audio stats (sr, duration, peak, loudness), source + scratch paths, last synced project dir, history depth, redo stack, and whether edits are unsynced since the last sync.",
+        "parameters": {},
+    },
     {
         "name": "undo",
         "description": "Restore the audio to its state before the last step (byte-exact checkpoint) and move the step to the redo stack.",
@@ -231,10 +256,11 @@ def dispatch(session: Session, name: str, args: dict[str, Any]) -> dict:
         "noise_reduce": lambda: tool_noise_reduce(session, args.get("profile_seconds", 0.5), args.get("strength", 1.0)),
         "master": lambda: tool_master(session, args.get("target_lufs", -14.0), args.get("true_peak_db", -1.0)),
         "export": lambda: tool_export(session, args.get("path", "audatron-export.wav"), args.get("fmt")),
-        "sync": lambda: tool_sync(session),
+        "sync": lambda: tool_sync(session, args.get("clip_indices") or None, args.get("clip_paths") or None),
         "hear": lambda: tool_hear(session, args.get("start_s", 0.0), args.get("end_s", 0.0), args.get("detail", "full")),
         "listen": lambda: tool_listen(session, args.get("start_s", 0.0), args.get("end_s", 0.0), args.get("max_ms", 20000)),
         "history": lambda: tool_history(session),
+        "status": lambda: tool_status(session),
         "undo": lambda: tool_undo(session),
         "redo": lambda: tool_redo(session),
         "load": lambda: tool_load(session, args.get("path", "")),
@@ -259,6 +285,7 @@ __all__ = [
     "tool_normalize",
     "tool_noise_reduce",
     "tool_redo",
+    "tool_status",
     "tool_sync",
     "tool_trim",
     "tool_undo",

audatron-0.2.0/README.md → audatron-0.2.2/src/audatron.egg-info/PKG-INFO

@@ -1,5 +1,29 @@
+Metadata-Version: 2.4
+Name: audatron
+Version: 0.2.2
+Summary: audatron — headless, deterministic, provenance-attested LLM-driven Audacity: natural language drives track editing, noise removal, and mastering via a headless DSP engine with closed-loop listening (hear/listen), auto-generated Audacity TCL scripts, an agent chat REPL, and an MCP stdio server.
+Author: DREAM PIXELS FORGE
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+Requires-Dist: soundfile>=0.12
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydub>=0.25
+Provides-Extra: noisereduce
+Requires-Dist: noisereduce>=3.0; extra == "noisereduce"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
 # audatron
 
+[![CI](https://github.com/Dream-Pixels-Forge/audatron/actions/workflows/pr-validation.yml/badge.svg)](https://github.com/Dream-Pixels-Forge/audatron/actions)
+[![PyPI version](https://img.shields.io/pypi/v/audatron)](https://pypi.org/project/audatron/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Provenance: SLSA](https://img.shields.io/badge/provenance-SLSA%20attested-brightgreen.svg)](https://pypi.org/project/audatron/)
+
 **Natural-language audio production, mirrored live into Audacity.**
 
 audatron is a realtime, LLM-driven toolchain: you prompt an agent (or any
@@ -28,6 +52,14 @@ watch the edits land on the open project.
    └──────────────────────────────┘
 ```
 
+## Headless by design
+
+No GUI automation, no hidden state: audatron runs its entire DSP pipeline
+headless and deterministically — same input, same calls, same bytes. Every
+release is published to PyPI with SLSA provenance attestations, so what you
+`pip install` is verifiably what CI built. The Audacity bridge writes
+artifacts, not clicks.
+
 ## Install
 
 ```bash
@@ -105,6 +137,54 @@ audatron-mcp        # newline-delimited JSON-RPC 2.0 over stdio
 Wiring it into a coding agent — see **[dev-notes/MCP-SETUP.md](dev-notes/MCP-SETUP.md)** for
 Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 
+## Closed-Loop Listening
+
+audatron's most defensible trait: the agent can **hear the result** of every
+edit and reason from the numbers, instead of declaring success on faith.
+
+```
+   1. inspect ──► 2. edit (trim / noise_reduce / master / …) ──► 3. hear ──► 4. listen again
+                                                            │            verify the region
+                                                            ▼         (silence %, centroid,
+                                                           good?        onsets, peak dB)
+                                                            │
+                                          good → export/sync ──┘
+                                          bad  → undo/redo, retry
+```
+
+- `hear` — a **local, deterministic text-embedding** of a segment (log-mel
+  grid + silence map + onset grid + loudness/centroid). ~400 tokens, no audio
+  input required — works on *any* LLM, including text-only local models.
+- `listen` — a base64 WAV data-URI (16 kHz mono, 20 s cap) for
+  audio-capable backends; `hear` is the text-only fallback.
+
+```python
+from audatron.dsp import load_audio
+from audatron.session import Session
+from audatron.tools import dispatch
+
+s = Session(load_audio("in.wav"), Path("in.wav"))
+before = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0, "detail": "full"})
+dispatch(s, "noise_reduce", {"profile_seconds": 0.5, "strength": 1.0})
+after = dispatch(s, "hear", {"start_s": 0.0, "end_s": 5.0})
+assert after["silence_pct"] < before["silence_pct"]   # the noise is gone
+```
+
+## How it differs
+
+| | audatron | Audacity-MCP (`xDarkzx/Audacity-MCP`) | cochlea | Ableton MCP (ableton-copilot-mcp) |
+|---|---|---|---|---|
+| GUI automation | no — headless | yes (drives the live Audacity GUI) | no | yes (live Ableton) |
+| Deterministic DSP | yes | n/a (GUI-driven) | yes | n/a |
+| MCP tool surface | yes (`audatron-mcp`) | yes | no | yes |
+| Native Audacity-4 SQLite `.aup3` | yes | n/a | no | n/a |
+| Closed-loop listening (`hear`/`listen`) | yes | no | no | no |
+
+audatron is the only tool in this set that is *headless*, *deterministic*, and
+*augmented with a feedback loop* — the agent verifies every destructive edit
+by hearing the numbers, not by trusting the operation succeeded. (Capability
+claims about competitors are from their public READMEs; verify before citing.)
+
 ## Tool surface
 
 | Tool           | What it does |
@@ -118,14 +198,17 @@ Claude Code, Codex, opencode, kimi, qwen-code, and generic MCP clients.
 | `master`       | loudness-normalize to target LUFS + peak ceiling |
 | `export`       | write wav / flac / mp3 / ogg |
 | `sync`         | generate the Audacity project + scripts |
-| `history` / `undo` | deck state |
+| `listen`       | WAV data-URI (16 kHz mono, 20 s cap) for audio-capable LLMs |
+| `hear`         | local text-embedding: log-mel + silence + onsets + numbers |
+| `status`       | session overview: stats + paths + sync state + undo depth |
+| `history` / `undo` / `redo` | deck state |
 | `load`         | replace the deck with a new file |
 
 ## Development
 
 ```bash
 pip install -e ".[test]"
-python -m pytest -q          # 102 tests, ~45s
+python -m pytest -q          # 100+ tests, ~45–80s
 ```
 
 Layout:
@@ -141,6 +224,7 @@ src/audatron/
   audacity.py     # .aup3 + TCL/Lua generation + Audacity lookup
   aup3.py        # native Audacity-4 SQLite .aup3 writer
   mcp_server.py   # MCP stdio JSON-RPC server
+  embed.py        # local text-embedding (hear) — log-mel + silence + onsets
   cli.py          # typer CLI
 tests/            # pytest: DSP, tools, agent (mocked), MCP, e2e, CLI, aup3, live
 ```

{audatron-0.2.0 → audatron-0.2.2}/tests/test_aup3.py

@@ -32,9 +32,11 @@ from audatron.aup3 import (
     SAMPLE_FORMAT,
     XML_PROLOG_RAW,
     build_doc,
+    build_doc_multitrack,
     encode_dict,
     split_sampleblocks,
     write_aup3,
+    write_multitrack_aup3,
 )
 
 AUDACITY4_EXE = r"C:\Program Files\Audacity 4\bin\Audacity4.exe"
@@ -387,6 +389,56 @@ class TestWriteAup3:
         assert wt[2]["name"] == "mydeck"
 
 
+# ---------------------------------------------------------------------------
+# multitrack
+# ---------------------------------------------------------------------------
+
+class TestMultitrack:
+    def _three_clips(self):
+        return [
+            ("deck", _samples(0.4)),
+            ("clip_0", _samples(0.2)),
+            ("clip_1", _samples(0.3)),
+        ]
+
+    def test_doc_has_three_wavetracks(self):
+        d, doc, _pool = build_doc_multitrack(
+            44100, [(n, len(s), [0], [1]) for n, s in self._three_clips()]
+        )
+        _, events = decode_doc_stream(d, doc)
+        wts = [e for e in events if e[0] == "start" and e[1] == "wavetrack"]
+        assert len(wts) == 3
+        assert [w[2]["name"] for w in wts] == ["deck", "clip_0", "clip_1"]
+        # each track: one waveclip, one sequence, one envelope start
+        for w in wts:
+            assert any(e[0] == "start" and e[1] == "waveclip" for e in events)
+            assert any(e[0] == "start" and e[1] == "envelope" for e in events)
+
+    def test_blockids_contiguous_across_tracks(self, tmp_path):
+        s1, s2 = _samples(0.2), _samples(0.3)
+        p = write_multitrack_aup3(tmp_path / "c.aup3", [("a", s1), ("b", s2)], 44100)
+        con = sqlite3.connect(str(p))
+        bids = [r[0] for r in con.execute("SELECT blockid FROM sampleblocks ORDER BY blockid")]
+        con.close()
+        assert bids == list(range(1, len(bids) + 1))
+
+    def test_writes_valid_record_stream(self, tmp_path):
+        p = write_multitrack_aup3(tmp_path / "m.aup3", self._three_clips(), 44100)
+        con = sqlite3.connect(str(p))
+        d, doc = con.execute("SELECT dict, doc FROM project").fetchone()
+        nblocks = con.execute("SELECT count(*) FROM sampleblocks").fetchone()[0]
+        con.close()
+        names, events = decode_doc_stream(d, doc)
+        assert events[0][0] == "raw"  # XML prolog raw records first
+        first_tag = next(e for e in events if e[0] == "start")
+        assert first_tag[1] == "project"
+        assert events[-1] == ("end", "project")
+        # 3 tracks -> >=3 sampleblock rows (20 000/88 200 samples each = 1 block)
+        assert nblocks == 3
+        # every name referenced by the stream exists in the dict pool
+        assert set(names.values())
+
+
 # ---------------------------------------------------------------------------
 # live open in real Audacity 4 (skip-guarded, like the LLM smoke test)
 # ---------------------------------------------------------------------------
@@ -414,3 +466,31 @@ class TestLiveOpen:
         finally:
             proc.terminate()
             proc.wait(timeout=10)
+
+    @pytest.mark.skipif(
+        not Path(AUDACITY4_EXE).exists(),
+        reason="Audacity 4 not installed on this machine",
+    )
+    def test_audacity4_stays_alive_with_multitrack_project(self, tmp_path):
+        from audatron.audacity import running_audacity
+        if running_audacity() is not None:
+            pytest.skip("Audacity already running - single-instance handoff "
+                       "would make the alive-check meaningless")
+        p = write_multitrack_aup3(
+            tmp_path / "multitrack.aup3",
+            [("deck", _samples(1.5)), ("clip_0", _samples(0.8)),
+             ("clip_1", _samples(0.4))],
+            44100,
+        )
+        creationflags = 0x08000000  # CREATE_NO_WINDOW
+        proc = subprocess.Popen(
+            [AUDACITY4_EXE, str(p)],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            creationflags=creationflags,
+        )
+        try:
+            time.sleep(8)
+            assert proc.poll() is None, "Audacity 4 exited while opening multitrack"
+        finally:
+            proc.terminate()
+            proc.wait(timeout=10)

{audatron-0.2.0 → audatron-0.2.2}/tests/test_tools.py

@@ -58,8 +58,56 @@ class TestDispatch:
         s.apply("gain", db=3.0)
         out = dispatch(s, "sync", {})
         assert out["ok"]
+        assert out["multitrack"] is False
         assert __import__("pathlib").Path(out["project_dir"]).exists()
 
+    def test_sync_multitrack_writes_three_tracks(self, tmp_path):
+        import sqlite3
+        s = _deck()
+        s.scratch = tmp_path / "scratch"
+        s.apply("gain", db=3.0)     # history[0] = pre-gain
+        s.apply("gain", db=2.0)     # history[1] = pre-second-gain
+        out = dispatch(s, "sync", {"clip_indices": [0, 1]})
+        assert out["ok"] and out["multitrack"] is True
+        proj = __import__("pathlib").Path(out["project_dir"])
+        native = proj / f"{proj.name}.native.aup3"
+        assert native.exists()
+        con = sqlite3.connect(str(native))
+        d, doc = con.execute("SELECT dict, doc FROM project").fetchone()
+        con.close()
+        from tests.test_aup3 import decode_doc_stream
+        _, events = decode_doc_stream(d, doc)
+        wts = [e for e in events if e[0] == "start" and e[1] == "wavetrack"]
+        # deck + 2 clip tracks
+        assert len(wts) == 3
+        # single-clip sync still works (backward compat)
+        out2 = dispatch(s, "sync", {})
+        assert out2["multitrack"] is False
+
+    def test_sync_multitrack_with_clip_paths(self, tmp_path):
+        import sqlite3
+        import numpy as np
+        from audatron.dsp import save_audio
+        s = _deck()
+        s.scratch = tmp_path / "scratch"
+        s.apply("gain", db=3.0)
+        # a second file at a *different* sample rate, to exercise resampling
+        sr = s.audio.sr
+        other = save_audio(Audio(np.sin(2 * np.pi * 330.0 * np.arange(int(sr * 0.2)) / sr).astype(np.float32), sr),
+                           tmp_path / "other.wav", format="wav")
+        out = dispatch(s, "sync", {"clip_paths": [str(other)]})
+        assert out["ok"] and out["multitrack"] is True
+        proj = __import__("pathlib").Path(out["project_dir"])
+        native = proj / f"{proj.name}.native.aup3"
+        con = sqlite3.connect(str(native))
+        d, doc = con.execute("SELECT dict, doc FROM project").fetchone()
+        con.close()
+        from tests.test_aup3 import decode_doc_stream
+        _, events = decode_doc_stream(d, doc)
+        wts = [e for e in events if e[0] == "start" and e[1] == "wavetrack"]
+        # deck + 1 clip track
+        assert len(wts) == 2
+
     def test_history_and_undo(self):
         s = _deck()
         dispatch(s, "gain", {"db": 3.0})
@@ -68,6 +116,21 @@ class TestDispatch:
         undo = dispatch(s, "undo", {})
         assert undo["ok"] and undo["history"] == 0
 
+    def test_status_tracks_sync_state(self, tmp_path):
+        s = _deck()
+        s.scratch = tmp_path / "scratch"
+        st = dispatch(s, "status", {})
+        assert st["ok"] and st["synced"] is False and st["unsynced_changes"] is True
+        assert st["project_dir"] is None and "src" in st and "loudness_db" in st
+        dispatch(s, "gain", {"db": 3.0})
+        out = dispatch(s, "sync", {})
+        st = dispatch(s, "status", {})
+        assert st["synced"] is True and st["unsynced_changes"] is False
+        assert st["history_steps"] == 1 and st["project_dir"] == out["project_dir"]
+        dispatch(s, "gain", {"db": 1.0})
+        st = dispatch(s, "status", {})
+        assert st["unsynced_changes"] is True
+
 
 class TestToOpsNoGarbage:
     """Regression: StepResult.args must be structured, and to_ops() must never