claude-code-generator 0.1.0__tar.gz → 0.2.0__tar.gz

{claude_code_generator-0.1.0/src/claude_code_generator.egg-info → claude_code_generator-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.1.0
+Version: 0.2.0
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -80,7 +80,9 @@ Read `.code-generator/requirements.md` and orchestrate Claude Code through the 0
 | 3-4 | Implementation, fresh SDK session per issue (TDD) | Sonnet 4.6 |
 | 5 | Closure + cross-module review | Opus 4.6 |
 | 6 | Test suite, max 3 retries on failure | Sonnet 4.6 |
-| 7 | Commit message + git add/commit/push | Haiku 4.5 |
+| 7 | Commit message + git add/commit/push | Opus 4.6 |
+
+Every phase logs a completion summary with token counts (`in`, `cache_read`, `cache_write`, `out`) and persists them to `state.json`.
 
 Flags:
 
@@ -102,7 +104,7 @@ Run a standalone Opus 4.6 review of the current codebase against the design prin
 
 ### `code-generator status`
 
-Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), and the last error.
+Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), per-cycle token consumption columns (`in | cache_read | cache_write | out`), wall-clock elapsed time, and any `last_error` highlighted in red.
 
 ## Safety constraints
 
@@ -115,7 +117,7 @@ The tool enforces eight non-negotiables (see `CLAUDE.md` for the full list):
 5. **Wait-and-resume rate-limit handling.** Rate limits are not retried with exponential backoff — the tool sleeps until `resets_at + 60s` and resumes the same session. Backoff (10→20→40→80→120s) only applies to non-rate-limit transient errors.
 6. **Fresh SDK session per issue.** The implementation phase never reuses conversational context across issues — each issue is a `/clear`-equivalent fresh session.
 7. **Atomic state writes.** `.code-generator/state.json` is updated via `tmp → os.replace(tmp, STATE)` so a crash mid-write cannot corrupt it.
-8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5; Sonnet 4.6 for phases 3/4/6; Haiku 4.5 for phase 7's commit message.
+8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5/7; Sonnet 4.6 for phases 3/4/6.
 
 ## Troubleshooting
 
@@ -151,7 +153,7 @@ src/code_generator/
 │   ├── phase3_4_implement.py # TDD loop, fresh session per issue
 │   ├── phase5_closure.py     # closure + fix-issue feedback loop
 │   ├── phase6_test.py        # test runner, max 3 retries
-│   ├── phase7_commit.py      # Haiku commit message + push with rebase retry
+│   ├── phase7_commit.py      # Opus commit message + push with rebase retry
 │   └── cycle_loop.py         # multi-cycle driver
 └── commands/             # init, status, generate, review (Typer commands)
 ```

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0}/README.md

@@ -49,7 +49,9 @@ Read `.code-generator/requirements.md` and orchestrate Claude Code through the 0
 | 3-4 | Implementation, fresh SDK session per issue (TDD) | Sonnet 4.6 |
 | 5 | Closure + cross-module review | Opus 4.6 |
 | 6 | Test suite, max 3 retries on failure | Sonnet 4.6 |
-| 7 | Commit message + git add/commit/push | Haiku 4.5 |
+| 7 | Commit message + git add/commit/push | Opus 4.6 |
+
+Every phase logs a completion summary with token counts (`in`, `cache_read`, `cache_write`, `out`) and persists them to `state.json`.
 
 Flags:
 
@@ -71,7 +73,7 @@ Run a standalone Opus 4.6 review of the current codebase against the design prin
 
 ### `code-generator status`
 
-Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), and the last error.
+Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), per-cycle token consumption columns (`in | cache_read | cache_write | out`), wall-clock elapsed time, and any `last_error` highlighted in red.
 
 ## Safety constraints
 
@@ -84,7 +86,7 @@ The tool enforces eight non-negotiables (see `CLAUDE.md` for the full list):
 5. **Wait-and-resume rate-limit handling.** Rate limits are not retried with exponential backoff — the tool sleeps until `resets_at + 60s` and resumes the same session. Backoff (10→20→40→80→120s) only applies to non-rate-limit transient errors.
 6. **Fresh SDK session per issue.** The implementation phase never reuses conversational context across issues — each issue is a `/clear`-equivalent fresh session.
 7. **Atomic state writes.** `.code-generator/state.json` is updated via `tmp → os.replace(tmp, STATE)` so a crash mid-write cannot corrupt it.
-8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5; Sonnet 4.6 for phases 3/4/6; Haiku 4.5 for phase 7's commit message.
+8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5/7; Sonnet 4.6 for phases 3/4/6.
 
 ## Troubleshooting
 
@@ -120,7 +122,7 @@ src/code_generator/
 │   ├── phase3_4_implement.py # TDD loop, fresh session per issue
 │   ├── phase5_closure.py     # closure + fix-issue feedback loop
 │   ├── phase6_test.py        # test runner, max 3 retries
-│   ├── phase7_commit.py      # Haiku commit message + push with rebase retry
+│   ├── phase7_commit.py      # Opus commit message + push with rebase retry
 │   └── cycle_loop.py         # multi-cycle driver
 └── commands/             # init, status, generate, review (Typer commands)
 ```

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.1.0"
+version = "0.2.0"
 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" }
