civon-image-edit-audit 0.1.0__tar.gz

civon_image_edit_audit-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Dependencies and local tool state
+node_modules/
+.pnpm-store/
+.DS_Store
+
+# Local environment files
+.env
+.env.*
+!.env.example
+
+# Runtime output is local-only by default: JSON logs, helper scripts, screenshots,
+# browser snapshots, network captures, and lock files all belong here.
+runs/*
+!runs/.gitkeep
+
+# A human may deliberately promote a small, redacted JSON receipt as durable
+# evidence. Promotion is explicit by path, not automatic from a runner.
+!runs/evidence/
+runs/evidence/*
+!runs/evidence/README.md
+!runs/evidence/*.json
+
+# Target-size media exports are reproducible local cache files. Reviewed shared
+# masters under assets/<site>/_shared/v*/ remain tracked. Add one export with
+# `git add -f` only when an exact reviewed file must survive across machines for
+# a registered publishing asset; never force-add the whole export cache.
+assets/**/_shared/exports/

civon_image_edit_audit-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+LicenseRef-NoLicenseGrant
+
+This prepared package makes no open-source or other package-use license grant.
+No ownership certificate, exclusivity claim, third-party license or permission
+to use product inputs or outputs is asserted. Distribution rights and registry
+publication must be confirmed by the authorised owner before execution.
+Local preparation does not upload or publish this package.

