bindery-cli 0.44.0__tar.gz → 0.45.0__tar.gz

bindery_cli-0.45.0/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: VirInvictus
+liberapay: bdkl

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/.gitignore

@@ -30,3 +30,4 @@ test_facility/*.epub
 venv/
 .venv_ci/
 testing_facility/top500candidates/*.txt
+testing_facility/

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/CLAUDE.md

@@ -14,7 +14,7 @@ Born from the 2026 library audit (see the user memory `calibre-library-epubcheck
 
 - **Minimal Dependencies.** Runtime deps are exactly: `tqdm` (progress/output),
   `vir-tui` (shared TUI rendering) and `cquarry` (read-only Calibre `metadata.db` access,
-  adopted in v0.16.0), pinned as PyPI ranges in pyproject.toml (`vir-tui>=2.2.0`,
+  adopted in v0.16.0), pinned as PyPI ranges in pyproject.toml (`vir-tui>=2.5.0`,
   `cquarry>=1.19.0`); `uv.lock` records the resolved versions. Since v0.40.0 both
   VirInvictus pins carry `; python_version >= '3.14'` markers (every release they
   ship declares requires-python >=3.14) and the package floor is 3.12: a 3.12/3.13
@@ -96,7 +96,7 @@ Born from the 2026 library audit (see the user memory `calibre-library-epubcheck
 - `src/bindery/epub.py`: archive rewrite, NCX uid sync, RepairReport, mismatch detection, and the opt-in structural-repair plumbing (including the CSS precondition scan). Since v0.38.0/v0.39.0 (Phase 16): `generate_container` + the `--fix-container` gateway (insert after mimetype when missing, replace in-loop when stale; constant-epoch timestamp keeps bytes deterministic), `prune_dangling_edges` (prune_missing_manifest_items returns the pruned ids and the edges that pointed at them (spine@toc, media-overlay, fallback, EPUB2 cover meta) are rewritten so pruning cannot manufacture the regression the gate rejects), and `fix_manifest_media_types` (extension map + magic-byte confirmation via a `peek` callable over the open source zip; jpg/png/gif only), and `fix_cover_meta` (the ruling's deterministic half: dangling EPUB2 cover meta re-pointed from the guide's cover reference when exactly one manifest item carries that file, removed otherwise; accepted under no_worse like the lossy strips because cover wiring is invisible to epubcheck).
 - `src/bindery/validate.py`: epubcheck wrapper, the `gate` (improvement) and `no_worse` (no-regression, for the lossy strips) acceptance bars.
 - `src/bindery/library.py`: Calibre walk, atomic replace, backups, and native format installation. Since v0.19.0 `CalibreIdResolver` resolves the book id from `metadata.db` through cquarry (one lazy path→id map per run; since v0.20.0 the map comes from `CalibreDB.format_path_index()`, re-normalized with `resolve().lower()` for the resolver's symlinked-directory and case-insensitive matching); the `(id)` directory-name regex is only the no-catalog fallback. Since v0.24.0 `install_format()` places the repaired file atomically and updates the `data` row through `cquarry.write.WritableCalibreDB` (since v0.31.0 via `set_format`, cquarry 1.17's sanctioned remove+add in one transaction); the external `calibredb` CLI is gone. Since v0.32.0 a guessed id drives a row update only when metadata.db corroborates it (`_verify_guess`: books row exists, file in the book's own directory, catalogued `data.name` when a row exists); anything else saves in place and leaves the catalog untouched: never reintroduce directory-name guessing as the primary source: renamed/mismatched directories would replace the wrong book. Since 2026-09-15 `make_backup` takes the opt-in `--backup-keep N` ring: at most N backup files per book, the author original `.bak` never deleted, newest content at the highest name; default remains an unbounded rotation.
-- `src/bindery/cli.py`: `repair` and `library` subcommands, including `--all` and `--install-to-calibre`; `repair --json` emits the library per-book record vocabulary (2026-09-15); since v0.29.0 also the `run` verbs: `phase1` (pre-import vetting over loose files: the audit battery composed with one gated repair sweep; read-only until `--apply-lossy`, which IS the lossy-strip consent) and `phase3` (the scoped post-import apply step: `library --id --sweep --only all --apply --all --install-to-calibre` plus a pre/post summary; mechanically refuses unscoped sweeps with exit 2; since 2026-09-15 the summary sums applied/equal states only and carries rejected projections as `rejected_projection`). Plus `bindery doctor` (2026-09-15): the environment self-check that imports none of the VirInvictus stack, never raises, and always exits 0. Both run verbs take `--non-interactive` and surface open questions as `decisions_needed` in their JSON, never prompts. They drive the shipped `run_library` through the real parser, so no flag can drift between the verb and the subcommand it wraps. `library --workers N` (v0.30.0) parallelizes only the sweep's candidate pass, in windows of N consumed in order so `--limit` stays lazy; the repair phase is never parallel (shared workdir, atomic-replacement contract). Since v0.40.0 `main()` guards the VirInvictus stack: a `ModuleNotFoundError` naming `vir_tui`/`cquarry` (marker-gated to 3.14+ on the 3.12 floor) becomes one stderr line and trouble exit 2 instead of a traceback; anything else missing still raises.
+- `src/bindery/cli.py`: `repair` and `library` subcommands, including `--all` and `--install-to-calibre`; `repair --json` emits the library per-book record vocabulary (2026-09-15; since v0.45.0 every per-book record, the phase1 payload included, also carries the structured fix breakdown: the `fixes` dict plus `ncx_uid_synced`/`watermark_refusals` off the `Outcome`, and `_phase1_decisions` reads that data instead of substring-matching the rendered `summary`, which stays for human eyes; CalibreQuarry's lossy-consent mirror is the waiting consumer, floor `bindery>=0.45.0`); since v0.29.0 also the `run` verbs: `phase1` (pre-import vetting over loose files: the audit battery composed with one gated repair sweep; read-only until `--apply-lossy`, which IS the lossy-strip consent) and `phase3` (the scoped post-import apply step: `library --id --sweep --only all --apply --all --install-to-calibre` plus a pre/post summary; mechanically refuses unscoped sweeps with exit 2; since 2026-09-15 the summary sums applied/equal states only and carries rejected projections as `rejected_projection`). Plus `bindery doctor` (2026-09-15): the environment self-check that imports none of the VirInvictus stack, never raises, and always exits 0. Both run verbs take `--non-interactive` and surface open questions as `decisions_needed` in their JSON, never prompts. They drive the shipped `run_library` through the real parser, so no flag can drift between the verb and the subcommand it wraps. `library --workers N` (v0.30.0) parallelizes only the sweep's candidate pass, in windows of N consumed in order so `--limit` stays lazy; the repair phase is never parallel (shared workdir, atomic-replacement contract). Since v0.40.0 `main()` guards the VirInvictus stack: a `ModuleNotFoundError` naming `vir_tui`/`cquarry` (marker-gated to 3.14+ on the 3.12 floor) becomes one stderr line and trouble exit 2 instead of a traceback; anything else missing still raises.
 - `plugin/__init__.py` + `scripts/build_plugin.py`: the Bindery Repair Calibre plugin (v0.37.0; identity `Bindery Repair` / `bindery_repair`, approved and built per the scoped spec in roadmap.md Phase 3). The builder vendors `transforms.py`, `epub.py`, `pagination.py`, `watermark.py`, `reserialize.py` byte-identically into the zip (the zip root is a package, so their relative imports resolve unchanged; the suite's drift test pins the equality) with the version tuple substituted from the single-source VERSION; `publish.yml` attaches `BinderyRepair-v<VERSION>.zip` to each release. The plugin runs ONLY the default pass (epubcheck cannot gate inside Calibre), never raises, is byte-idempotent (zero fixes returns the original path), testzip()-verifies its output, logs one line per book, and takes JSON config via `site_customization` (`log`, `log_path`, `max_size_mb` default 150, `epubcheck_path` experimental validation default OFF). Load it in tests through the `tests/test_plugin.py` stubs: the calibre namespace is installed in sys.modules and the package loads with a two-dir `__path__` (plugin dir first, then src/bindery) exactly like calibre's zipplugin loader shape. **Plugin/interpreter compatibility (v0.40.0):** v0.39.0 shipped PEP 758 unparenthesized except tuples, and the plugin died with a bare SyntaxError on every released Calibre (7.x and the whole 8.x series embed Python 3.11, 9.0+ embeds 3.14; from calibre's bypy sources.json, checked against the upstream clone). The core is now grammar-pinned: parenthesized except tuples everywhere, `ruff`'s `target-version = "py312"` pin (inference from requires-python would rewrite the parens back off), `tests/test_version.py`'s parse guard, and CI's `plugin-compat` job byte-compiling the built zip under 3.11/3.12/3.13/3.14. `minimum_calibre_version` is (7, 0, 0): the oldest series whose interpreter CI covers, replacing the hollow (2, 0, 0); `supported_platforms` stays `["linux"]` (developed and tested on Linux only). Any new syntax in the vendored modules must clear the guard before it ships.
 - `tests/`: transforms, end-to-end repair, atomic replace, pagination, watermarks, the audit analyzers (content/pagenumbers/emptytext/ocr/monolithic/completeness, archive integrity, spine classification), the library sweep and `CalibreIdResolver`, validate, reserialize, CLI wiring, the version pin and the syntax-floor grammar guard, and the Calibre plugin (build drift + run behavior under calibre stubs).
 

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bindery-cli
-Version: 0.44.0
+Version: 0.45.0
 Summary: Audit EPUB body text and repair broken EPUBs with deterministic, epubcheck-gated fixes; atomic in-place replacement in a Calibre library.
 Project-URL: Homepage, https://github.com/VirInvictus/bindery-cli
 Project-URL: Repository, https://github.com/VirInvictus/bindery-cli

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/patchnotes.md

@@ -1,4 +1,18 @@
 # bindery-cli Patch Notes
+## v0.45.0 (2026-09-21)
+
+### The structured fix breakdown in the JSON records
+
+* **Every per-book record now carries the fix breakdown as data, not only the rendered `summary` string** (the roadmap box recorded 2026-09-18 from the CalibreQuarry side): `library --json` and `repair --json` records, and the `run phase1`/`phase3` payloads built on them, expose the RepairReport's `fixes` dict plus `ncx_uid_synced` and `watermark_refusals`. Consumers that need to know whether a repair was lossy (CalibreQuarry's lossy-consent mirror) can read fix classes as data instead of substring-matching the flattened `"k:v, k:v"` summary; the summary itself stays rendered for human eyes, byte-identical to before. Purely additive: no existing key changed meaning.
+* **`run phase1`'s own decisions read the data now**: `_phase1_decisions` narrows the `apply_lossy` and `manual_watermark_repair` questions through the structured fields instead of matching summary substrings, and a book whose apply failed mid-run (the ENOSPC-class path) still reports the candidate's real fixes instead of an empty breakdown.
+* CalibreQuarry adoption is a deliberate floor bump: `bindery>=0.45.0`.
+* Suite: 521 -> 524 tests (`TestStructuredFixRecord`, plus the apply-failure and watermark-refusal records updated to the structured shape).
+## v0.44.1 (2026-09-18)
+
+### Doctor names its interpreter
+
+* **`bindery doctor` prints `sys.executable` on its python line**, in the epubcheck line's `version  [path]` shape. The version-only line hid which environment was probed, so an html5lib "not installed" read as wrong when the module sat in the system interpreter: a uv tool venv (`include-system-site-packages = false`) genuinely cannot see system site-packages, and `find_spec` only ever consults the running interpreter. The path makes the install shape self-diagnosing.
+* Repo housekeeping with no runtime effect: `FUNDING.yml` (GitHub Sponsors + Liberapay).
 ## v0.44.0 (2026-09-17)
 
 ### The wave-2 batch: PKG-010 entry renames, the cover and ToC-drift audit slices, and the roman grammar unified

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bindery-cli"
-version = "0.44.0"
+version = "0.45.0"
 description = "Audit EPUB body text and repair broken EPUBs with deterministic, epubcheck-gated fixes; atomic in-place replacement in a Calibre library."
 readme = "README.md"
 classifiers = [

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/roadmap.md

@@ -1950,7 +1950,7 @@ four interpreter families.
       quote skips, well-formed byte-identity, prune spin over the
       truncated-OPF shape). Never a third grammar copy.)*
 
-- [ ] **`--encode-url-spaces` left an OPF-manifest RSC-020 FATAL standing
+- [x] **`--encode-url-spaces` left an OPF-manifest RSC-020 FATAL standing
       on the Theaetetus fixture** (observed 2026-09-16, classics wave
       phase 1): the Hackett Aristotle *Theaetetus* EPUB (McDowell) arrived
       with 270 raw-space zip entry names AND 270 raw-space hrefs in
@@ -1983,3 +1983,22 @@ four interpreter families.
       such books at all — until then the book parses in lenient readers
       but never passes epubcheck. Low frequency (one book in the wave),
       noted with the fixture reference above.
+
+- [x] **The `run phase1` report's repair records carry no structured fix
+      breakdown** (observed 2026-09-18 from the CalibreQuarry side, after
+      its lossy_consent box): the phase-1 JSON exposes only the rendered
+      `summary` string (fix keys flattened to "k:v, k:v"), so the CQ
+      mirror has to substring-match the gate's lossy keys
+      (`stripped_pagination`, `stripped_broken_tags`,
+      `stripped_watermarks`, `dropped_marker`, `stub_docs_dropped`) to
+      narrow consent to real strips. Exposing the RepairReport's `fixes`
+      dict per book (the `ncx_uid_synced`/`watermark_refusals` fields
+      already exist as data) would turn the lossy/structural split into
+      data instead of string matching, and CalibreQuarry would adopt it
+      with a deliberate floor bump. DONE in v0.45.0: every per-book
+      record (library --json, repair --json, and the phase1 payload built
+      on it) carries `fixes` plus `ncx_uid_synced` and
+      `watermark_refusals` as data; `_phase1_decisions` reads those
+      fields and no longer substring-matches the summary (which stays
+      rendered for human eyes). CalibreQuarry can floor-bump to
+      `bindery>=0.45.0` and drop its substring matching.

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/spec.md

@@ -509,8 +509,13 @@ crash), never raises, and always exits 0: a diagnosis is not a failure.
 
 `bindery repair SRC [DST] [--json FILE]` writes its record in the
 `library --json` per-book vocabulary (`status`, `applied`, `before`/`after`,
-the fix `summary`) on every processing outcome, including nochange and
-reject; usage refusals (missing input, existing output) precede any record.
+the fix `summary`, and the structured fix breakdown: the `fixes` dict plus
+`ncx_uid_synced` and `watermark_refusals`) on every processing outcome,
+including nochange and reject; usage refusals (missing input, existing
+output) precede any record. The structured fields are the machine-readable
+half of the same information: consumers narrow lossy consent by fix class
+as data, never by substring-matching the rendered summary (v0.45.0; the
+phase1 payload inherits them through its per-book repair records).
 
 ## The Calibre plugin (Bindery Repair)
 

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/src/bindery/__init__.py

@@ -11,7 +11,7 @@ Calibre plugin built from this core.
 Single source of truth for the version. pyproject.toml must match VERSION below.
 """
 
-VERSION = "0.44.0"
+VERSION = "0.45.0"
 __version__ = VERSION
 
 from .epub import RepairReport, repair_epub  # noqa: E402

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/src/bindery/cli.py

@@ -11,7 +11,7 @@ import subprocess
 import sys
 import tempfile
 import zipfile
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from itertools import islice
 from pathlib import Path
 
@@ -56,6 +56,13 @@ class Outcome:
     before: CheckResult | None
     after: CheckResult | None
     summary: str
+    # The structured half of `summary`: the RepairReport's own data, so
+    # consumers (run phase1's decisions, CalibreQuarry's lossy-consent
+    # mirror) read fix classes as data instead of substring-matching the
+    # rendered string.
+    fixes: dict[str, int] = field(default_factory=dict)
+    ncx_uid_synced: bool = False
+    watermark_refusals: int = 0
 
 
 def process_book(
@@ -133,7 +140,16 @@ def process_book(
         )
 
     if not validate:
-        return Outcome(epub, "unvalidated", None, None, summary)
+        return Outcome(
+            epub,
+            "unvalidated",
+            None,
+            None,
+            summary,
+            fixes=report.fixes,
+            ncx_uid_synced=report.ncx_uid_synced,
+            watermark_refusals=report.watermark_refusals,
+        )
 
     if before is None:
         before = run_epubcheck(epub)
@@ -142,7 +158,16 @@ def process_book(
         # Validation was requested but the oracle failed (crash, timeout, unparsable
         # output). This is "error", not "unvalidated": the gate did not accept the
         # repair, so it must never be applied. Only --no-validate skips the gate.
-        return Outcome(epub, "error", before, after, summary + " (epubcheck failed)")
+        return Outcome(
+            epub,
+            "error",
+            before,
+            after,
+            summary + " (epubcheck failed)",
+            fixes=report.fixes,
+            ncx_uid_synced=report.ncx_uid_synced,
+            watermark_refusals=report.watermark_refusals,
+        )
     verdict = gate(before, after)
     if (
         report.fixes.get("stripped_pagination")
@@ -193,7 +218,16 @@ def process_book(
     elif verdict == "noop":
         summary += " (no measurable gain)"
     status = "equal" if verdict == "noop" else verdict
-    return Outcome(epub, status, before, after, summary)
+    return Outcome(
+        epub,
+        status,
+        before,
+        after,
+        summary,
+        fixes=report.fixes,
+        ncx_uid_synced=report.ncx_uid_synced,
+        watermark_refusals=report.watermark_refusals,
+    )
 
 
 def _load_audit(path: Path) -> dict[str, tuple[int, int, int]]:
@@ -660,8 +694,21 @@ def run_library(args) -> int:
                     # record per path.
                     errors += 1
                     records.pop()
+                    # Forward o's structured fields: the repair itself
+                    # happened (its fixes are facts about the candidate),
+                    # and the record contract promises them on every
+                    # outcome, apply-failed included.
                     records.append(
-                        Outcome(epub, "error", o.before, o.after, f"apply failed: {e}")
+                        Outcome(
+                            epub,
+                            "error",
+                            o.before,
+                            o.after,
+                            f"apply failed: {e}",
+                            fixes=o.fixes,
+                            ncx_uid_synced=o.ncx_uid_synced,
+                            watermark_refusals=o.watermark_refusals,
+                        )
                     )
                     tqdm.write(
                         f"  ERROR   {rel}\n            apply failed: {e}; not applied"
@@ -742,6 +789,9 @@ def run_library(args) -> int:
                     "before": _counts_dict(o.before),
                     "after": _counts_dict(o.after),
                     "summary": o.summary,
+                    "fixes": o.fixes,
+                    "ncx_uid_synced": o.ncx_uid_synced,
+                    "watermark_refusals": o.watermark_refusals,
                     "applied": o.epub in applied_paths,
                 }
                 for o in records
@@ -833,6 +883,9 @@ def run_repair(args) -> int:
                     "before": None,
                     "after": None,
                     "summary": "",
+                    "fixes": {},
+                    "ncx_uid_synced": False,
+                    "watermark_refusals": 0,
                     "error": f"{type(e).__name__}: {e}",
                 }
             )
@@ -846,6 +899,9 @@ def run_repair(args) -> int:
             "before": _counts_dict(o.before),
             "after": _counts_dict(o.after),
             "summary": o.summary,
+            "fixes": o.fixes,
+            "ncx_uid_synced": o.ncx_uid_synced,
+            "watermark_refusals": o.watermark_refusals,
         }
         if o.status == "nochange":
             print("no applicable fixes; nothing written.")
@@ -951,10 +1007,10 @@ def _phase1_decisions(books: list[dict], apply: bool) -> list[dict]:
             r = b["repair"]
             if r is None:
                 continue
-            summary = r.get("summary") or ""
-            if "stripped_watermarks" in summary or "dropped_marker" in summary:
+            fixes = r.get("fixes") or {}
+            if fixes.get("stripped_watermarks") or fixes.get("dropped_marker"):
                 watermarked.append(b["path"])
-            if "watermark_refusals" in summary:
+            if r.get("watermark_refusals"):
                 manual_wm.append(b["path"])
             if r["status"] in ("accept", "partial"):
                 pending.append(b["path"])
@@ -974,7 +1030,7 @@ def _phase1_decisions(books: list[dict], apply: bool) -> list[dict]:
     else:
         for b in books:
             r = b["repair"]
-            if r is not None and "watermark_refusals" in (r.get("summary") or ""):
+            if r is not None and r.get("watermark_refusals"):
                 manual_wm.append(b["path"])
     if manual_wm:
         decisions.append(
@@ -1024,7 +1080,7 @@ def run_doctor(args) -> int:
     print()
 
     py = sys.version.split()[0]
-    print(f"python:      {py} (floor 3.12)")
+    print(f"python:      {py} (floor 3.12)  [{sys.executable}]")
 
     stack = []
     for mod in ("vir_tui", "cquarry"):

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/tests/test_cli.py

@@ -196,8 +196,9 @@ class TestRepairWritesGatedBytes(unittest.TestCase):
 class TestRepairJson(unittest.TestCase):
     """repair --json: the one machine-readable gap in the four-verb CLI. The
     record speaks the library --json per-book vocabulary (status, applied,
-    before/after, summary) and lands on every processing outcome, including
-    the refusals."""
+    before/after, summary, the structured fixes/ncx_uid_synced/
+    watermark_refusals fields) and lands on every processing outcome,
+    including the refusals."""
 
     def test_accepted_repair_writes_a_record(self):
         with tempfile.TemporaryDirectory() as td:
@@ -274,6 +275,68 @@ class TestRepairJson(unittest.TestCase):
         self.assertFalse(d2["applied"])
 
 
+class TestStructuredFixRecord(unittest.TestCase):
+    """The per-book records carry the fix breakdown as data, not only the
+    rendered summary string: the structured-fixes roadmap box (2026-09-18),
+    so consumers like CalibreQuarry's lossy-consent mirror and run phase1's
+    own decisions read fix classes instead of substring-matching prose."""
+
+    def test_library_record_carries_fix_breakdown(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            _phase1_book(root / "a.epub", broken=False, real_fix=True)
+            jout = root / "lib.json"
+            with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
+                rc = cli.run_library(
+                    build_parser().parse_args(
+                        ["library", str(root), "--no-validate", "--json", str(jout)]
+                    )
+                )
+            data = json.loads(jout.read_text())
+        self.assertEqual(rc, 0)
+        (rec,) = data["books"]
+        self.assertEqual(rec["status"], "unvalidated")
+        self.assertEqual(rec["fixes"], {"fix_ncx_playorder": 1})
+        self.assertFalse(rec["ncx_uid_synced"])
+        self.assertEqual(rec["watermark_refusals"], 0)
+        # the rendered summary stays for human eyes
+        self.assertIn("fix_ncx_playorder:1", rec["summary"])
+
+    def test_repair_json_record_carries_fix_breakdown(self):
+        with tempfile.TemporaryDirectory() as td:
+            src = Path(td) / "in.epub"
+            dst = Path(td) / "out.epub"
+            _phase1_book(src, broken=False, real_fix=True)
+            jout = Path(td) / "repair.json"
+            with redirect_stdout(io.StringIO()):
+                rc = main(
+                    ["repair", str(src), str(dst), "--no-validate", "--json", str(jout)]
+                )
+            data = json.loads(jout.read_text())
+        self.assertEqual(rc, 0)
+        self.assertEqual(data["status"], "unvalidated")
+        self.assertEqual(data["fixes"], {"fix_ncx_playorder": 1})
+        self.assertFalse(data["ncx_uid_synced"])
+        self.assertEqual(data["watermark_refusals"], 0)
+
+    def test_nochange_record_carries_empty_fixes(self):
+        with tempfile.TemporaryDirectory() as td:
+            src = Path(td) / "in.epub"
+            dst = Path(td) / "out.epub"
+            _phase1_book(src, broken=False)
+            jout = Path(td) / "repair.json"
+            with redirect_stdout(io.StringIO()):
+                rc = main(
+                    ["repair", str(src), str(dst), "--no-validate", "--json", str(jout)]
+                )
+            data = json.loads(jout.read_text())
+        self.assertEqual(rc, 0)
+        self.assertEqual(data["status"], "nochange")
+        self.assertEqual(data["fixes"], {})
+        self.assertFalse(data["ncx_uid_synced"])
+        self.assertEqual(data["watermark_refusals"], 0)
+
+
 class TestDoctor(unittest.TestCase):
     """bindery doctor: the stranded stranger's first command. It must always
     run, never traceback, and always exit 0; the findings ARE the output."""
@@ -744,6 +807,11 @@ class TestApplyFailureIsolation(unittest.TestCase):
         self.assertEqual(len(paths), len(set(paths)))  # one record per path
         statuses = [b["status"] for b in data["books"]]
         self.assertEqual(statuses, ["error"])
+        # the repair itself happened; its fixes are facts about the candidate
+        # and must survive the apply failure (the record contract promises
+        # the structured fields on every outcome)
+        (rec,) = data["books"]
+        self.assertEqual(rec["fixes"], {"fix_ncx_playorder": 1})
         self.assertEqual(rc, 2)
 
     def test_backup_dir_inside_library_root_is_refused(self):
@@ -1264,6 +1332,9 @@ class TestWatermarkRefusalDecision(unittest.TestCase):
             "repair": {
                 "status": "equal",
                 "summary": "watermark_refusals:1 (no measurable gain)",
+                "fixes": {},
+                "ncx_uid_synced": False,
+                "watermark_refusals": 1,
             },
         }
 
@@ -1278,6 +1349,9 @@ class TestWatermarkRefusalDecision(unittest.TestCase):
         book["repair"] = {
             "status": "accept",
             "summary": "stripped_watermarks:1, watermark_refusals:1",
+            "fixes": {"stripped_watermarks": 1},
+            "ncx_uid_synced": False,
+            "watermark_refusals": 1,
         }
         decisions = _phase1_decisions([book], apply=True)
         (d,) = decisions  # apply recorded: only the manual-repair question remains

{bindery_cli-0.44.0 → bindery_cli-0.45.0}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "bindery-cli"
-version = "0.44.0"
+version = "0.45.0"
 source = { editable = "." }
 dependencies = [
     { name = "cquarry", marker = "python_full_version >= '3.14'" },
@@ -41,11 +41,11 @@ wheels = [
 
 [[package]]
 name = "cquarry"
-version = "1.23.0"
+version = "1.23.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/bb/b124fc1988935b5e3420394841b3d8c89c3bbf331f4c8335c643b2f6136c/cquarry-1.23.0.tar.gz", hash = "sha256:ecc86a0144e1fe03620e236b588927bf52ca24979550c0e043f972b310911aa6", size = 279290, upload-time = "2026-09-15T20:00:01.202Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/f3/68d8dea76897d2efb9db7c6ce5e3592b1b6e410656e6e6a727c3ddae0353/cquarry-1.23.2.tar.gz", hash = "sha256:cb7467b02dea4013189964528f389d825b23416d6c493912947e7bbf10238a84", size = 284386, upload-time = "2026-09-16T21:18:59.258Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/05/cb087280bec3de9bb63f04e67183c127a33a4153110145ee30930d8f7c60/cquarry-1.23.0-py3-none-any.whl", hash = "sha256:1f39ecd144a586e17d81513beca954364c90e086f4bb44505fa428aa0f9b0ff4", size = 96522, upload-time = "2026-09-15T19:59:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/4b/40e5f2a45ccbcb228f4a4c6dfe4a3e0b191004249bd7de1dec1c5a68541f/cquarry-1.23.2-py3-none-any.whl", hash = "sha256:708884c454ef344202351e9633cfba856b83b3961a742eac18d4815e3f8b38ec", size = 96618, upload-time = "2026-09-16T21:18:57.906Z" },
 ]
 
 [[package]]