syncade 0.6.2__py3-none-any.whl

syncade/persistence/synth.py

@@ -0,0 +1,242 @@
+"""Synthesizer subprocess persistence.
+
+Writes ``<round_dir>/synthesizer.{stdout,stderr,parsed.json[,error.txt]}``
+and the matching round-manifest entry. There is exactly one
+synthesizer per round, so the basename is hardcoded (``SYNTHESIZER_NAME``
+from :mod:`syncade.synthesizer`).
+
+The module is named ``synth.py`` (not ``synthesizer.py``) to
+disambiguate from :mod:`syncade.synthesizer`, which contains the actual
+synthesizer driver.
+"""
+
+from __future__ import annotations
+
+import traceback
+from dataclasses import dataclass
+from pathlib import Path
+
+from syncade.synthesizer import (
+    SYNTHESIZER_MODEL,
+    SYNTHESIZER_NAME,
+    SYNTHESIZER_PROVIDER,
+    SynthesizerResult,
+)
+from syncade.usage import usage_fields
+
+from ._atomic import atomic_write_text
+from ._validation import _validate_reviewer_filename_basename
+
+
+@dataclass(frozen=True)
+class SynthesizerArtifactPaths:
+    """Where the synthesizer subprocess's artifacts land on disk.
+
+    All four paths are absolute and rooted at ``<round_dir>``.
+    ``parsed`` is ``None`` when the synthesizer failed (no
+    :class:`SynthesizerOutput` to serialize); ``error`` is ``None``
+    when it succeeded (no exception to record).
+
+    Returned by :func:`persist_synthesizer_result` and attached to
+    :class:`~syncade.orchestrator.RunArtifacts` so the CLI / future
+    loop can address the files without re-deriving the layout
+    convention.
+    """
+
+    stdout: Path
+    stderr: Path
+    parsed: Path | None
+    error: Path | None
+
+
+def persist_synthesizer_result(
+    round_dir: Path, synth_result: SynthesizerResult
+) -> SynthesizerArtifactPaths:
+    """Write the synthesizer subprocess's outputs to
+    ``<round_dir>/synthesizer.*``.
+
+    Mirrors :func:`persist_reviewer_result`'s file-layout convention
+    so a tool inspecting the round directory sees the synthesizer
+    artifacts in the same shape as the per-reviewer artifacts. The
+    only difference is the fixed ``"synthesizer"`` basename — there
+    is exactly one synthesizer per round, so no per-reviewer-name
+    collision risk.
+
+    Files written:
+
+    - ``synthesizer.stdout`` and ``synthesizer.stderr`` — always
+      created. Carry the captured codex subprocess streams when
+      :attr:`SynthesizerResult.raw_subprocess_result` is present;
+      empty when the failure happened before any subprocess output
+      (binary missing).
+    - ``synthesizer.parsed.json`` — written only when
+      ``synth_result.output is not None``. Pretty-printed via
+      :meth:`pydantic.BaseModel.model_dump_json(indent=2)` so the
+      file diffs cleanly across runs.
+    - ``synthesizer.error.txt`` — written only when
+      ``synth_result.error is not None``. Class name, message, and
+      traceback (when available).
+
+    Args:
+        round_dir: The round directory to write into. Must already
+            exist.
+        synth_result: The :class:`SynthesizerResult` from
+            :func:`syncade.synthesizer.run_synthesizer`.
+
+    Returns:
+        :class:`SynthesizerArtifactPaths` naming all written files.
+
+    Raises:
+        FileNotFoundError: If ``round_dir`` does not exist (caller
+            bug — the orchestrator creates it during run setup).
+    """
+    _validate_reviewer_filename_basename(SYNTHESIZER_NAME)
+    if not round_dir.is_dir():
+        raise FileNotFoundError(f"round_dir does not exist: {round_dir}")
+
+    base = round_dir / SYNTHESIZER_NAME
+
+    raw_result = synth_result.raw_subprocess_result
+    stdout_text = raw_result.stdout if raw_result is not None else ""
+    stderr_text = raw_result.stderr if raw_result is not None else ""
+    stdout_path = base.with_suffix(".stdout")
+    stderr_path = base.with_suffix(".stderr")
+    atomic_write_text(stdout_path, stdout_text)
+    atomic_write_text(stderr_path, stderr_text)
+
+    parsed_path: Path | None = None
+    if synth_result.output is not None:
+        parsed_path = base.with_suffix(".parsed.json")
+        atomic_write_text(parsed_path, synth_result.output.model_dump_json(indent=2))
+
+    error_path: Path | None = None
+    if synth_result.error is not None:
+        exc = synth_result.error
+        lines = [
+            f"{type(exc).__name__}: {exc}",
+            "",
+        ]
+        tb = exc.__traceback__
+        if tb is not None:
+            lines.extend(traceback.format_exception(type(exc), exc, tb))
+        else:
+            lines.append("(no traceback available — exception was constructed, not raised)")
+        error_path = base.with_suffix(".error.txt")
+        atomic_write_text(error_path, "\n".join(lines))
+
+    return SynthesizerArtifactPaths(
+        stdout=stdout_path,
+        stderr=stderr_path,
+        parsed=parsed_path,
+        error=error_path,
+    )
+
+
+def _synthesizer_manifest_entry(synth_result: SynthesizerResult | None) -> dict[str, object] | None:
+    """Build the ``synthesizer`` section of the round manifest.
+
+    Returns ``None`` when the synthesizer phase was skipped (any
+    reviewer failed); a dict otherwise.
+
+    Schema:
+
+    .. code-block:: json
+
+       {
+         "outcome": "success" | "failure",
+         "stdout_path": "synthesizer.stdout",
+         "stderr_path": "synthesizer.stderr",
+         "parsed_path": "synthesizer.parsed.json" | null,
+         "error_path": "synthesizer.error.txt" | null,
+         "duration_seconds": float,
+         "error_type": null | "ExceptionClassName",
+         "dismissed_count": int | null,
+         "active_blocker_count": int | null,
+         "active_minor_count": int | null,
+         "active_nit_count": int | null,
+         "provenance_repairs": [ {reviewer_name, original_index,
+                                  synthesizer_text, reviewer_text} ] | []
+       }
+
+    On success: counts populated, ``error_path`` AND ``error_type``
+    are null (no .error.txt was written; no exception class to
+    record).
+
+    On failure: counts are null, ``error_path`` names the .error.txt
+    artifact IFF persistence will actually write one — i.e. when
+    ``synth_result.error is not None``. ``SynthesizerResult`` enforces
+    exactly one of output/error at construction, so the null-error
+    fallback is defensive only.
+    """
+    if synth_result is None:
+        return None
+
+    paths = {
+        "provider": synth_result.provider or SYNTHESIZER_PROVIDER,
+        "model": synth_result.model
+        or (synth_result.usage.model if synth_result.usage is not None else SYNTHESIZER_MODEL),
+        "stdout_path": f"{SYNTHESIZER_NAME}.stdout",
+        "stderr_path": f"{SYNTHESIZER_NAME}.stderr",
+    }
+
+    if synth_result.output is not None:
+        consolidated = synth_result.output.consolidated_findings
+        dismissed = sum(1 for f in consolidated if f.dismissed)
+        active_by_sev = {"blocker": 0, "minor": 0, "nit": 0}
+        for f in consolidated:
+            if not f.dismissed:
+                active_by_sev[f.severity] += 1
+        return {
+            "outcome": "success",
+            **paths,
+            "parsed_path": f"{SYNTHESIZER_NAME}.parsed.json",
+            "error_path": None,
+            "duration_seconds": synth_result.duration_seconds,
+            **usage_fields(synth_result.usage),
+            # Include error_type on success (null) for schema symmetry;
+            # downstream tools don't have to KeyError-guard or treat absence as
+            # a separate signal.
+            "error_type": None,
+            "dismissed_count": dismissed,
+            "active_blocker_count": active_by_sev["blocker"],
+            "active_minor_count": active_by_sev["minor"],
+            "active_nit_count": active_by_sev["nit"],
+            # Non-empty means the synthesizer miscopied a source it had correctly
+            # attributed, and syncade corrected the quotation from the reviewer's own
+            # text (PR-h-field-01 item 5). Recorded rather than silent: it is a signal about
+            # that model's fidelity, and rewriting a model's output without saying so
+            # is not something to hide. Both strings are kept so the operator can judge.
+            "provenance_repairs": [
+                {
+                    "reviewer_name": r.reviewer_name,
+                    "original_index": r.original_index,
+                    "consolidated_index": r.consolidated_index,
+                    "provenance_index": r.provenance_index,
+                    "synthesizer_text": r.synthesizer_text,
+                    "reviewer_text": r.reviewer_text,
+                }
+                for r in synth_result.provenance_repairs
+            ],
+        }
+
+    # Failure path. error_path is null when no .error.txt will be
+    # written — that's the contract-violation case (output=None AND
+    # error=None) where persist_synthesizer_result intentionally
+    # skips the error.txt write. Without this guard the manifest
+    # would point at a file that doesn't exist on disk.
+    error_type = type(synth_result.error).__name__ if synth_result.error is not None else None
+    error_path = f"{SYNTHESIZER_NAME}.error.txt" if synth_result.error is not None else None
+    return {
+        "outcome": "failure",
+        **paths,
+        "parsed_path": None,
+        "error_path": error_path,
+        "duration_seconds": synth_result.duration_seconds,
+        **usage_fields(synth_result.usage),
+        "error_type": error_type,
+        "dismissed_count": None,
+        "active_blocker_count": None,
+        "active_minor_count": None,
+        "active_nit_count": None,
+        "provenance_repairs": [],
+    }