civon_image_edit_audit-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.5
+Name: civon-image-edit-audit
+Version: 0.1.0
+Summary: Audit human image-edit records and quote totals with a dependency-free Python library and CLI.
+Project-URL: Homepage, https://civon.ai/image-editor
+License-Expression: LicenseRef-NoLicenseGrant
+License-File: LICENSE
+Keywords: image-editing,manual-review,record-validation,workflow
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# civon-image-edit-audit
+
+A dependency-free Python audit library and local CLI for **human-entered image-edit records**. It validates a JSON interchange format, identifies incomplete checks and failed candidates, counts manual acceptances, and sums recorded credit quotes with decimal arithmetic. It also produces a compact Markdown report.
+
+This is an independent workflow utility, not an official Civon generation SDK. It does not generate, inspect, edit, hash or upload images, read an account balance, fetch current prices, run a model or verify rights. The decisions reflect only the supplied human assertions. Original AI-assisted code and text; no private product implementation, image, credential or third-party runtime package is included.
+
+## Local installation and runtime
+
+The prepared release contains a real wheel and source distribution. Install the actual local wheel in a virtual environment:
+
+```sh
+python -m pip install --no-index --no-deps /absolute/path/to/civon_image_edit_audit-0.1.0-py3-none-any.whl
+civon-edit-audit records.json
+civon-edit-audit --markdown records.json
+civon-edit-audit - < records.json
+```
+
+Python 3.10 or later is declared. Local preparation tests the installed artifacts on the available Python runtime and records that version; it does not claim a full version matrix. Hatchling and build are build tools, not runtime dependencies. No PyPI or TestPyPI upload, live project URL or name reservation is established by this bundle.
+
+## Python API
+
+```python
+from civon_image_edit_audit import audit_record, audit_records, load_records, to_markdown
+
+candidate = {
+    "schema": "civon-image-edit-record/v1",
+    "id": "draft-1",
+    "candidate": "mug-background-v1.png",
+    "prompt": "Explore a warmer backdrop; inspect lettering.",
+    "settings": "Manually recorded model, ratio and resolution",
+    "quotedCredits": "2.5",  # synthetic example, not a product price
+    "checks": {
+        "subject": "pass", "text": "fail", "geometry": "pass",
+        "edges": "pass", "lighting": "pass", "delivery": "pass"
+    },
+    "permissionsConfirmed": False
+}
+
+result = audit_record(candidate)
+assert result.status == "revise"
+assert result.failed == ("text",)
+report = audit_records([candidate])
+assert report["quotedCredits"] == "2.5"
+print(to_markdown([candidate]))
+```
+
+These sample checks are fictional and do not describe an actual image analysis or product result. `AuditResult` is a frozen dataclass; audit functions do not mutate the supplied records.
+
+## Interchange contract
+
+The input is an array of `civon-image-edit-record/v1` records, compatible with JSON-serialised records from the separately prepared JavaScript record utility. This Python package does not require or execute that JavaScript package.
+
+- Required non-empty strings: `id` (up to 160 characters), `candidate` (250), `prompt` (2000), `settings` (2000).
+- `quotedCredits` is a decimal string with at most six whole digits and three fractional digits, or null/omitted for unknown. An explicit `"0"` is distinct from unknown. Numbers, negative values, exponent notation and excessive precision are rejected. Decimal arithmetic totals all known quotes, including rejected candidates; these are entries, not charges, prices or an account balance.
+- Optional `sourceSha256` and `candidateSha256` contain 64 hexadecimal characters or null. Only their syntax is checked; files are not opened or hashed. Optional `notes` is non-empty text up to 2000 characters, or null/omitted.
+- `checks` contains exactly `subject`, `text`, `geometry`, `edges`, `lighting` and `delivery`. Each value is `pending`, `pass`, `fail` or `na`. `permissionsConfirmed` must be an actual boolean, not a string or number.
+- A failed check yields `revise`; a pending check yields `pending`. All N/A is insufficient. Acceptance requires at least one Pass and confirmed permissions after all checks resolve. The permissions field records a user assertion, not legal clearance.
+- Arrays are limited to 10,000 records, with unique trimmed ids. Errors identify the zero-based record index where applicable. `load_records` rejects duplicate JSON keys, non-finite constants and malformed/deeply nested JSON. Unknown top-level extra fields are ignored; unknown check fields are rejected.
+
+The CLI reads at most 5 MiB plus one byte to detect oversized input. It accepts one local UTF-8 file or stdin, prints a report and writes no file. Invalid data returns status 1, argument errors 2, and valid reports/help 0. `to_markdown` escapes table delimiters and line breaks; it is not an HTML sanitiser. Keep exported prompts, filenames, settings and notes private when needed.
+
+## Provenance and license posture
+
+Metadata uses `LicenseRef-NoLicenseGrant` with the included notice. This preparation grants no open-source or other package-use license and makes no ownership or exclusivity assurance. Account authority, distribution rights, namespace/version availability and final publication remain execution checks. No author, email, source repository or issue tracker is invented.
+
+## Related product context
+
+[Civon AI Image Editor](https://civon.ai/image-editor) is a browser-based, prompt-led still-image editor. Model choices, usable reference counts, settings, access and quoted credits vary. This audit utility works without visiting or connecting to it and provides no model integration, endorsement by PyPI or guarantee about an edited image.

civon_image_edit_audit-0.1.0/README.md

@@ -0,0 +1,68 @@
+# civon-image-edit-audit
+
+A dependency-free Python audit library and local CLI for **human-entered image-edit records**. It validates a JSON interchange format, identifies incomplete checks and failed candidates, counts manual acceptances, and sums recorded credit quotes with decimal arithmetic. It also produces a compact Markdown report.
+
+This is an independent workflow utility, not an official Civon generation SDK. It does not generate, inspect, edit, hash or upload images, read an account balance, fetch current prices, run a model or verify rights. The decisions reflect only the supplied human assertions. Original AI-assisted code and text; no private product implementation, image, credential or third-party runtime package is included.
+
+## Local installation and runtime
+
+The prepared release contains a real wheel and source distribution. Install the actual local wheel in a virtual environment:
+
+```sh
+python -m pip install --no-index --no-deps /absolute/path/to/civon_image_edit_audit-0.1.0-py3-none-any.whl
+civon-edit-audit records.json
+civon-edit-audit --markdown records.json
+civon-edit-audit - < records.json
+```
+
+Python 3.10 or later is declared. Local preparation tests the installed artifacts on the available Python runtime and records that version; it does not claim a full version matrix. Hatchling and build are build tools, not runtime dependencies. No PyPI or TestPyPI upload, live project URL or name reservation is established by this bundle.
+
+## Python API
+
+```python
+from civon_image_edit_audit import audit_record, audit_records, load_records, to_markdown
+
+candidate = {
+    "schema": "civon-image-edit-record/v1",
+    "id": "draft-1",
+    "candidate": "mug-background-v1.png",
+    "prompt": "Explore a warmer backdrop; inspect lettering.",
+    "settings": "Manually recorded model, ratio and resolution",
+    "quotedCredits": "2.5",  # synthetic example, not a product price
+    "checks": {
+        "subject": "pass", "text": "fail", "geometry": "pass",
+        "edges": "pass", "lighting": "pass", "delivery": "pass"
+    },
+    "permissionsConfirmed": False
+}
+
+result = audit_record(candidate)
+assert result.status == "revise"
+assert result.failed == ("text",)
+report = audit_records([candidate])
+assert report["quotedCredits"] == "2.5"
+print(to_markdown([candidate]))
+```
+
+These sample checks are fictional and do not describe an actual image analysis or product result. `AuditResult` is a frozen dataclass; audit functions do not mutate the supplied records.
+
+## Interchange contract
+
+The input is an array of `civon-image-edit-record/v1` records, compatible with JSON-serialised records from the separately prepared JavaScript record utility. This Python package does not require or execute that JavaScript package.
+
+- Required non-empty strings: `id` (up to 160 characters), `candidate` (250), `prompt` (2000), `settings` (2000).
+- `quotedCredits` is a decimal string with at most six whole digits and three fractional digits, or null/omitted for unknown. An explicit `"0"` is distinct from unknown. Numbers, negative values, exponent notation and excessive precision are rejected. Decimal arithmetic totals all known quotes, including rejected candidates; these are entries, not charges, prices or an account balance.
+- Optional `sourceSha256` and `candidateSha256` contain 64 hexadecimal characters or null. Only their syntax is checked; files are not opened or hashed. Optional `notes` is non-empty text up to 2000 characters, or null/omitted.
+- `checks` contains exactly `subject`, `text`, `geometry`, `edges`, `lighting` and `delivery`. Each value is `pending`, `pass`, `fail` or `na`. `permissionsConfirmed` must be an actual boolean, not a string or number.
+- A failed check yields `revise`; a pending check yields `pending`. All N/A is insufficient. Acceptance requires at least one Pass and confirmed permissions after all checks resolve. The permissions field records a user assertion, not legal clearance.
+- Arrays are limited to 10,000 records, with unique trimmed ids. Errors identify the zero-based record index where applicable. `load_records` rejects duplicate JSON keys, non-finite constants and malformed/deeply nested JSON. Unknown top-level extra fields are ignored; unknown check fields are rejected.
+
+The CLI reads at most 5 MiB plus one byte to detect oversized input. It accepts one local UTF-8 file or stdin, prints a report and writes no file. Invalid data returns status 1, argument errors 2, and valid reports/help 0. `to_markdown` escapes table delimiters and line breaks; it is not an HTML sanitiser. Keep exported prompts, filenames, settings and notes private when needed.
+
+## Provenance and license posture
+
+Metadata uses `LicenseRef-NoLicenseGrant` with the included notice. This preparation grants no open-source or other package-use license and makes no ownership or exclusivity assurance. Account authority, distribution rights, namespace/version availability and final publication remain execution checks. No author, email, source repository or issue tracker is invented.
+
+## Related product context
+
+[Civon AI Image Editor](https://civon.ai/image-editor) is a browser-based, prompt-led still-image editor. Model choices, usable reference counts, settings, access and quoted credits vary. This audit utility works without visiting or connecting to it and provides no model integration, endorsement by PyPI or guarantee about an edited image.

civon_image_edit_audit-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "civon-image-edit-audit"
+version = "0.1.0"
+description = "Audit human image-edit records and quote totals with a dependency-free Python library and CLI."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-NoLicenseGrant"
+license-files = ["LICENSE"]
+dependencies = []
+keywords = ["image-editing", "manual-review", "record-validation", "workflow"]
+classifiers = ["Programming Language :: Python :: 3", "Operating System :: OS Independent"]
+
+[project.urls]
+Homepage = "https://civon.ai/image-editor"
+
+[project.scripts]
+civon-edit-audit = "civon_image_edit_audit.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/civon_image_edit_audit"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/", "tests/", "README.md", "LICENSE", "pyproject.toml"]

civon_image_edit_audit-0.1.0/src/civon_image_edit_audit/__init__.py

@@ -0,0 +1,5 @@
+"""Audit manual decisions; no image analysis, network I/O or rights verification."""
+from .audit import AuditError, AuditResult, audit_record, audit_records, load_records, to_markdown
+
+__version__ = "0.1.0"
+__all__ = ["AuditError", "AuditResult", "audit_record", "audit_records", "load_records", "to_markdown"]

civon_image_edit_audit-0.1.0/src/civon_image_edit_audit/audit.py

@@ -0,0 +1,150 @@
+"""Validate the civon-image-edit-record/v1 JSON interchange format."""
+from dataclasses import dataclass
+from decimal import Decimal, localcontext
+import json
+import re
+from typing import Any
+
+CHECKS = ("subject", "text", "geometry", "edges", "lighting", "delivery")
+RESULTS = frozenset(("pending", "pass", "fail", "na"))
+SCHEMA = "civon-image-edit-record/v1"
+
+
+class AuditError(ValueError):
+    """An input violates the documented manual-record contract."""
+
+
+@dataclass(frozen=True)
+class AuditResult:
+    record_id: str
+    candidate: str
+    status: str
+    reason: str
+    quoted_credits: Decimal | None
+    failed: tuple[str, ...]
+    pending: tuple[str, ...]
+
+
+def _text(value: Any, field: str, maximum: int) -> str:
+    if not isinstance(value, str) or not value.strip() or len(value) > maximum:
+        raise AuditError(f"{field} must be non-empty text (maximum {maximum} characters)")
+    return value.strip()
+
+
+def _quote(value: Any) -> Decimal | None:
+    if value is None:
+        return None
+    if not isinstance(value, str) or not re.fullmatch(r"[0-9]{1,6}(?:\.[0-9]{1,3})?", value):
+        raise AuditError("quotedCredits must be a decimal string with up to 6 whole digits and 3 decimal places, or null")
+    return Decimal(value)
+
+
+def _amount(value: Decimal) -> str:
+    text = format(value, "f")
+    return text.rstrip("0").rstrip(".") if "." in text else text
+
+
+def audit_record(record: Any) -> AuditResult:
+    """Validate a record and derive status from the supplied human assertions."""
+    if not isinstance(record, dict) or record.get("schema") != SCHEMA:
+        raise AuditError("Unsupported image-edit record schema")
+    record_id = _text(record.get("id"), "id", 160)
+    candidate = _text(record.get("candidate"), "candidate", 250)
+    _text(record.get("prompt"), "prompt", 2000)
+    _text(record.get("settings"), "settings", 2000)
+    quote = _quote(record.get("quotedCredits"))
+    for name in ("sourceSha256", "candidateSha256"):
+        value = record.get(name)
+        if value is not None and (not isinstance(value, str) or not re.fullmatch(r"[a-fA-F0-9]{64}", value)):
+            raise AuditError(f"{name} must be SHA-256 hexadecimal text or null")
+    if record.get("notes") is not None:
+        _text(record["notes"], "notes", 2000)
+    checks = record.get("checks")
+    if not isinstance(checks, dict) or set(checks) != set(CHECKS):
+        raise AuditError("checks must contain exactly the six documented names")
+    if any(not isinstance(value, str) or value not in RESULTS for value in checks.values()):
+        raise AuditError("Invalid check result")
+    if type(record.get("permissionsConfirmed")) is not bool:
+        raise AuditError("permissionsConfirmed must be a boolean")
+    failed = tuple(name for name in CHECKS if checks[name] == "fail")
+    pending = tuple(name for name in CHECKS if checks[name] == "pending")
+    if failed:
+        status, reason = "revise", "failed_checks"
+    elif pending:
+        status, reason = "pending", "incomplete_checks"
+    elif not any(value == "pass" for value in checks.values()):
+        status, reason = "pending", "no_positive_check"
+    elif not record["permissionsConfirmed"]:
+        status, reason = "pending", "permissions_unconfirmed"
+    else:
+        status, reason = "accepted", "manual_checks_complete"
+    return AuditResult(record_id, candidate, status, reason, quote, failed, pending)
+
+
+def audit_records(records: Any) -> dict[str, Any]:
+    """Audit up to 10,000 records, reject duplicate ids, and total all known quotes."""
+    if not isinstance(records, list) or len(records) > 10000:
+        raise AuditError("Expected a JSON array containing at most 10000 records")
+    ids: set[str] = set()
+    outcomes = []
+    decisions = {"pending": 0, "revise": 0, "accepted": 0}
+    values, unknown = [], 0
+    for index, record in enumerate(records):
+        try:
+            result = audit_record(record)
+            if result.record_id in ids:
+                raise AuditError(f"Duplicate record id: {result.record_id}")
+        except AuditError as error:
+            raise AuditError(f"Record {index}: {error}") from error
+        ids.add(result.record_id)
+        decisions[result.status] += 1
+        if result.quoted_credits is None:
+            unknown += 1
+        else:
+            values.append(result.quoted_credits)
+        outcomes.append({"id": result.record_id, "candidate": result.candidate, "status": result.status,
+                         "reason": result.reason, "quotedCredits": None if result.quoted_credits is None else _amount(result.quoted_credits),
+                         "failed": list(result.failed), "pending": list(result.pending)})
+    with localcontext() as context:
+        context.prec = 28
+        total = sum(values, Decimal("0"))
+    return {"schema": "civon-image-edit-audit/v1", "records": len(records), "quotedCredits": _amount(total),
+            "unknownQuotes": unknown, "decisions": decisions, "quoteMeaning": "sum_of_manually_entered_quotes_not_charges",
+            "results": outcomes}
+
+
+def _pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise AuditError(f"Duplicate JSON key: {key}")
+        result[key] = value
+    return result
+
+
+def _constant(value: str) -> None:
+    raise AuditError(f"Non-finite JSON constant: {value}")
+
+
+def load_records(text: str) -> list[dict[str, Any]]:
+    """Decode strict JSON and validate before returning the records."""
+    try:
+        records = json.loads(text, object_pairs_hook=_pairs, parse_constant=_constant)
+    except (json.JSONDecodeError, RecursionError) as error:
+        raise AuditError(f"Invalid JSON: {error}") from error
+    audit_records(records)
+    return records
+
+
+def to_markdown(records: Any) -> str:
+    """Render a compact table, escaping table pipes and line breaks, not HTML."""
+    report = audit_records(records)
+    def cell(value: Any) -> str:
+        return str(value).replace("|", "\\|").replace("\r", " ").replace("\n", " ")
+    lines = ["# Manual image-edit audit", "", "Human assertions and quoted credits; not image analysis, billing or rights verification.", "",
+             "| Record | Candidate | Quote | Decision |", "| --- | --- | --- | --- |"]
+    for row in report["results"]:
+        quote = "Unknown" if row["quotedCredits"] is None else row["quotedCredits"]
+        lines.append("| " + " | ".join(cell(v) for v in (row["id"], row["candidate"], quote, row["status"])) + " |")
+    lines += ["", f"Total entered quotes: {report['quotedCredits']}; unknown quotes: {report['unknownQuotes']}.", ""]
+    return "\n".join(lines)

civon_image_edit_audit-0.1.0/src/civon_image_edit_audit/cli.py

@@ -0,0 +1,30 @@
+"""Read one local JSON array or stdin; write an audit to stdout."""
+import argparse
+import json
+import sys
+from .audit import AuditError, audit_records, load_records, to_markdown
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Audit human image-edit records; no image analysis or network access.")
+    parser.add_argument("file", help="local JSON file, or - for stdin")
+    parser.add_argument("--markdown", action="store_true", help="write a compact Markdown table")
+    args = parser.parse_args(argv)
+    try:
+        if args.file == "-":
+            data = sys.stdin.buffer.read(5 * 1024 * 1024 + 1)
+        else:
+            with open(args.file, "rb") as stream:
+                data = stream.read(5 * 1024 * 1024 + 1)
+        if len(data) > 5 * 1024 * 1024:
+            raise AuditError("Input exceeds 5 MiB")
+        records = load_records(data.decode("utf-8"))
+        print(to_markdown(records) if args.markdown else json.dumps(audit_records(records), indent=2, ensure_ascii=False))
+        return 0
+    except (AuditError, OSError, UnicodeError, RecursionError) as error:
+        print(f"Invalid edit records: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

civon_image_edit_audit-0.1.0/tests/test_audit.py

@@ -0,0 +1,167 @@
+import copy
+from dataclasses import FrozenInstanceError
+from decimal import Decimal, localcontext
+import json
+import subprocess
+import sys
+import unittest
+from unittest.mock import patch
+from civon_image_edit_audit import AuditError, audit_record, audit_records, load_records, to_markdown
+
+
+def record(identifier="a", quote=None):
+    return {"schema": "civon-image-edit-record/v1", "id": identifier, "candidate": "mug.png",
+            "prompt": "A warmer backdrop", "settings": "Manual settings", "quotedCredits": quote,
+            "checks": dict.fromkeys(("subject", "text", "geometry", "edges", "lighting", "delivery"), "pending"),
+            "permissionsConfirmed": False}
+
+
+class AuditTests(unittest.TestCase):
+    def test_pending_and_immutable(self):
+        r = record()
+        before = copy.deepcopy(r)
+        result = audit_record(r)
+        self.assertEqual(result.status, "pending")
+        self.assertEqual(len(result.pending), 6)
+        self.assertEqual(r, before)
+        with self.assertRaises(FrozenInstanceError):
+            result.status = "accepted"
+
+    def test_permissions_gate_and_acceptance(self):
+        r = record()
+        r["checks"] = dict.fromkeys(r["checks"], "pass")
+        self.assertEqual(audit_record(r).reason, "permissions_unconfirmed")
+        r["permissionsConfirmed"] = True
+        self.assertEqual(audit_record(r).status, "accepted")
+
+    def test_failure_precedes_pending(self):
+        r = record()
+        r["checks"]["text"] = "fail"
+        self.assertEqual(audit_record(r).status, "revise")
+        self.assertEqual(audit_record(r).failed, ("text",))
+
+    def test_na_is_not_positive_evidence(self):
+        r = record()
+        r["checks"] = dict.fromkeys(r["checks"], "na")
+        r["permissionsConfirmed"] = True
+        self.assertEqual(audit_record(r).reason, "no_positive_check")
+        r["checks"]["subject"] = "pass"
+        self.assertEqual(audit_record(r).status, "accepted")
+
+    def test_quote_precision_and_unknown(self):
+        data = [record("a", "0.1"), record("b", "0.2"), record("c", None), record("d", "0")]
+        report = audit_records(data)
+        self.assertEqual(report["quotedCredits"], "0.3")
+        self.assertEqual(report["unknownQuotes"], 1)
+        self.assertEqual(audit_record(record(quote="999999.999")).quoted_credits, Decimal("999999.999"))
+        with localcontext() as context:
+            context.prec = 2
+            self.assertEqual(audit_records([record("a", "999999.999"), record("b", "0.001")])["quotedCredits"], "1000000")
+
+    def test_quotes_reject_non_contract_values(self):
+        for quote in [-1, 0, 1.2, True, "-1", "NaN", "Infinity", "1e3", "1.0001", "1000000", "", "١"]:
+            with self.subTest(quote=quote), self.assertRaises(AuditError):
+                audit_record(record(quote=quote))
+
+    def test_record_shape(self):
+        for value in [None, [], {}, {"schema": "other"}]:
+            with self.subTest(value=value), self.assertRaises(AuditError):
+                audit_record(value)
+
+    def test_required_strings(self):
+        for field in ["id", "candidate", "prompt", "settings"]:
+            for value in ["", " ", None, 2, True]:
+                with self.subTest(field=field, value=value), self.assertRaises(AuditError):
+                    r = record()
+                    r[field] = value
+                    audit_record(r)
+        for field, limit in [("id", 160), ("candidate", 250), ("prompt", 2000), ("settings", 2000)]:
+            r = record()
+            r[field] = "x" * (limit + 1)
+            with self.assertRaises(AuditError):
+                audit_record(r)
+
+    def test_checks_exact_shape(self):
+        for change in ["missing", "extra", "invalid", "list", "unhashable"]:
+            r = record()
+            if change == "missing": del r["checks"]["text"]
+            if change == "extra": r["checks"]["invented"] = "pass"
+            if change == "invalid": r["checks"]["text"] = "yes"
+            if change == "list": r["checks"] = []
+            if change == "unhashable": r["checks"]["text"] = []
+            with self.subTest(change=change), self.assertRaises(AuditError):
+                audit_record(r)
+
+    def test_permission_boolean(self):
+        for value in [1, 0, "true", None, []]:
+            r = record()
+            r["permissionsConfirmed"] = value
+            with self.subTest(value=value), self.assertRaises(AuditError):
+                audit_record(r)
+
+    def test_checksums_and_notes(self):
+        r = record()
+        r["sourceSha256"] = "AB" * 32
+        r["candidateSha256"] = None
+        r["notes"] = "Private observation"
+        audit_record(r)
+        for field, value in [("sourceSha256", "bad"), ("candidateSha256", 3), ("notes", ""), ("notes", "x" * 2001)]:
+            bad = {**r, field: value}
+            with self.subTest(field=field), self.assertRaises(AuditError):
+                audit_record(bad)
+
+    def test_duplicates_and_error_index(self):
+        with self.assertRaisesRegex(AuditError, "Record 1: Duplicate"):
+            audit_records([record("a"), record(" a ")])
+        with self.assertRaisesRegex(AuditError, "Record 1:"):
+            audit_records([record(), {}])
+
+    def test_array_and_size(self):
+        self.assertEqual(audit_records([])["quotedCredits"], "0")
+        for data in [{}, None, [record()] * 10001]:
+            with self.subTest(kind=type(data).__name__), self.assertRaises(AuditError):
+                audit_records(data)
+
+    def test_json_strictness(self):
+        self.assertEqual(load_records(json.dumps([record()])), [record()])
+        for text in ['{"a":1,"a":2}', '[NaN]', '[Infinity]', '[', '[[]]', '[' * 2000 + ']' * 2000]:
+            with self.subTest(text=text[:20]), self.assertRaises(AuditError):
+                load_records(text)
+
+    def test_markdown_escape(self):
+        r = record("a|b")
+        r["candidate"] = "one\ntwo"
+        result = to_markdown([r])
+        self.assertIn("a\\|b", result)
+        self.assertIn("one two", result)
+        self.assertIn("Unknown", result)
+
+    def test_no_file_or_network_io(self):
+        with patch("builtins.open", side_effect=AssertionError("file I/O")), patch("socket.socket", side_effect=AssertionError("network")):
+            self.assertEqual(audit_records([record()])["records"], 1)
+
+    def test_summary_counts_failed_quotes(self):
+        r = record("failed", "2.50")
+        r["checks"]["text"] = "fail"
+        report = audit_records([r, record("pending", "1.25")])
+        self.assertEqual(report["quotedCredits"], "3.75")
+        self.assertEqual(report["decisions"], {"pending": 1, "revise": 1, "accepted": 0})
+
+    def test_cli(self):
+        def cli(args, data=b""):
+            return subprocess.run([sys.executable, "-m", "civon_image_edit_audit.cli", *args], input=data, capture_output=True)
+        data = json.dumps([record(quote="0.2")]).encode()
+        result = cli(["-"], data)
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(json.loads(result.stdout)["quotedCredits"], "0.2")
+        self.assertEqual(cli(["--markdown", "-"], data).returncode, 0)
+        self.assertEqual(cli(["--help"]).returncode, 0)
+        self.assertEqual(cli([]).returncode, 2)
+        self.assertEqual(cli(["-"], b"{bad").returncode, 1)
+        self.assertEqual(cli(["-"], b"\xff").returncode, 1)
+        self.assertEqual(cli(["-"], b" " * (5 * 1024 * 1024 + 1)).returncode, 1)
+        self.assertEqual(cli(["/nonexistent/civon-audit-test.json"]).returncode, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()