@trac3er/oh-my-god 2.2.2 → 2.2.4

package/build/lib/hooks/tdd-gate.py

@@ -1,10 +0,0 @@
-#!/usr/bin/env python3
-"""Backward-compatible entrypoint for the test validator stop hook."""
-from __future__ import annotations
-
-import runpy
-from pathlib import Path
-
-
-if __name__ == "__main__":
-    runpy.run_path(str(Path(__file__).with_name("test-validator.py")), run_name="__main__")

package/build/lib/hooks/test-validator.py

@@ -1,430 +0,0 @@
-#!/usr/bin/env python3
-"""
-Stop Hook: Test Validator (v5) — Enhanced Anti-Pattern Detection
-
-v5 additions (T32):
-  - Skip/ignore test detection (pytest.mark.skip, xit, xdescribe, etc.)
-  - Mock-heavy test detection (ratio-based: mocks vs assertions)
-  - Parameterized test gap detection (same function 3+ literal args)
-  - Assertion-free Python test detection (def test_* with no assert)
-  - Empty test body detection (pass, ..., comment-only)
-  - Coverage metrics persistence to .omg/state/test-metrics.json
-
-Callable API:
-  check_test_quality(data, project_dir) -> list[str]
-    Returns list of block reasons (empty = pass).
-  analyze_test_content(content, filename) -> list[str]
-    Returns list of issue strings for a single file's content.
-  persist_metrics(project_dir, analysis) -> None
-    Writes test quality metrics to .omg/state/test-metrics.json.
-"""
-import json, sys, os, re
-from collections import Counter
-from datetime import datetime, timezone
-
-HOOKS_DIR = os.path.dirname(__file__)
-PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
-
-from hooks._common import _resolve_project_dir, should_skip_stop_hooks
-
-# --- Builtins excluded from parameterized-gap detection ---
-_BUILTIN_FUNCS = frozenset({
-    "test", "it", "describe", "print", "len", "range", "str", "int",
-    "float", "list", "dict", "set", "tuple", "type", "isinstance",
-    "assert_equal", "assertEqual", "patch", "mock", "Mock", "MagicMock",
-    "expect", "require", "import", "open", "super", "getattr", "setattr",
-    "hasattr", "sorted", "enumerate", "zip", "map", "filter", "min", "max",
-})
-_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
-_SKIP_DIR_SEGMENTS = frozenset({"build", "dist", "node_modules", ".git"})
-_TEST_DIR_NAMES = frozenset({"tests", "test", "__tests__"})
-
-
-def analyze_test_content(content, filename="test.py"):
-    """
-    Analyze test file content for quality anti-patterns.
-
-    Returns list of issue strings, each prefixed with a category label:
-      FAKE:, BOILERPLATE:, HAPPY PATH ONLY:, EMPTY:, OVER-MOCKED:,
-      SKIP:, ASSERTION-FREE:, MOCK-HEAVY:, PARAMETERIZED:
-    """
-    issues = []
-
-    # === FAKE TEST PATTERNS (v3, kept) ===
-    fake_patterns = [
-        (r"expect\s*\(\s*true\s*\)\s*\.to(Be|Equal)\s*\(\s*true\s*\)", "assert true === true"),
-        (r"expect\s*\(\s*1\s*\)\s*\.toBe\s*\(\s*1\s*\)", "assert 1 === 1"),
-        (r"assert\s+True\b", "assert True (Python)"),
-        (r"assert\s+1\s*==\s*1", "assert 1 == 1"),
-    ]
-    for pat, label in fake_patterns:
-        if re.search(pat, content):
-            issues.append(f"FAKE: {label}")
-
-    # === BOILERPLATE-ONLY (v4, kept) ===
-    type_checks = len(re.findall(
-        r"(typeof\s+\w+|instanceof\s+\w+|toBeDefined|toBeInstanceOf|\.type\b)", content))
-    behavior_checks = len(re.findall(
-        r"(toEqual|toContain|toMatch|toThrow|rejects|resolves|toHaveBeenCalledWith|"
-        r"toHaveProperty|toHaveLength|toBeGreaterThan|toBeLessThan|assert.*==|"
-        r"assertEqual|assertIn|assertRaises|assert_called_with)", content))
-
-    if type_checks > 3 and behavior_checks == 0:
-        issues.append("BOILERPLATE: Only checks types/existence, never tests actual behavior")
-
-    # === HAPPY PATH ONLY (v4, kept) ===
-    has_error_tests = bool(re.search(
-        r"(toThrow|rejects|assertRaises|error|invalid|empty|null|undefined|"
-        r"edge.case|boundary|overflow|timeout|unauthorized|forbidden|not.found|"
-        r"bad.request|missing|malformed)", content, re.IGNORECASE))
-    test_count = len(re.findall(r"(test|it|describe)\s*\(", content))
-
-    if test_count >= 3 and not has_error_tests:
-        issues.append("HAPPY PATH ONLY: No error/edge case tests. "
-                      "What happens with bad input? Unauthorized? Empty data?")
-
-    # === NO ASSERTIONS — JS style (v3, kept) ===
-    test_bodies = re.findall(
-        r"(?:test|it)\s*\([^)]+,\s*(?:async\s*)?\(\)\s*=>\s*\{([^}]*)\}",
-        content, re.DOTALL)
-    for body in test_bodies:
-        if body.strip() and not re.search(
-            r"(expect|assert|should|verify|check|toBe|toEqual|toThrow|toHave)",
-            body, re.IGNORECASE):
-            issues.append("EMPTY: Test body has no assertions")
-            break
-
-    # === OVER-MOCKED (v3, kept) ===
-    mock_count = len(re.findall(
-        r"(jest\.mock|mock\(|patch\(|MagicMock|stub\(|sinon\.stub)", content))
-    if mock_count > 5 and behavior_checks <= 1:
-        issues.append("OVER-MOCKED: Heavy mocking but barely tests real behavior")
-
-    # ============================================================
-    # v5 NEW PATTERNS
-    # ============================================================
-
-    # === SKIP / IGNORE TESTS (v5) ===
-    skip_patterns = [
-        (r"@pytest\.mark\.skip", "@pytest.mark.skip"),
-        (r"@pytest\.mark\.skipIf", "@pytest.mark.skipIf"),
-        (r"@unittest\.skip", "@unittest.skip"),
-        (r"\bit\.skip\s*\(", "it.skip()"),
-        (r"\bdescribe\.skip\s*\(", "describe.skip()"),
-        (r"\bxit\s*\(", "xit()"),
-        (r"\bxdescribe\s*\(", "xdescribe()"),
-    ]
-    for pat, label in skip_patterns:
-        if re.search(pat, content):
-            issues.append(f"SKIP: {label} — skipped tests hide failures")
-
-    # === ASSERTION-FREE Python tests (v5) ===
-    _detect_assertion_free_python(content, issues)
-
-    # === EMPTY TEST BODY — Python (v5) ===
-    _detect_empty_python_test_body(content, issues)
-
-    # === MOCK-HEAVY (v5, ratio-based refinement) ===
-    # Different from OVER-MOCKED: catches moderate mock counts with poor assertion ratio
-    assertion_count = len(re.findall(
-        r"(\bassert\b|\bexpect\s*\(|\.should\b|\bverify\s*\()", content))
-    if mock_count >= 3 and mock_count <= 5 and assertion_count < mock_count / 2:
-        issues.append(
-            f"MOCK-HEAVY: {mock_count} mocks but only {assertion_count} assertions "
-            f"— tests should verify behavior, not just mock dependencies")
-
-    # === PARAMETERIZED TEST GAP (v5) ===
-    _detect_parameterized_gap(content, issues)
-
-    return issues
-
-
-def _extract_python_test_bodies(content):
-    """
-    Extract Python test function names and their body text.
-    Returns list of (test_name, body_text) tuples.
-    """
-    results = []
-    test_defs = list(re.finditer(r'def\s+(test_\w+)\s*\([^)]*\)\s*:', content))
-
-    for idx, m in enumerate(test_defs):
-        body_start = m.end()
-        # Body extends to next def at same indent level, or EOF
-        if idx + 1 < len(test_defs):
-            body_end = test_defs[idx + 1].start()
-        else:
-            body_end = len(content)
-
-        raw_body = content[body_start:body_end]
-        # Keep only indented lines (the actual function body)
-        body_lines = []
-        for line in raw_body.split('\n'):
-            stripped = line.strip()
-            if not stripped:
-                continue
-            if line and (line[0] == ' ' or line[0] == '\t'):
-                body_lines.append(stripped)
-            elif body_lines:
-                # Non-indented non-empty line after body started = end of function
-                break
-
-        results.append((m.group(1), body_lines))
-
-    return results
-
-
-def _detect_assertion_free_python(content, issues):
-    """Detect Python test functions with no assertion keywords."""
-    for test_name, body_lines in _extract_python_test_bodies(content):
-        if not body_lines:
-            continue  # Empty bodies caught by _detect_empty_python_test_body
-        body_text = ' '.join(body_lines)
-        if not re.search(
-            r'(\bassert\b|\bexpect\s*\(|\.should\b|\bverify\s*\()',
-            body_text, re.IGNORECASE
-        ):
-            # Skip bodies that are just pass/ellipsis (caught by empty body detector)
-            non_trivial = [l for l in body_lines
-                           if l not in ('pass', '...') and not l.startswith('#')]
-            if non_trivial:
-                issues.append(
-                    f"ASSERTION-FREE: {test_name} has no assertions")
-
-
-def _detect_empty_python_test_body(content, issues):
-    """Detect Python test functions with empty bodies (pass, ..., comment-only)."""
-    for test_name, body_lines in _extract_python_test_bodies(content):
-        non_trivial = [l for l in body_lines
-                       if l not in ('pass', '...') and not l.startswith('#')]
-        if not non_trivial:
-            issues.append(f"EMPTY: {test_name} has empty body (only pass/ellipsis/comments)")
-
-
-def _detect_parameterized_gap(content, issues):
-    """
-    Detect functions called 3+ times with different literal arguments,
-    suggesting @pytest.mark.parametrize would be more appropriate.
-    """
-    # Find function calls with literal arguments (numbers or strings)
-    calls = re.findall(
-        r'\b(\w+)\s*\(\s*(\d+(?:\.\d+)?|"[^"]*"|\'[^\']*\')\s*(?:\)|,)',
-        content)
-
-    # Group by function name, collect unique literal args
-    call_groups = {}
-    for func, arg in calls:
-        if func.lower() not in _BUILTIN_FUNCS:
-            call_groups.setdefault(func, set()).add(arg)
-
-    for func, args in call_groups.items():
-        if len(args) >= 3:
-            issues.append(
-                f"PARAMETERIZED: '{func}' called with {len(args)} different "
-                f"literal values — consider @pytest.mark.parametrize or "
-                f"@pytest.mark.parametrize")
-
-
-def persist_metrics(project_dir, analysis):
-    """
-    Write test quality metrics to .omg/state/test-metrics.json.
-
-    Args:
-        project_dir: Project root directory.
-        analysis: Dict with keys: total_tests, fake_count, boilerplate_count,
-                  edge_case_count, skip_count, assertion_free_count.
-    """
-    try:
-        state_dir = os.path.join(project_dir, ".omg", "state")
-        os.makedirs(state_dir, exist_ok=True)
-
-        total = analysis.get("total_tests", 0)
-        issue_sum = (
-            analysis.get("fake_count", 0)
-            + analysis.get("boilerplate_count", 0)
-            + analysis.get("skip_count", 0)
-            + analysis.get("assertion_free_count", 0)
-        )
-
-        # Quality score: 1.0 = perfect, 0.0 = all tests problematic
-        if total > 0:
-            quality_score = round(max(0.0, 1.0 - (issue_sum / total)), 3)
-        else:
-            quality_score = 1.0
-
-        metrics = {
-            "ts": datetime.now(timezone.utc).isoformat(),
-            "total_tests": analysis.get("total_tests", 0),
-            "fake_count": analysis.get("fake_count", 0),
-            "boilerplate_count": analysis.get("boilerplate_count", 0),
-            "edge_case_count": analysis.get("edge_case_count", 0),
-            "skip_count": analysis.get("skip_count", 0),
-            "assertion_free_count": analysis.get("assertion_free_count", 0),
-            "quality_score": quality_score,
-        }
-
-        metrics_path = os.path.join(state_dir, "test-metrics.json")
-        with open(metrics_path, "w", encoding="utf-8") as f:
-            json.dump(metrics, f, separators=(",", ":"))
-    except Exception:
-        pass  # Crash isolation: never fail the hook
-
-
-def _is_test_file(rel_path):
-    """
-    Heuristic: is this path likely a test file (vs source module)?
-
-    Excludes build artifacts and source modules that happen to start with
-    ``test_`` but live outside test directories (e.g. ``runtime/test_intent_lock.py``).
-    """
-    parts = rel_path.replace("\\", "/").split("/")
-    # Skip build artifacts and vendored code
-    if any(seg in _SKIP_DIR_SEGMENTS for seg in parts[:-1]):
-        return False
-    basename = parts[-1].lower() if parts else ""
-    # Standard test file patterns (checked against basename)
-    if any(p in basename for p in (".test.", ".spec.", "_test.", ".tests.")):
-        return True
-    # __tests__ directory anywhere in path
-    if "__tests__" in rel_path:
-        return True
-    # test_ prefix: only match if file is in a test directory or at repo root
-    if basename.startswith("test_"):
-        parent_dirs = {p.lower() for p in parts[:-1]}
-        return not parent_dirs or bool(parent_dirs & _TEST_DIR_NAMES)
-    return False
-
-
-def check_test_quality(data, project_dir):
-    """Core test-quality validation. Returns list of block-reason strings."""
-    import subprocess
-
-    # Find recently modified test files
-    test_files = []
-    try:
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "--diff-filter=AM"],
-            capture_output=True, text=True, timeout=10, cwd=project_dir
-        )
-        for f in result.stdout.strip().split("\n"):
-            if f and _is_test_file(f):
-                full = os.path.join(project_dir, f)
-                if os.path.exists(full):
-                    test_files.append(full)
-    except Exception:
-        pass
-
-    if not test_files:
-        return []
-
-    warnings = []
-    # Aggregate metrics across all files
-    agg = {
-        "total_tests": 0, "fake_count": 0, "boilerplate_count": 0,
-        "edge_case_count": 0, "skip_count": 0, "assertion_free_count": 0,
-    }
-
-    for tf in test_files:
-        try:
-            with open(tf, "r", encoding="utf-8", errors="ignore") as f:
-                content = f.read()
-        except Exception:
-            continue
-
-        filename = os.path.basename(tf)
-        issues = analyze_test_content(content, filename)
-
-        # Count tests in this file
-        py_tests = len(re.findall(r'def\s+test_\w+\s*\(', content))
-        js_tests = len(re.findall(r'(test|it)\s*\(', content))
-        agg["total_tests"] += py_tests + js_tests
-
-        # Count issue categories
-        for issue in issues:
-            if issue.startswith("FAKE:"):
-                agg["fake_count"] += 1
-            elif issue.startswith("BOILERPLATE:"):
-                agg["boilerplate_count"] += 1
-            elif "HAPPY PATH" in issue:
-                agg["edge_case_count"] += 1
-            elif issue.startswith("SKIP:"):
-                agg["skip_count"] += 1
-            elif issue.startswith("ASSERTION-FREE:"):
-                agg["assertion_free_count"] += 1
-
-        if issues:
-            warnings.append(f"{filename}: " + "; ".join(issues))
-
-    # Persist metrics
-    try:
-        persist_metrics(project_dir, agg)
-    except Exception:
-        pass
-
-    if warnings:
-        msg = "TEST QUALITY ISSUES:\n" + "\n".join(f"  {w}" for w in warnings)
-        msg += ("\n\nTests should verify what USERS need, not just that code exists.\n"
-                "Ask: 'What does the user expect to happen? What could go wrong?'\n"
-                "Write tests for those scenarios.")
-        return [msg]
-
-    return []
-
-
-def check_methodology_contract(data):
-    if not isinstance(data, dict):
-        return []
-
-    tool_name = str(data.get("tool_name", "")).strip().lower()
-    if tool_name not in _MUTATION_TOOLS:
-        return []
-
-    tool_input = data.get("tool_input")
-    if not isinstance(tool_input, dict):
-        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
-
-    exemption = str(tool_input.get("exemption", "")).strip().lower()
-    if exemption == "docs":
-        return []
-
-    metadata = tool_input.get("metadata")
-    if not isinstance(metadata, dict):
-        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
-
-    done_when = metadata.get("done_when")
-    if isinstance(done_when, str) and done_when.strip():
-        return []
-    if isinstance(done_when, list):
-        if any(str(item).strip() for item in done_when):
-            return []
-    if isinstance(done_when, dict):
-        criteria = done_when.get("criteria")
-        if isinstance(criteria, str) and criteria.strip():
-            return []
-        if isinstance(criteria, list) and any(str(item).strip() for item in criteria):
-            return []
-        if str(done_when.get("summary", "")).strip():
-            return []
-
-    return ["METHODOLOGY: done_when criteria required before mutation-capable execution"]
-
-
-# Standalone execution (backward compat: invoked directly by hook runner)
-if __name__ == "__main__":
-    try:
-        data = json.load(sys.stdin)
-    except (json.JSONDecodeError, EOFError):
-        sys.exit(0)
-
-    if should_skip_stop_hooks(data):
-        sys.exit(0)
-
-    project_dir = _resolve_project_dir()
-    blocks = check_test_quality(data, project_dir)
-    blocks.extend(check_methodology_contract(data))
-    if blocks:
-        json.dump({"decision": "block", "reason": blocks[0]}, sys.stdout)
-    sys.exit(0)

