claude-code-generator 0.5.5__tar.gz → 0.5.7__tar.gz

{claude_code_generator-0.5.5/src/claude_code_generator.egg-info → claude_code_generator-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.5
+Version: 0.5.7
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.5.5"
+version = "0.5.7"
 description = "Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file."
 readme = "README.md"
 license = { text = "MIT" }

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.5
+Version: 0.5.7
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/claude_code_generator.egg-info/requires.txt
 src/claude_code_generator.egg-info/top_level.txt
 src/code_generator/__init__.py
 src/code_generator/agents.py
+src/code_generator/checklist.py
 src/code_generator/cli.py
 src/code_generator/effort.py
 src/code_generator/env.py
@@ -41,6 +42,7 @@ src/code_generator/gh/issues.py
 src/code_generator/gh/labels.py
 src/code_generator/gh/milestones.py
 src/code_generator/orchestrator/__init__.py
+src/code_generator/orchestrator/_cache_warmup.py
 src/code_generator/orchestrator/_client_lifecycle.py
 src/code_generator/orchestrator/_comments.py
 src/code_generator/orchestrator/_memory_writers.py
@@ -70,10 +72,14 @@ src/code_generator/prompts/prompt-review.md
 src/code_generator/runner/__init__.py
 src/code_generator/runner/_telemetry.py
 src/code_generator/runner/batch.py
+src/code_generator/runner/cache_breakpoints.py
+src/code_generator/runner/compaction_pause.py
 src/code_generator/runner/fake_runner.py
 src/code_generator/runner/mcp.py
+src/code_generator/runner/memory_tool.py
 src/code_generator/runner/message_parsing.py
 src/code_generator/runner/options.py
+src/code_generator/runner/phase_telemetry.py
 src/code_generator/runner/protocol.py
 src/code_generator/runner/rate_limit.py
 src/code_generator/runner/retry.py
@@ -97,12 +103,17 @@ tests/test_bench_compare.py
 tests/test_bench_export.py
 tests/test_bench_fixture.py
 tests/test_bench_regression.py
+tests/test_cache_breakpoints.py
+tests/test_cache_ttl_ordering.py
+tests/test_cache_warmup.py
 tests/test_changelog.py
+tests/test_checklist.py
 tests/test_claude_md.py
 tests/test_cli_io_logging.py
 tests/test_client_lifecycle.py
 tests/test_comments.py
 tests/test_commit_message.py
+tests/test_compaction_pause_handler.py
 tests/test_crash_recovery.py
 tests/test_cycle_loop.py
 tests/test_cycle_loop_multicycle.py
@@ -117,6 +128,7 @@ tests/test_docs_ollama_model_guide.py
 tests/test_docs_ollama_pro.py
 tests/test_effective_model_routing.py
 tests/test_effort.py
+tests/test_effort_routing_consistency.py
 tests/test_env.py
 tests/test_generate.py
 tests/test_generate_ollama.py
@@ -132,6 +144,7 @@ tests/test_logging_setup.py
 tests/test_max_turns_cli_flag.py
 tests/test_mcp.py
 tests/test_memory.py
+tests/test_memory_tool.py
 tests/test_memory_writers.py
 tests/test_message_parsing.py
 tests/test_no_max_turns_in_call_sites.py
@@ -144,12 +157,16 @@ tests/test_options.py
 tests/test_phase0.py
 tests/test_phase1.py
 tests/test_phase2.py
+tests/test_phase2_cache_regression.py
+tests/test_phase2_multicycle_token_reduction.py
+tests/test_phase2_token_reduction.py
 tests/test_phase3_4.py
 tests/test_phase5.py
 tests/test_phase5_precommit.py
 tests/test_phase6.py
 tests/test_phase7.py
 tests/test_phase_mcp_regression.py
+tests/test_phase_telemetry.py
 tests/test_phase_token_logging.py
 tests/test_preflight.py
 tests/test_preflight_ollama.py

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/code_generator/__init__.py

@@ -1,3 +1,3 @@
 """code-generator: orchestrator CLI for end-to-end project generation."""
 
-__version__ = "0.5.5"
+__version__ = "0.5.6"

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/code_generator/agents.py

@@ -74,6 +74,38 @@ _PYTHON_CLI = AgentSelection(
 )
 
 
+# ---------------------------------------------------------------------------
+# Extra-skill detection
+# ---------------------------------------------------------------------------
+
+_EXTRA_SKILL_KEYWORDS: tuple[tuple[tuple[str, ...], tuple[str, ...]], ...] = (
+    (("supabase",), ("supabase", "supabase-postgres-best-practices")),
+    (
+        ("skfolio", "portfolio optim", "efficient frontier", "mean-variance", "risk parity"),
+        ("skfolio",),
+    ),
+    (("yfinance", "yahoo finance", "ohlcv", "stock data", "ticker data"), ("yfinance",)),
+    (("xlsx", ".xlsx", " excel", "spreadsheet"), ("xlsx",)),
+    (("docx", ".docx", "word document"), ("docx",)),
+)
+
+
+def _detect_extra_skills(block: str) -> tuple[str, ...]:
+    extras: list[str] = []
+    for keywords, skills in _EXTRA_SKILL_KEYWORDS:
+        if any(kw in block for kw in keywords):
+            extras.extend(skills)
+    return tuple(extras)
+
+
+def _merge(base: AgentSelection, extras: tuple[str, ...]) -> AgentSelection:
+    if not extras:
+        return base
+    existing = set(base.skills)
+    new_skills = base.skills + tuple(s for s in extras if s not in existing)
+    return AgentSelection(primary=base.primary, support=base.support, skills=new_skills)
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -131,18 +163,16 @@ def detect(requirements_path: Path) -> AgentSelection:
     has_fastapi = "fastapi" in block or "python api" in block
 
     if has_angular and has_fastapi:
-        return _ANGULAR_FASTAPI
-
-    if has_angular:
-        return _ANGULAR_ONLY
-
-    if has_fastapi:
-        return _FASTAPI
-
-    if "baml" in block or "llm function" in block:
-        return _BAML
-
-    if "typer" in block or "click" in block or "python cli" in block:
-        return _PYTHON_CLI
-
-    return _GENERIC_FALLBACK
+        base = _ANGULAR_FASTAPI
+    elif has_angular:
+        base = _ANGULAR_ONLY
+    elif has_fastapi:
+        base = _FASTAPI
+    elif "baml" in block or "llm function" in block:
+        base = _BAML
+    elif "typer" in block or "click" in block or "python cli" in block:
+        base = _PYTHON_CLI
+    else:
+        base = _GENERIC_FALLBACK
+
+    return _merge(base, _detect_extra_skills(block))

claude_code_generator-0.5.7/src/code_generator/checklist.py

@@ -0,0 +1,121 @@
+"""Feature completion checklist (issue #249).
+
+Persists a JSON array of per-issue completion entries at
+``.code-generator/checklists/<requirements_hash>.json``. Phase 1 seeds the
+file; Phase 6 ticks ``tests_passed``; Phase 7 ticks ``committed``;
+``feature_done`` is derived (``tests_passed AND committed``) so the model
+cannot self-report completion.
+
+All writes follow the ``tmp → os.replace(tmp, path)`` pattern so a crash
+mid-write cannot corrupt the file. The module is orchestrator-only state —
+the SDK runner has no Write access to ``.code-generator/checklists/``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pathlib import Path
+
+    from code_generator.state import IssueState
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ChecklistEntry:
+    """One row in the per-feature completion checklist."""
+
+    issue_number: int
+    title: str
+    tests_passed: bool = False
+    committed: bool = False
+    feature_done: bool = False
+
+    def recompute_feature_done(self) -> None:
+        """Set ``feature_done`` from the two underlying flags."""
+        self.feature_done = self.tests_passed and self.committed
+
+
+def seed(path: Path, issues: Iterable[IssueState]) -> None:
+    """Atomically write the checklist for *issues* to *path* (idempotent).
+
+    Re-seeding with the same data is a no-op (file content stays byte-identical).
+    Re-seeding with new entries appends them while preserving any existing
+    ticks on the entries already in the file.
+    """
+    new_entries = [_entry_from_issue(issue) for issue in issues]
+    existing = {e.issue_number: e for e in load(path)}
+    merged: list[ChecklistEntry] = []
+    for fresh in new_entries:
+        prior = existing.get(fresh.issue_number)
+        merged.append(prior if prior is not None else fresh)
+    _atomic_write_json(path, [asdict(e) for e in merged])
+
+
+def load(path: Path) -> list[ChecklistEntry]:
+    """Return the checklist entries; ``[]`` when the file is absent."""
+    if not path.exists():
+        return []
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    return [_entry_from_dict(item) for item in raw]
+
+
+def tick_tests_passed(path: Path, issue_number: int) -> None:
+    """Set ``tests_passed=True`` on *issue_number*; recompute ``feature_done``."""
+    _tick(path, issue_number, "tests_passed")
+
+
+def tick_committed(path: Path, issue_number: int) -> None:
+    """Set ``committed=True`` on *issue_number*; recompute ``feature_done``."""
+    _tick(path, issue_number, "committed")
+
+
+def done_total(path: Path) -> tuple[int, int]:
+    """Return ``(feature_done_count, total_entries)`` — used by ``status``."""
+    entries = load(path)
+    return sum(1 for e in entries if e.feature_done), len(entries)
+
+
+def _tick(path: Path, issue_number: int, field: str) -> None:
+    """Mutate *field* to True for *issue_number*; warn + no-op when missing."""
+    entries = load(path)
+    target = next((e for e in entries if e.issue_number == issue_number), None)
+    if target is None:
+        _logger.warning(
+            "checklist tick: issue_number=%s not found in %s — no-op.",
+            issue_number,
+            path,
+        )
+        return
+    setattr(target, field, True)
+    target.recompute_feature_done()
+    _atomic_write_json(path, [asdict(e) for e in entries])
+
+
+def _entry_from_issue(issue: IssueState) -> ChecklistEntry:
+    return ChecklistEntry(issue_number=issue.number, title=issue.title)
+
+
+def _entry_from_dict(item: dict) -> ChecklistEntry:
+    return ChecklistEntry(
+        issue_number=int(item["issue_number"]),
+        title=str(item.get("title", "")),
+        tests_passed=bool(item.get("tests_passed", False)),
+        committed=bool(item.get("committed", False)),
+        feature_done=bool(item.get("feature_done", False)),
+    )
+
+
+def _atomic_write_json(path: Path, payload: list[dict]) -> None:
+    """``tmp.write_text(...) → os.replace(tmp, path)`` atomic write."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    tmp_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    os.replace(tmp_path, path)

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/code_generator/commands/_bench_io.py

@@ -17,7 +17,12 @@ if TYPE_CHECKING:
 
 # Bump this + add a migration note for any breaking schema change.
 # v2 (issue #212): per-phase dicts + totals now include ``num_turns``.
-SCHEMA_VERSION: int = 2
+# v3 (issue #248): per-phase dicts + totals add ``cache_write_5m``,
+#   ``cache_write_1h``, ``compaction_events``, ``clear_events``, and
+#   ``cache_hit_ratio`` (0.0-1.0 float). v2 readers still parse the original
+#   keys; v3 readers should fall back to ``.get(metric)`` so cross-version
+#   comparisons surface ``None`` rather than ``KeyError``.
+SCHEMA_VERSION: int = 3
 
 
 def write_output(path: Path | None, payload: dict[str, Any]) -> None:

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/code_generator/commands/_dispatch.py

@@ -19,6 +19,7 @@ import typer
 from code_generator import memory as _memory
 from code_generator.commands._crash_recovery import check_and_log_crash_recovery
 from code_generator.commands._resume import next_start_phase, resolve_continue_multi_cycle
+from code_generator.state import CycleState
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -36,14 +37,51 @@ __all__ = ["dispatch_async", "dispatch_orchestrator"]
 
 _GRAPHIFY_TIMEOUT = int(os.environ.get("CODE_GENERATOR_GRAPHIFY_TIMEOUT", "600"))
 
+_GRAPHIFY_EXTRACT_CMD = ["graphify", "extract", "."]
+_GRAPHIFY_UPDATE_CMD = ["graphify", "update", "."]
 
 _SETUP_HINT = (
-    "graph-report: graphify-out/graph.json not found — run `/graphify .` once "
-    "inside Claude Code (or another graphify-compatible assistant) to seed the "
-    "knowledge graph. After that, code-generator will keep it fresh "
-    "automatically with `graphify update .`. Using fallback for now."
+    "graph-report: headless extraction via `graphify extract .` was attempted "
+    "automatically but failed — ensure graphify >= 0.7.3 is installed "
+    "(`pipx install graphifyy`) or run `/graphify .` once inside Claude Code "
+    "to seed the knowledge graph manually. Using fallback for now."
 )
 
+_GRAPHIFY_MIN_VERSION = (0, 7, 3)
+_GRAPHIFY_UPGRADE_HINT = (
+    "upgrade for headless seeding and v0.5.5 workaround removal: pip install -U graphifyy"
+)
+
+
+def _parse_version_line(stdout: str) -> str | None:
+    """Return 'X.Y.Z' from pip-show stdout, or None when the line is absent."""
+    for line in stdout.splitlines():
+        if line.startswith("Version:"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def _get_graphify_version_str() -> str | None:
+    """Probe installed graphifyy version via pip show; None on any failure."""
+    try:
+        result = subprocess.run(
+            ["pip", "show", "graphifyy"], capture_output=True, text=True, check=False
+        )
+        return _parse_version_line(result.stdout or "")
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def _probe_graphify_version(log: logging.Logger) -> None:
+    """Warn when graphify is below _GRAPHIFY_MIN_VERSION or undetectable."""
+    version_str = _get_graphify_version_str()
+    if version_str is None:
+        log.warning("graph-report: graphify version unknown — %s", _GRAPHIFY_UPGRADE_HINT)
+        return
+    version = tuple(int(p) for p in version_str.split(".") if p.isdigit())
+    if version < _GRAPHIFY_MIN_VERSION:
+        log.warning("graph-report: graphify %s detected — %s", version_str, _GRAPHIFY_UPGRADE_HINT)
+
 
 def _decode_stderr(stderr: bytes | str | None) -> str:
     """Decode subprocess stderr to a short single-line string for logging."""
@@ -54,42 +92,65 @@ def _decode_stderr(stderr: bytes | str | None) -> str:
     return text[:500]
 
 
-def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) -> None:
-    """Refresh the codebase graph via graphify and persist the report.
+def _extract_argv(ollama_model: str | None) -> list[str]:
+    """Build graphify extract argv, appending --backend ollama on the Ollama path."""
+    if ollama_model is not None:
+        return [*_GRAPHIFY_EXTRACT_CMD, "--backend", "ollama"]
+    return list(_GRAPHIFY_EXTRACT_CMD)
 
-    Graphify's shell CLI does **not** support a "build" subcommand — the full
-    LLM-driven build only happens through the ``/graphify`` slash-command
-    inside an AI assistant (Claude Code, Codex, Cursor, etc.).  The shell
-    binary only supports maintenance subcommands like ``update``, ``watch``,
-    ``query``.
+
+def _run_graphify(
+    cmd: list[str],
+    project_dir: Path,
+    log: logging.Logger,
+    memories_dir: Path,
+) -> bool:
+    """Run a graphify subprocess. Write fallback and return False on any error."""
+    try:
+        log.info("graph-report: running %s", " ".join(cmd))
+        subprocess.run(  # noqa: S603
+            cmd,
+            cwd=project_dir,
+            timeout=_GRAPHIFY_TIMEOUT,
+            capture_output=True,
+            check=True,
+        )
+        return True
+    except subprocess.CalledProcessError as exc:
+        stderr = _decode_stderr(exc.stderr)
+        log.warning(
+            "graph-report: graphify exited %d; using fallback. stderr: %s",
+            exc.returncode,
+            stderr or "<empty>",
+        )
+    except subprocess.TimeoutExpired as exc:
+        log.warning("graph-report: graphify timed out after %ss; using fallback", exc.timeout)
+    except (FileNotFoundError, OSError) as exc:
+        log.warning("graph-report: could not invoke graphify (%s); using fallback", exc)
+    _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
+    return False
+
+
+def _compute_and_persist_graph_report(
+    project_dir: Path, log: logging.Logger, *, ollama_model: str | None = None
+) -> None:
+    """Refresh the codebase graph via graphify and persist the report.
 
     Strategy:
 
-    1. If ``graphify-out/graph.json`` does **not** exist, the user has never
-       seeded the graph.  Log a one-time setup hint, write the fallback
-       sentinel, and return — do not call subprocess.  The user must run
-       ``/graphify .`` in their assistant once to seed it.
+    1. If ``graphify-out/graph.json`` does **not** exist, run
+       ``graphify extract .`` (headless LLM-driven seeding, requires >= 0.7.3).
+       On success, read ``GRAPH_REPORT.md`` and persist.  On failure, write the
+       fallback sentinel and emit :data:`_SETUP_HINT`.
 
-    2. If it exists, run ``graphify update .`` (cwd=project_dir).  This is
-       AST-only re-extraction, no LLM cost, fast on cached files.  It
-       refreshes ``graph.json`` and ``GRAPH_REPORT.md``.  Doc / paper /
-       image changes are *not* picked up — for those the user must run
-       ``/graphify .`` again in their assistant.
+    2. If it exists, run ``graphify update .`` (AST-only refresh, no LLM cost).
+       Refreshes ``graph.json`` and ``GRAPH_REPORT.md``.
 
     Falls back to :data:`code_generator.memory.REPOMAP_FALLBACK` on any
     failure (binary missing, timeout, non-zero exit, missing report file).
-    Stderr from graphify is captured and logged at WARN level on failure so
-    the user can diagnose without re-running by hand.
-
-    Auth: graphify inherits the parent process env. ``graphify update`` is
-    AST-only and makes no LLM calls, so OAuth context is irrelevant on this
-    codepath — but we still don't strip ``ANTHROPIC_*`` because the startup
-    ``env.assert_safe_environment()`` check (CLAUDE.md non-negotiable #1)
-    already guarantees those vars are absent on the Anthropic Max path.
 
     Args:
-        project_dir: Project root directory (graphify writes ``graphify-out/``
-            into this directory).
+        project_dir: Project root directory.
         log: Phase logger.
     """
     memories_dir = project_dir / ".code-generator" / "memories"
@@ -105,42 +166,14 @@ def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) ->
         return
 
     if not graph_json.exists():
-        log.info(_SETUP_HINT)
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
-
-    cmd = ["graphify", "update", "."]
-    try:
-        log.info("graph-report: refreshing (cmd=%s)", " ".join(cmd))
-        subprocess.run(  # noqa: S603
-            cmd,
-            cwd=project_dir,
-            timeout=_GRAPHIFY_TIMEOUT,
-            capture_output=True,
-            check=True,
-        )
-    except subprocess.CalledProcessError as exc:
-        stderr = _decode_stderr(exc.stderr)
-        log.warning(
-            "graph-report: graphify exited %d; using fallback. stderr: %s",
-            exc.returncode,
-            stderr or "<empty>",
-        )
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
-    except subprocess.TimeoutExpired as exc:
-        log.warning(
-            "graph-report: graphify timed out after %ss; using fallback",
-            exc.timeout,
-        )
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
-    except (FileNotFoundError, OSError) as exc:
-        # `FileNotFoundError` here means the `graphify` binary disappeared
-        # between `shutil.which` and `subprocess.run`. Extremely unlikely.
-        log.warning("graph-report: could not invoke graphify (%s); using fallback", exc)
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
+        log.info("graph-report: graph.json absent — attempting headless extraction")
+        if not _run_graphify(_extract_argv(ollama_model), project_dir, log, memories_dir):
+            log.info(_SETUP_HINT)
+            return
+    else:
+        _probe_graphify_version(log)
+        if not _run_graphify(_GRAPHIFY_UPDATE_CMD, project_dir, log, memories_dir):
+            return
 
     try:
         content = report_path.read_text(encoding="utf-8")
@@ -207,6 +240,8 @@ def _reset_failed_cycles_for_continue(
 
     reset_ids: list[int] = []
     for c in st.cycles:
+        if not isinstance(c, CycleState):
+            continue
         if c.status != "failed":
             continue
         if target_cycle is not None and c.id != target_cycle:
@@ -275,7 +310,9 @@ async def _apply_delta_plan(
             "Phase 0 failed during delta planning; aborting to preserve cycle history."
         )
 
-    new_cycles = state_module.append_new_cycles(st, raw_cycles)
+    new_cycles = state_module.append_new_cycles(
+        st, raw_cycles, ollama_model=effective_model
+    )
 
     if not new_cycles:
         logger.info("Delta planning: no new cycles detected.")
@@ -330,7 +367,7 @@ async def dispatch_async(
     # Build the codebase graph once at the top of dispatch so Phase 0
     # (complexity analysis) sees a fresh report alongside Phases 1 and 2.
     graph_logger = setup_phase_logger("graph-report", project_dir)
-    _compute_and_persist_graph_report(project_dir, graph_logger)
+    _compute_and_persist_graph_report(project_dir, graph_logger, ollama_model=ollama_model)
 
     # Phase 0: determine mode when not already known.
     if mode == "auto":
@@ -343,7 +380,7 @@ async def dispatch_async(
     # Delta planning: multi-cycle with completed cycles needs a merge, not a
     # fresh Phase 0 run.  Single-mode delta is handled upstream (mode reset to
     # "unknown" forces Phase 0 to re-run via needs_phase0=True).
-    completed = [c for c in st.cycles if c.status == "completed"]
+    completed = [c for c in st.cycles if isinstance(c, CycleState) and c.status == "completed"]
     if delta_hash is not None and st.mode == "multi-cycle" and completed and state_path is not None:
         first_new_id = await _apply_delta_plan(
             st,
@@ -504,7 +541,9 @@ def dispatch_orchestrator(
             state_module.save_state(state_path, st)
 
         elif run_mode == "delta":
-            completed = [c for c in st.cycles if c.status == "completed"]
+            completed = [
+                c for c in st.cycles if isinstance(c, CycleState) and c.status == "completed"
+            ]
             if st.mode == "multi-cycle" and completed:
                 # Defer hash update to async path — atomicity requires Phase 0
                 # to succeed before we store the new hash.

{claude_code_generator-0.5.5 → claude_code_generator-0.5.7}/src/code_generator/commands/bench.py

@@ -4,10 +4,19 @@ Signature:
     code-generator bench [--fake|--real] [--session-mode fresh|shared]
                          [--cycles N] [--fixture PATH] [--output FILE]
 
-Output schema (schema_version=1):
+Output schema (schema_version=3, see _bench_io.SCHEMA_VERSION):
     {schema_version, timestamp_utc, session_mode, fixture,
-     cycles: [{cycle_name, phases: {"0"…"7": {input, output,
-     cache_read, cache_write, cache_hit_pct, wall_seconds}}, totals}]}
+     cycles: [{cycle_name,
+               phases: {"0"…"7": {input, output, cache_read, cache_write,
+                                  cache_hit_pct, wall_seconds, num_turns,
+                                  cache_write_5m, cache_write_1h,
+                                  compaction_events, clear_events,
+                                  cache_hit_ratio}},
+               totals}]}
+
+v3 (issue #248): added the TTL split (cache_write_5m / cache_write_1h), the
+SDK lifecycle counters (compaction_events / clear_events), and the 0.0-1.0
+``cache_hit_ratio`` float used by ``bench compare`` for regression flagging.
 
 Bump schema_version + add a migration note for any breaking change.
 """
@@ -49,11 +58,20 @@ _LOGGER = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 
 
+def _cache_hit_ratio(cache_read: int, cache_write: int, input_tokens: int) -> float:
+    """Return the 0–1 cache hit ratio (issue #248). Zero denominator → 0.0."""
+    denominator = cache_read + cache_write + input_tokens
+    if denominator <= 0:
+        return 0.0
+    return cache_read / denominator
+
+
 def _phase_metrics(result: RunResult) -> dict[str, int | float]:
-    """Convert a RunResult into the seven-key phase-metrics dict (schema v2).
+    """Convert a RunResult into the v3 phase-metrics dict (issue #248).
 
-    Includes ``num_turns`` as of issue #212 so operators can see per-phase
-    agent-loop turn counts alongside the four token counters.
+    v3 adds the TTL split (``cache_write_5m`` / ``cache_write_1h``), the SDK
+    lifecycle counters (``compaction_events`` / ``clear_events``), and the
+    0.0-1.0 ``cache_hit_ratio`` float alongside the existing v2 keys.
     """
     u = result.usage
     denominator = u.cache_read + u.cache_write + u.input
@@ -66,14 +84,20 @@ def _phase_metrics(result: RunResult) -> dict[str, int | float]:
         "cache_hit_pct": hit_pct,
         "wall_seconds": result.wall_seconds,
         "num_turns": u.num_turns,
+        "cache_write_5m": u.cache_write_5m,
+        "cache_write_1h": u.cache_write_1h,
+        "compaction_events": u.compaction_events,
+        "clear_events": u.clear_events,
+        "cache_hit_ratio": _cache_hit_ratio(u.cache_read, u.cache_write, u.input),
     }
 
 
 def _aggregate_totals(phases: dict[str, dict[str, int | float]]) -> dict[str, int | float]:
-    """Sum per-phase metrics into cycle-level totals with recomputed cache_hit_pct."""
+    """Sum per-phase metrics into cycle-level totals with recomputed ratios."""
     total_input = total_output = total_read = total_write = 0
     total_turns = 0
     total_wall = 0.0
+    total_5m = total_1h = total_compaction = total_clear = 0
     for m in phases.values():
         total_input += int(m["input"])
         total_output += int(m["output"])
@@ -81,6 +105,10 @@ def _aggregate_totals(phases: dict[str, dict[str, int | float]]) -> dict[str, in
         total_write += int(m["cache_write"])
         total_turns += int(m.get("num_turns", 0))
         total_wall += float(m["wall_seconds"])
+        total_5m += int(m.get("cache_write_5m", 0))
+        total_1h += int(m.get("cache_write_1h", 0))
+        total_compaction += int(m.get("compaction_events", 0))
+        total_clear += int(m.get("clear_events", 0))
 
     denominator = total_read + total_write + total_input
     hit_pct = round(total_read / denominator * 100, 1) if denominator else 0.0
@@ -92,6 +120,11 @@ def _aggregate_totals(phases: dict[str, dict[str, int | float]]) -> dict[str, in
         "cache_hit_pct": hit_pct,
         "wall_seconds": total_wall,
         "num_turns": total_turns,
+        "cache_write_5m": total_5m,
+        "cache_write_1h": total_1h,
+        "compaction_events": total_compaction,
+        "clear_events": total_clear,
+        "cache_hit_ratio": _cache_hit_ratio(total_read, total_write, total_input),
     }