syncade/persistence/test_run.py

@@ -0,0 +1,152 @@
+"""Test re-run leg persistence.
+
+Writes ``<round_dir>/test-run.{stdout,stderr,exit-code.txt}`` and the
+matching round-manifest entry. The orchestrator only calls these on
+rounds where the operator configured ``[loop] test_command`` AND every
+prior phase succeeded AND the synthesizer was clean.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from syncade.test_runner import TestRunResult
+
+from ._atomic import atomic_write_text
+from ._validation import _validate_reviewer_filename_basename
+
+# Hardcoded basename for the test-leg artifacts. There is exactly one
+# test run per round, so no per-test-command collision risk. The
+# hardcoded basename also keeps the operator's ``test_command`` string
+# (which can be anything) entirely out of the filesystem layer —
+# manifest.json echoes the command but no file is ever named from it.
+TEST_RUN_NAME = "test-run"
+
+
+@dataclass(frozen=True)
+class TestRunArtifactPaths:
+    """Where the test re-run leg's artifacts land on disk.
+
+    Returned by :func:`persist_test_run_result` and attached to
+    :class:`~syncade.orchestrator.RunArtifacts` so the CLI / future
+    loop can address the files without re-deriving the layout
+    convention.
+
+    All three paths are absolute and rooted at ``<round_dir>``. They
+    are always written when the test leg ran (the orchestrator only
+    calls :func:`persist_test_run_result` on a non-None
+    ``test_result``); the unconfigured-leg path keeps the field
+    ``None`` on :class:`~syncade.orchestrator.RunArtifacts` so the
+    no-files-written-on-disk signal stays unambiguous.
+    """
+
+    stdout: Path
+    stderr: Path
+    exit_code: Path
+
+
+def persist_test_run_result(
+    round_dir: Path,
+    test_result: TestRunResult,
+) -> TestRunArtifactPaths:
+    """Write the test re-run leg's outputs to
+    ``<round_dir>/test-run.{stdout,stderr,exit-code.txt}``.
+
+    Mirrors :func:`persist_reviewer_result` and
+    :func:`persist_synthesizer_result`'s file-layout convention so a
+    tool inspecting the round directory sees the test artifacts in
+    the same shape as the per-reviewer and synthesizer artifacts.
+
+    Files written:
+
+    - ``test-run.stdout`` — captured test command stdout (whatever
+      reached the pipe buffer before the subprocess exited or was
+      killed). Empty on the subprocess-error path where the
+      subprocess never started (binary missing, bad cwd).
+    - ``test-run.stderr`` — captured test command stderr.
+    - ``test-run.exit-code.txt`` — one-line integer terminated by
+      ``\\n`` (``0`` for passed, the actual exit code for failed,
+      ``-1`` for subprocess error). Stored as a hardcoded basename
+      file rather than embedded only in ``manifest.json`` so a
+      shell-script consumer (CI integration, ``grep`` against the
+      round directory) can pull it without parsing JSON.
+
+    Args:
+        round_dir: The round directory to write into. Must already
+            exist (the orchestrator creates it during run setup).
+        test_result: The :class:`TestRunResult` from
+            :func:`syncade.test_runner.run_tests`. The caller (the
+            orchestrator) only calls this on a non-None test_result;
+            the unconfigured-leg path never reaches here.
+
+    Returns:
+        :class:`TestRunArtifactPaths` naming all three written files.
+
+    Raises:
+        FileNotFoundError: If ``round_dir`` does not exist (caller
+            bug — the orchestrator creates it during run setup).
+    """
+    _validate_reviewer_filename_basename(TEST_RUN_NAME)
+    if not round_dir.is_dir():
+        raise FileNotFoundError(f"round_dir does not exist: {round_dir}")
+
+    base = round_dir / TEST_RUN_NAME
+    stdout_path = base.with_suffix(".stdout")
+    stderr_path = base.with_suffix(".stderr")
+    # ``test-run.exit-code.txt`` — Path.with_suffix would replace the
+    # ``.stdout`` suffix wholesale, leaving us with
+    # ``test-run.exit-code.txt`` only if we hand-stitch. Build the
+    # filename directly rather than relying on with_suffix; the
+    # hardcoded basename keeps the layout self-explanatory.
+    exit_code_path = round_dir / f"{TEST_RUN_NAME}.exit-code.txt"
+
+    atomic_write_text(stdout_path, test_result.stdout)
+    atomic_write_text(stderr_path, test_result.stderr)
+    atomic_write_text(exit_code_path, f"{test_result.exit_code}\n")
+
+    return TestRunArtifactPaths(
+        stdout=stdout_path,
+        stderr=stderr_path,
+        exit_code=exit_code_path,
+    )
+
+
+def _test_run_manifest_entry(test_result: TestRunResult | None) -> dict[str, object] | None:
+    """Build the ``test_run`` section of the round manifest.
+
+    Returns ``None`` when the leg was skipped (either ``test_command``
+    is not configured OR a prior phase failed/produced blockers).
+    Returns a dict with the documented synthesizer schema otherwise.
+
+    Schema:
+
+    .. code-block:: json
+
+       {
+         "outcome": "passed" | "failed" | "subprocess_error",
+         "exit_code": 0 | int | -1,
+         "command": "<operator-configured string>",
+         "duration_seconds": float,
+         "stdout_path": "test-run.stdout",
+         "stderr_path": "test-run.stderr",
+         "exit_code_path": "test-run.exit-code.txt",
+         "error_type": null | "SubprocessTimeoutError" | ...
+       }
+
+    ``command`` is echoed verbatim from the operator's config so a
+    consumer reading manifest.json knows what was run without
+    cross-referencing back to ``.syncade/config.toml``.
+    """
+    if test_result is None:
+        return None
+    return {
+        "outcome": test_result.outcome,
+        "exit_code": test_result.exit_code,
+        "command": test_result.command,
+        "duration_seconds": test_result.duration_seconds,
+        "stdout_path": f"{TEST_RUN_NAME}.stdout",
+        "stderr_path": f"{TEST_RUN_NAME}.stderr",
+        "exit_code_path": f"{TEST_RUN_NAME}.exit-code.txt",
+        "error_type": (type(test_result.error).__name__ if test_result.error is not None else None),
+    }

syncade/presets.py

@@ -0,0 +1,36 @@
+"""Bundled config presets (PR-v2-9): ``--preset cheap|balanced|thorough``.
+
+Loads a packaged TOML preset as a plain ``dict`` — stdlib + importlib only, NO ``config`` import, so
+:func:`syncade.config_loader.load_config` can deep-merge it without a cycle. The preset is the run's
+BASE config; the user's ``.syncade/config.toml`` layers on top (user wins).
+
+Presets vary ONLY safe loop dimensions (rounds / timeout) and NEVER the reviewer model or effort
+tier — a cheaper panel that audits leniently is the pr-29 hazard. ``tests/config/test_presets.py``
+pins that: every preset yields the SAME reviewer roster as the shipped defaults, and ``balanced`` is
+behaviourally the defaults.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from importlib.resources import files
+
+# The bundled presets. Explicit (not directory-discovered) so ``--preset``'s argparse choices and
+# this tuple cannot drift, and an unrelated ``.toml`` dropped in the dir can't become a preset.
+PRESET_NAMES: tuple[str, ...] = ("cheap", "balanced", "thorough")
+
+
+class PresetError(Exception):
+    """An unknown ``--preset`` name (the CLI's argparse ``choices`` normally catches this first)."""
+
+
+def load_preset(name: str) -> dict:
+    """Return the bundled preset ``name`` as a parsed TOML dict.
+
+    Read via :func:`importlib.resources.files` so it resolves in both a source checkout and an
+    installed wheel. Raises :class:`PresetError` for an unknown name.
+    """
+    if name not in PRESET_NAMES:
+        raise PresetError(f"unknown preset {name!r}; choose from {list(PRESET_NAMES)}")
+    text = (files("syncade") / "templates" / "presets" / f"{name}.toml").read_text(encoding="utf-8")
+    return tomllib.loads(text)