package/build/lib/hooks/test_generator_hook.py

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-"""
-PostToolUse Hook: Test Generation Suggestion
-Suggests test generation when source files are modified without corresponding tests.
-Feature-gated under TEST_GENERATION flag.
-"""
-from __future__ import annotations
-
-import importlib.util
-import json
-import os
-import re
-import sys
-
-HOOKS_DIR = os.path.dirname(os.path.abspath(__file__))
-
-
-def _load_common():
-    path = os.path.join(HOOKS_DIR, "_common.py")
-    spec = importlib.util.spec_from_file_location("_common", path)
-    if spec is None or spec.loader is None:
-        raise RuntimeError("Unable to load _common.py")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-_common = _load_common()
-setup_crash_handler = _common.setup_crash_handler
-json_input = _common.json_input
-get_feature_flag = _common.get_feature_flag
-get_project_dir = _common.get_project_dir
-
-# Tool names that modify files
-WRITE_TOOLS = frozenset({"Write", "Edit", "MultiEdit"})
-
-# Patterns indicating a file is a test file
-TEST_FILE_PATTERNS = [
-    r"(?:^|/)test_",       # test_ prefix (Python convention)
-    r"_test\.",             # _test suffix before extension
-    r"\.spec\.",            # .spec. (JS/TS convention)
-    r"\.test\.",            # .test. (JS/TS convention)
-    r"(?:^|/)tests/",      # inside tests/ directory
-    r"(?:^|/)test/",       # inside test/ directory
-    r"(?:^|/)__tests__/",  # inside __tests__/ directory
-]
-
-_TEST_RE = re.compile("|".join(TEST_FILE_PATTERNS))
-
-
-def _is_test_file(file_path: str) -> bool:
-    """Return True if the file path looks like a test file."""
-    normalized = file_path.replace("\\", "/")
-    return bool(_TEST_RE.search(normalized))
-
-
-def _find_corresponding_test(file_path: str, project_dir: str) -> bool:
-    """Return True if a corresponding test file exists for the given source file."""
-    basename = os.path.basename(file_path)
-    name, ext = os.path.splitext(basename)
-    dir_part = os.path.dirname(file_path)
-
-    # Python: tests/test_{basename}
-    if ext == ".py":
-        candidates = [
-            os.path.join(project_dir, "tests", f"test_{basename}"),
-            os.path.join(project_dir, dir_part, "tests", f"test_{basename}"),
-        ]
-    # JS/TS: same dir + .test.{ext} or .spec.{ext}
-    elif ext in (".js", ".ts", ".jsx", ".tsx", ".mjs"):
-        candidates = [
-            os.path.join(project_dir, dir_part, f"{name}.test{ext}"),
-            os.path.join(project_dir, dir_part, f"{name}.spec{ext}"),
-        ]
-    else:
-        # Generic: check tests/test_{name}{ext}
-        candidates = [
-            os.path.join(project_dir, "tests", f"test_{basename}"),
-        ]
-
-    return any(os.path.exists(c) for c in candidates)
-
-
-def main() -> None:
-    setup_crash_handler("test-generator-hook", fail_closed=False)
-
-    payload = json_input()
-
-    # Gate: feature flag
-    if not get_feature_flag("TEST_GENERATION", default=False):
-        sys.exit(0)
-
-    # Gate: only file-modifying tools
-    tool_name = payload.get("tool_name", "")
-    if tool_name not in WRITE_TOOLS:
-        sys.exit(0)
-
-    # Extract file path (file_path or path)
-    tool_input = payload.get("tool_input", {})
-    file_path = tool_input.get("file_path") or tool_input.get("path", "")
-    if not file_path:
-        sys.exit(0)
-
-    # Gate: skip test files
-    if _is_test_file(file_path):
-        sys.exit(0)
-
-    # Check for corresponding test file
-    project_dir = get_project_dir()
-    if _find_corresponding_test(file_path, project_dir):
-        sys.exit(0)
-
-    # Inject suggestion
-    suggestion = (
-        f"No test file found for {file_path}. "
-        "Consider running /OMG:testgen to generate tests."
-    )
-    json.dump({"additionalContext": suggestion}, sys.stdout)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/build/lib/hooks/todo-state-tracker.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-"""
-PostToolUse Hook: Todo State Tracker (v1)
-
-Parses todo lists from agent responses and tracks completion status.
-Persists state to .omg/state/todo_progress.json for cross-turn tracking.
-
-Feature flag: OMG_TODO_TRACKING_ENABLED (default: False)
-"""
-import json
-import sys
-import os
-import re
-from datetime import datetime, timezone
-
-HOOKS_DIR = os.path.dirname(__file__)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
-
-from _common import (
-    setup_crash_handler,
-    json_input,
-    get_project_dir,
-    get_feature_flag,
-    atomic_json_write,
-)
-
-setup_crash_handler("todo-state-tracker", fail_closed=False)
-
-# Feature flag check
-if not get_feature_flag("TODO_TRACKING", default=False):
-    sys.exit(0)
-
-data = json_input()
-
-# Extract response text from various possible fields
-response_text = ""
-if isinstance(data, dict):
-    # PostToolUse hook may have response in different fields
-    response_text = (
-        data.get("response", "")
-        or data.get("tool_response", "")
-        or data.get("message", "")
-        or ""
-    )
-    if isinstance(response_text, dict):
-        response_text = response_text.get("content", "")
-
-if not isinstance(response_text, str):
-    response_text = str(response_text) if response_text else ""
-
-# Parse todo items: regex pattern for markdown todo format
-# Matches: - [ ] task text or - [x] task text
-TODO_PATTERN = r'- \[([ x])\] (.+)'
-matches = re.findall(TODO_PATTERN, response_text, re.IGNORECASE)
-
-if not matches:
-    # No todos found, exit cleanly
-    sys.exit(0)
-
-# Separate incomplete and complete items
-incomplete_items = []
-complete_items = []
-
-for status, task_text in matches:
-    task_text = task_text.strip()
-    if status.lower() == 'x':
-        complete_items.append(task_text)
-    else:
-        incomplete_items.append(task_text)
-
-# Load existing state
-project_dir = get_project_dir()
-state_path = os.path.join(project_dir, ".omg", "state", "todo_progress.json")
-
-existing_state = {}
-if os.path.exists(state_path):
-    try:
-        with open(state_path, "r", encoding="utf-8") as f:
-            existing_state = json.load(f)
-    except Exception:
-        existing_state = {}
-
-# Ensure existing_state is a dict
-if not isinstance(existing_state, dict):
-    existing_state = {}
-
-# Cross-turn merge strategy:
-# - Keep existing complete items (don't regress)
-# - Add new complete items
-# - Update incomplete items (replace with current turn's findings)
-# - Preserve session_id if available
-
-merged_complete = list(set(existing_state.get("complete", []) + complete_items))
-merged_incomplete = incomplete_items  # Replace with current turn's findings
-
-# Build new state
-new_state = {
-    "incomplete": merged_incomplete,
-    "complete": merged_complete,
-    "total": len(merged_incomplete) + len(merged_complete),
-    "last_updated": datetime.now(timezone.utc).isoformat(),
-}
-
-# Preserve session_id if available
-if "session_id" in existing_state:
-    new_state["session_id"] = existing_state["session_id"]
-elif "session_id" in data:
-    new_state["session_id"] = data.get("session_id")
-
-# Atomically write state
-atomic_json_write(state_path, new_state)
-
-sys.exit(0)