@@ -69,3 +69,7 @@ ignore = []
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 asyncio_mode = "auto"
+
+[tool.pyright]
+# Test mocks intentionally use unused parameters to match the production interface signature.
+reportUnusedParameter = "none"

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.1.0
+Version: 0.2.0
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -80,7 +80,9 @@ Read `.code-generator/requirements.md` and orchestrate Claude Code through the 0
 | 3-4 | Implementation, fresh SDK session per issue (TDD) | Sonnet 4.6 |
 | 5 | Closure + cross-module review | Opus 4.6 |
 | 6 | Test suite, max 3 retries on failure | Sonnet 4.6 |
-| 7 | Commit message + git add/commit/push | Haiku 4.5 |
+| 7 | Commit message + git add/commit/push | Opus 4.6 |
+
+Every phase logs a completion summary with token counts (`in`, `cache_read`, `cache_write`, `out`) and persists them to `state.json`.
 
 Flags:
 
@@ -102,7 +104,7 @@ Run a standalone Opus 4.6 review of the current codebase against the design prin
 
 ### `code-generator status`
 
-Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), and the last error.
+Print a Rich table with the current mode, current cycle, current phase, open/closed issue counts, the rate-limit pause state (with minutes remaining if paused), per-cycle token consumption columns (`in | cache_read | cache_write | out`), wall-clock elapsed time, and any `last_error` highlighted in red.
 
 ## Safety constraints
 
@@ -115,7 +117,7 @@ The tool enforces eight non-negotiables (see `CLAUDE.md` for the full list):
 5. **Wait-and-resume rate-limit handling.** Rate limits are not retried with exponential backoff — the tool sleeps until `resets_at + 60s` and resumes the same session. Backoff (10→20→40→80→120s) only applies to non-rate-limit transient errors.
 6. **Fresh SDK session per issue.** The implementation phase never reuses conversational context across issues — each issue is a `/clear`-equivalent fresh session.
 7. **Atomic state writes.** `.code-generator/state.json` is updated via `tmp → os.replace(tmp, STATE)` so a crash mid-write cannot corrupt it.
-8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5; Sonnet 4.6 for phases 3/4/6; Haiku 4.5 for phase 7's commit message.
+8. **Fixed model per phase.** Opus 4.6 for phases 0/1/2/5/7; Sonnet 4.6 for phases 3/4/6.
 
 ## Troubleshooting
 
@@ -151,7 +153,7 @@ src/code_generator/
 │   ├── phase3_4_implement.py # TDD loop, fresh session per issue
 │   ├── phase5_closure.py     # closure + fix-issue feedback loop
 │   ├── phase6_test.py        # test runner, max 3 retries