syncade/pricing_config.py

@@ -0,0 +1,72 @@
+"""Config-driven per-model pricing (PR-v2-04).
+
+Codex reports tokens but no cost, so cost is derived here. Ships a conservative
+default table so zero-config runs still estimate cost (labeled ``"estimated"``);
+operators override via a ``[pricing]`` table in ``.syncade/config.toml``. Prices
+are list prices as of 2026-07 (USD per 1M tokens) and go stale — override for
+accuracy. Split into its own module (not ``config.py``, which is at its LOC cap).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelPrice(BaseModel):
+    """USD per 1M tokens for one model."""
+
+    model_config = ConfigDict(extra="forbid", allow_inf_nan=False)
+
+    input_per_mtok: float = Field(ge=0)
+    output_per_mtok: float = Field(ge=0)
+    cached_input_per_mtok: float | None = Field(
+        default=None, ge=0
+    )  # unset → priced at the input rate
+
+
+# List prices as of 2026-07 (USD / 1M tokens). Estimates — override via [pricing].
+DEFAULT_PRICES: dict[str, ModelPrice] = {
+    "claude-opus-4-8": ModelPrice(
+        input_per_mtok=15.0, output_per_mtok=75.0, cached_input_per_mtok=1.5
+    ),
+    "claude-sonnet-4-6": ModelPrice(
+        input_per_mtok=3.0, output_per_mtok=15.0, cached_input_per_mtok=0.3
+    ),
+    # No default uses gpt-5.6-sol any more (PR-28 put the reviewers + judge on it;
+    # PR-29 moved both back to gpt-5.5). It STAYS priced: runs 2026-07-11T15-36-39
+    # and 2026-07-12T10-04-35 ran on it, and `syncade --metrics` reads the whole
+    # historical corpus — dropping the entry would silently turn those runs' cost
+    # into "unknown". Prices are append-mostly for exactly this reason.
+    "gpt-5.6-sol": ModelPrice(input_per_mtok=5.0, output_per_mtok=30.0, cached_input_per_mtok=0.5),
+    # Codex-harness producer default.
+    "gpt-5.6-terra": ModelPrice(
+        input_per_mtok=2.5, output_per_mtok=15.0, cached_input_per_mtok=0.25
+    ),
+    "gpt-5.5": ModelPrice(input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125),
+    "gpt-5.4": ModelPrice(input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125),
+    "gpt-5.4-mini": ModelPrice(
+        input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125
+    ),
+    "gpt-5.3-codex": ModelPrice(
+        input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125
+    ),
+    "gpt-5.3-codex-spark": ModelPrice(
+        input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125
+    ),
+    "gpt-5.2": ModelPrice(input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125),
+    "gpt-5-codex": ModelPrice(
+        input_per_mtok=1.25, output_per_mtok=10.0, cached_input_per_mtok=0.125
+    ),
+}
+
+
+class PricingConfig(BaseModel):
+    """The ``[pricing]`` config section. A user-supplied ``models`` table replaces
+    the packaged default (provide the full table to override)."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    models: dict[str, ModelPrice] = Field(default_factory=lambda: dict(DEFAULT_PRICES))
+
+    def price_for(self, model: str) -> ModelPrice | None:
+        return self.models.get(model)