-│   ├── phase7_commit.py      # Haiku commit message + push with rebase retry
+│   ├── phase7_commit.py      # Opus commit message + push with rebase retry
 │   └── cycle_loop.py         # multi-cycle driver
 └── commands/             # init, status, generate, review (Typer commands)
 ```

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -10,16 +10,28 @@ src/claude_code_generator.egg-info/top_level.txt
 src/code_generator/__init__.py
 src/code_generator/agents.py
 src/code_generator/cli.py
+src/code_generator/effort.py
 src/code_generator/env.py
-src/code_generator/gh.py
+src/code_generator/git_ops.py
 src/code_generator/logging_setup.py
+src/code_generator/requirements_structure.py
 src/code_generator/state.py
 src/code_generator/commands/__init__.py
+src/code_generator/commands/_detect.py
+src/code_generator/commands/_dispatch.py
+src/code_generator/commands/_resume.py
 src/code_generator/commands/generate.py
 src/code_generator/commands/init.py
+src/code_generator/commands/optimize.py
 src/code_generator/commands/review.py
 src/code_generator/commands/status.py
+src/code_generator/gh/__init__.py
+src/code_generator/gh/core.py
+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/_comments.py
 src/code_generator/orchestrator/cycle_loop.py
 src/code_generator/orchestrator/phase0_complexity.py
 src/code_generator/orchestrator/phase1_plan.py
@@ -29,6 +41,7 @@ src/code_generator/orchestrator/phase5_closure.py
 src/code_generator/orchestrator/phase6_test.py
 src/code_generator/orchestrator/phase7_commit.py
 src/code_generator/prompts/__init__.py
+src/code_generator/prompts/prompt-optimize-requirements.md
 src/code_generator/prompts/prompt-phase-0-complexity.md
 src/code_generator/prompts/prompt-phase-1-planning.md
 src/code_generator/prompts/prompt-phase-2-issue-review.md
@@ -38,10 +51,15 @@ src/code_generator/prompts/prompt-phase-6-test.md
 src/code_generator/prompts/prompt-phase-7-commit.md
 src/code_generator/prompts/prompt-review.md
 src/code_generator/runner/__init__.py
+src/code_generator/runner/message_parsing.py
+src/code_generator/runner/options.py
+src/code_generator/runner/protocol.py
 src/code_generator/runner/rate_limit.py
 src/code_generator/runner/retry.py
 src/code_generator/runner/sdk_runner.py
 src/code_generator/runner/subprocess_runner.py
+src/code_generator/runner/types.py
+src/code_generator/runner/utils.py
 src/code_generator/templates/__init__.py
 src/code_generator/templates/angular.md
 src/code_generator/templates/base.md
@@ -51,13 +69,26 @@ src/code_generator/templates/fullstack.md
 src/code_generator/templates/nestjs.md
 src/code_generator/templates/python-cli.md
 tests/test_agents.py
+tests/test_comments.py
+tests/test_commit_message.py
 tests/test_cycle_loop.py
+tests/test_cycle_loop_multicycle.py
+tests/test_delta_planning.py
+tests/test_detect.py
+tests/test_effort.py
 tests/test_env.py
 tests/test_generate.py
 tests/test_generate_resume.py
 tests/test_gh.py
+tests/test_gh_labels.py
+tests/test_gh_milestones.py
+tests/test_gh_submodules.py
+tests/test_git_ops.py
 tests/test_init.py
 tests/test_logging_setup.py
+tests/test_message_parsing.py
+tests/test_optimize.py
+tests/test_options.py
 tests/test_phase0.py
 tests/test_phase1.py
 tests/test_phase2.py
@@ -65,10 +96,16 @@ tests/test_phase3_4.py
 tests/test_phase5.py
 tests/test_phase6.py
 tests/test_phase7.py
+tests/test_phase_token_logging.py
 tests/test_prompts.py
 tests/test_rate_limit.py
+tests/test_requirements_structure.py
 tests/test_retry.py
 tests/test_review.py
+tests/test_runner_protocol.py
+tests/test_runner_protocol_annotations.py
+tests/test_runner_types.py
+tests/test_runner_utils.py
 tests/test_sdk_runner.py
 tests/test_state.py
 tests/test_status.py

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0}/src/code_generator/__init__.py

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

{claude_code_generator-0.1.0 → claude_code_generator-0.2.0}/src/code_generator/cli.py

@@ -11,6 +11,7 @@ import typer
 import code_generator
 from code_generator.commands.generate import generate_command
 from code_generator.commands.init import init_command
+from code_generator.commands.optimize import optimize_command
 from code_generator.commands.review import review_command
 from code_generator.commands.status import status_command
 
@@ -46,4 +47,5 @@ def root(
 app.command(name="init")(init_command)
 app.command(name="status")(status_command)
 app.command(name="generate")(generate_command)
+app.command(name="optimize")(optimize_command)
 app.command(name="review")(review_command)

claude_code_generator-0.2.0/src/code_generator/commands/_detect.py

@@ -0,0 +1,59 @@
+"""Re-run detection for the generate command.
+
+Compares the current requirements.md hash against the stored hash in state to
+decide the correct execution path on startup.
+
+The sole exported function is a pure function (no I/O) so it is trivially
+unit-testable.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from code_generator import state as state_module
+
+RunMode = Literal["first-run", "resume", "no-op", "delta"]
+
+__all__ = ["RunMode", "detect_run_mode"]
+
+
+def _run_is_complete(state: state_module.State) -> bool:
+    """Return True when the generation run is fully complete.
+
+    Single mode: complete when phase == 7 (final commit phase).
+    Multi-cycle mode: complete when every cycle has status "completed"
+    and at least one cycle exists.
+    """
+    if state.mode == "multi-cycle":
+        return len(state.cycles) > 0 and all(c.status == "completed" for c in state.cycles)
+    return state.phase == 7
+
+
+def detect_run_mode(state: state_module.State, current_hash: str) -> RunMode:
+    """Determine how the generate command should proceed given existing state.
+
+    This is a pure function: it reads ``state`` and ``current_hash`` and
+    returns a decision literal.  It never performs I/O.
+
+    Decision rules (evaluated in order):
+    1. No stored hash → ``"first-run"`` (treat as a brand-new run)
+    2. Hashes differ  → ``"delta"``     (requirements changed)
+    3. Run complete   → ``"no-op"``     (nothing left to do)
+    4. Otherwise      → ``"resume"``    (same requirements, incomplete run)
+
+    Args:
+        state: Loaded root state (may have requirements_hash=None for old runs).
+        current_hash: SHA-256 hex digest of the current requirements.md.
+
+    Returns:
+        One of ``"first-run"``, ``"resume"``, ``"no-op"``, or ``"delta"``.
+    """
+    if state.requirements_hash is None:
+        return "first-run"
+    if state.requirements_hash != current_hash:
+        return "delta"
+    if _run_is_complete(state):
+        return "no-op"
+    return "resume"

claude_code_generator-0.2.0/src/code_generator/commands/_dispatch.py

@@ -0,0 +1,278 @@
+"""Dispatch helpers for the generate command.
+
+Handles resolving resume parameters from CLI flags and delegating to the
+async orchestration pipeline.  Separated from the Typer command definition
+so both layers can be tested in isolation.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+import typer
+
+from code_generator.commands._resume import next_start_phase, resolve_continue_multi_cycle
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from code_generator import state as state_module
+
+_logger = logging.getLogger(__name__)
+
+__all__ = ["dispatch_async", "dispatch_orchestrator"]
+
+
+async def _apply_delta_plan(
+    st: state_module.State,
+    project_dir: Path,
+    *,
+    runner_module: object,
+    delta_hash: str,
+    state_path: Path,
+    logger: logging.Logger,
+) -> int | None:
+    """Run Phase 0 and merge new cycles into state for multi-cycle delta planning.
+
+    Atomicity guarantee: state is only mutated after a successful Phase 0
+    response.  If Phase 0 fails, a ``RuntimeError`` is raised and neither
+    ``state.cycles`` nor ``state.requirements_hash`` is changed.
+
+    Args:
+        st: Root state (mutated in place on success).
+        project_dir: Project root directory.
+        runner_module: Runner module for Phase 0 execution.
+        delta_hash: The new requirements hash to store on success.
+        state_path: Path to state.json for atomic persistence.
+        logger: Phase logger.
+
+    Returns:
+        ID of the first newly appended cycle, or ``None`` when the new plan
+        contains no scopes that are not already in ``state.cycles``.
+
+    Raises:
+        RuntimeError: When Phase 0 returns ``None`` (all retries exhausted).
+    """
+    from code_generator import state as state_module
+    from code_generator.orchestrator import phase0_complexity
+
+    raw_cycles = await phase0_complexity.get_raw_cycle_plan(
+        project_dir,
+        runner_module=runner_module,  # type: ignore[arg-type]
+        logger=logger,
+    )
+
+    if raw_cycles is None:
+        raise RuntimeError(
+            "Phase 0 failed during delta planning; aborting to preserve cycle history."
+        )
+
+    new_cycles = state_module.append_new_cycles(st, raw_cycles)
+
+    if not new_cycles:
+        logger.info("Delta planning: no new cycles detected.")
+        st.requirements_hash = delta_hash
+        state_module.save_state(state_path, st)
+        return None
+
+    # Extend state atomically: build new list, then assign all at once.
+    st.cycles = list(st.cycles) + new_cycles
+    st.current_cycle = new_cycles[0].id
+    st.requirements_hash = delta_hash
+    state_module.save_state(state_path, st)
+    return new_cycles[0].id
+
+
+async def dispatch_async(
+    st: state_module.State,
+    project_dir: Path,
+    *,
+    dry_run: bool,
+    start_phase: int,
+    start_cycle: int | None,
+    mode: str,
+    delta_hash: str | None = None,
+    state_path: Path | None = None,
+) -> None:
+    """Async entry point for the orchestration pipeline.
+
+    Args:
+        st: Root state object.
+        project_dir: Project root directory.
+        dry_run: When True, only phases 0 and 1 run.
+        start_phase: Resume from this phase (1 = full run).
+        start_cycle: Resume from this cycle (multi-cycle only).
+        mode: ``"auto"``, ``"single"``, or ``"multi-cycle"``.
+        delta_hash: When set, triggers delta planning for multi-cycle mode
+            with completed cycles (the new requirements hash to persist on
+            success).  ``None`` disables delta planning.
+        state_path: Path to state.json; required when ``delta_hash`` is set.
+    """
+    from code_generator.logging_setup import setup_phase_logger
+    from code_generator.orchestrator import cycle_loop, phase0_complexity
+    from code_generator.runner import get_runner
+
+    runner_module = get_runner()
+    logger = setup_phase_logger("generate", project_dir)
+
+    # Phase 0: determine mode when not already known.
+    if mode == "auto":
+        needs_phase0 = st.mode not in ("single", "multi-cycle")
+    else:
+        needs_phase0 = False
+        # Force the mode from the flag.
+        st.mode = mode  # type: ignore[assignment]
+
+    # 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"]
+    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,
+            project_dir,
+            runner_module=runner_module,
+            delta_hash=delta_hash,
+            state_path=state_path,
+            logger=logger,
+        )
+        if first_new_id is None:
+            return  # No new cycles — nothing to run.
+        start_cycle = first_new_id
+        start_phase = 1
+        needs_phase0 = False
+
+    if needs_phase0:
+        await phase0_complexity.run(st, project_dir, runner_module=runner_module, logger=logger)
+
+    # Dry-run: planning only (phase 0 + phase 1).
+    if dry_run:
+        from code_generator.orchestrator import phase1_plan
+
+        logger.info("--dry-run: running phase 1 (planning only).")
+        await phase1_plan.run(st, None, project_dir, runner_module=runner_module, logger=logger)
+        return
+
+    # Dispatch to cycle loop.
+    if st.mode == "multi-cycle":
+        await cycle_loop.run_multi_cycle(
+            st,
+            project_dir,
+            runner_module=runner_module,
+            logger=logger,
+            start_cycle=start_cycle,
+            start_phase=start_phase,
+        )
+    else:
+        await cycle_loop.run_single_mode(
+            st,
+            project_dir,
+            runner_module=runner_module,
+            logger=logger,
+            start_phase=start_phase,
+        )
+
+
+def dispatch_orchestrator(
+    st: state_module.State,
+    project_dir: Path,
+    *,
+    dry_run: bool,
+    phase: int | None,
+    continue_: bool,
+    mode: str,
+    cycle: int | None,
+    state_path: Path,
+    requirements_hash: str | None = None,
+) -> None:
+    """Resolve resume parameters and dispatch the async orchestrator.
+
+    Args:
+        st: Root state.
+        project_dir: Project root directory.
+        dry_run: When True, only phase 0/1 planning runs.
+        phase: Resume from this explicit phase number.
+        continue_: Resume from the last completed phase/cycle in state.
+        mode: ``"auto"``, ``"single"``, or ``"multi-cycle"``.
+        cycle: Resume from this specific cycle (multi-cycle only).
+        state_path: Path to state.json, used for atomic hash updates.
+        requirements_hash: SHA-256 digest of the current requirements.md, or
+            None when the file is absent (detection is skipped).
+    """
+    from code_generator import state as state_module
+
+    # Re-run detection: only when no explicit resume flags override intent.
+    # --continue and --phase N express explicit user intent, so they bypass
+    # detection entirely to avoid surprising "nothing to do" responses.
+    delta_hash_for_async: str | None = None
+    if not continue_ and phase is None and requirements_hash is not None:
+        from code_generator.commands._detect import detect_run_mode
+
+        run_mode = detect_run_mode(st, requirements_hash)
+
+        if run_mode == "no-op":
+            _logger.info("nothing to do: all cycles complete, requirements unchanged")
+            typer.echo("All cycles complete. Nothing to do.")
+            return
+
+        if run_mode == "first-run":
+            st.requirements_hash = requirements_hash
+            state_module.save_state(state_path, st)
+
+        elif run_mode == "delta":
+            completed = [c for c in st.cycles if 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.
+                delta_hash_for_async = requirements_hash
+            else:
+                # Single mode or no completed cycles: treat as fresh run from Phase 0.
+                # Reset mode to "unknown" so Phase 0 re-runs and re-evaluates complexity.
+                st.mode = "unknown"  # type: ignore[assignment]
+                st.requirements_hash = requirements_hash
+                state_module.save_state(state_path, st)
+
+    # Resolve effective mode (honor existing state when --mode auto).
+    effective_mode = mode
+    if mode == "auto" and st.mode in ("single", "multi-cycle"):
+        effective_mode = st.mode
+
+    # Resolve start_phase and start_cycle.
+    # Flag precedence (highest → lowest):
+    #   1. --continue  → derive start_cycle + start_phase from state (last completed)
+    #   2. --phase N   → explicit phase; start_cycle stays None (single-mode default)
+    #   3. --cycle N   → overrides any continue-derived start_cycle; start_phase
+    #                    defaults to 1 unless --phase N is also given
+    #   4. (none)      → fresh run from phase 1, cycle None
+    start_phase = 1
+    start_cycle: int | None = None
+
+    if continue_:
+        # Resume from the *next* phase/cycle after the last completed one.
+        if effective_mode == "multi-cycle":
+            start_cycle, start_phase = resolve_continue_multi_cycle(st)
+        else:
+            start_phase = next_start_phase(st)
+
+    elif phase is not None:
+        start_phase = phase
+
+    if cycle is not None:
+        # --cycle N overrides any continue-derived start_cycle.
+        start_cycle = cycle
+        start_phase = phase or 1
+
+    asyncio.run(
+        dispatch_async(
+            st,
+            project_dir,
+            dry_run=dry_run,
+            start_phase=start_phase,
+            start_cycle=start_cycle,
+            mode=effective_mode,
+            delta_hash=delta_hash_for_async,
+            state_path=state_path,
+        )
+    )

claude_code_generator-0.2.0/src/code_generator/commands/_resume.py

@@ -0,0 +1,73 @@
+"""Resume helpers for the generate command.
+
+Derives ``start_phase`` and ``start_cycle`` from persisted state when the user
+passes ``--continue``.  These functions are pure (no I/O) so they are easy to
+unit-test in isolation.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from code_generator import state as state_module
+
+_logger = logging.getLogger(__name__)
+
+__all__ = ["next_start_phase", "resolve_continue_multi_cycle"]
+
+
+def next_start_phase(st: state_module.State) -> int:
+    """Return the phase to resume from after ``--continue``.
+
+    ``state.phase`` records the last *completed* phase, so the next phase to
+    run is always ``phase + 1``.  When no prior phase is recorded (fresh run),
+    start from phase 1.
+
+    Args:
+        st: Root state.
+
+    Returns:
+        Phase number to pass as ``start_phase`` to the cycle loop.
+    """
+    return (st.phase or 0) + 1
+
+
+def resolve_continue_multi_cycle(
+    st: state_module.State,
+) -> tuple[int | None, int]:
+    """Return ``(start_cycle, start_phase)`` for a ``--continue`` in multi-cycle mode.
+
+    Rules:
+    - When ``current_cycle`` is *completed* (all phases done), advance to the
+      next cycle and restart from phase 1 — the completed cycle must not be
+      re-entered.
+    - When ``current_cycle`` is still *open* (interrupted mid-cycle), resume
+      within that cycle at the next phase.
+    - When no ``current_cycle`` is recorded, return ``(None, 1)`` for a full run.
+
+    Args:
+        st: Root state.
+
+    Returns:
+        Tuple of ``(start_cycle, start_phase)`` to pass to ``run_multi_cycle``.
+    """
+    if st.current_cycle is None:
+        return None, 1
+
+    current = next((c for c in st.cycles if c.id == st.current_cycle), None)
+    if current is not None and current.status == "completed":
+        return st.current_cycle + 1, 1
+
+    if current is not None:
+        cycle_phase = current.phase or 0
+        # Phase 7 with non-completed status → retry commit (don't advance beyond 7).
+        start_phase = cycle_phase + 1 if cycle_phase < 7 else 7
+        return st.current_cycle, start_phase
+
+    _logger.warning(
+        "No cycle record found for current_cycle=%d; defaulting to phase 1.",
+        st.current_cycle,
+    )
+    return st.current_cycle, 1