@michaelxwb/code-flow 0.8.1 → 1.0.0

package/src/core/code-flow/scripts/codeflow/cli/cf_spec_gate.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-"""CLI wrapper for the fail-closed Spec Context Stage Gate."""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-from pathlib import Path
-import sys
-import time
-from typing import IO, Optional, Sequence
-
-from codeflow.core.cf_core import phase_timing
-from codeflow.spec.cf_spec_context_model import load_context
-from codeflow.spec.cf_stage_gate import (
-    GateIssue, GateResult, evidence_deferral_kind, result_to_data, validate_plan_coverage, validate_stage,
-)
-
-
-def _merge_results(first: GateResult, second: GateResult) -> GateResult:
-    errors = (*first.errors, *second.errors)
-    warnings = (*first.warnings, *second.warnings)
-    refs = tuple(sorted(set((*first.affected_refs, *second.affected_refs))))
-    return GateResult("block" if errors else "pass", errors, warnings, refs)
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog=os.environ.get("CF_RUNTIME_COMMAND", "cf_spec_gate.py"))
-    parser.add_argument("--task-dir", required=True)
-    parser.add_argument("--stage", required=True)
-    parser.add_argument("--task", default="")
-    parser.add_argument("--artifact", default="")
-    parser.add_argument("--json", action="store_true")
-    return parser
-
-
-def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
-    started = time.monotonic()
-    try:
-        args = _parser().parse_args(argv)
-        phase_started = time.monotonic()
-        context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
-        phase_timing("gate.load_context", phase_started)
-        phase_started = time.monotonic()
-        directory = Path(args.task_dir).resolve()
-        root = next((parent.parent for parent in (directory, *directory.parents)
-                     if parent.name == ".code-flow"), directory)
-        result = validate_stage(context, args.stage, task_id=args.task, root=str(root), task_dir=args.task_dir)
-        phase_timing("gate.validate_stage", phase_started)
-        if args.stage == "plan" and args.artifact:
-            phase_started = time.monotonic()
-            result = _merge_results(result, validate_plan_coverage(context, args.artifact))
-            phase_timing("gate.validate_plan", phase_started)
-        stdout.write(json.dumps(result_to_data(result), ensure_ascii=False))
-        phase_timing("gate.total", started)
-        return 0 if result.decision == "pass" else 3
-    except Exception as exc:
-        sys.stderr.write(f"cf_spec_gate error: {exc}\n")
-        stdout.write(json.dumps({"decision": "block", "errors": [{"code": "gate_error"}]}, ensure_ascii=False))
-        return 2

package/src/core/code-flow/scripts/codeflow/cli/cf_spec_session.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-"""CLI wrapper for TASK-bound Spec Context projection."""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-from pathlib import Path
-import sys
-from typing import IO, Optional, Sequence
-
-from codeflow.spec.cf_spec_context_model import context_sha256, load_context
-from codeflow.spec.cf_task_projection import SessionProjection, project_task_session
-from codeflow.task.cf_task_doc import task_section, task_spec_refs
-
-
-def _task_section(text: str, task_id: str) -> str:
-    return task_section(text, task_id).body
-
-
-def _refs(section: str) -> tuple[str, ...]:
-    return task_spec_refs(section)
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog=os.environ.get("CF_RUNTIME_COMMAND", "cf_spec_session.py"))
-    parser.add_argument("--task-dir", required=True)
-    parser.add_argument("--task-file", required=True)
-    parser.add_argument("--task", required=True)
-    parser.add_argument("--output", required=True)
-    parser.add_argument("--budget", type=int, default=12000)
-    parser.add_argument("--json", action="store_true")
-    return parser
-
-
-def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
-    try:
-        args = _parser().parse_args(argv)
-        context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
-        result = project_task_session(context, args.task_file, args.task, args.budget)
-        Path(args.output).write_text(result.text, encoding="utf-8")
-        stdout.write(json.dumps(result.__dict__, ensure_ascii=False))
-        return 0
-    except Exception as exc:
-        stdout.write(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
-        return 3

package/src/core/code-flow/scripts/codeflow/cli/cf_stats.py

@@ -1,540 +0,0 @@
-#!/usr/bin/env python3
-import json
-import argparse
-import os
-import sys
-from pathlib import Path
-from typing import Optional
-
-from codeflow.core import cf_log
-from codeflow.acceptance.cf_checks import load_check_state
-from codeflow.core.cf_core import (
-    build_effective_mapping,
-    build_spec_catalog,
-    compress_content,
-    estimate_tokens,
-    load_config,
-    project_instruction_file,
-    non_injectable_specs,
-    resolve_quality_loop,
-)
-
-
-def _violation_fixed(index: int, events: list) -> bool:
-    """修正口径：违规后同会话同文件有后续编辑，且其后无同 check 再违规。
-
-    用日志追加顺序判先后（ts 仅秒级精度，同秒事件无法靠时间戳排序）。
-    保留单点查询语义；批量聚合请用 violation_fixed_batch（一次线性扫描）。
-    """
-    violation = events[index]
-    v_data = violation.get("data") or {}
-    later_edit = False
-    for event in events[index + 1:]:
-        if event.get("sid") != violation.get("sid"):
-            continue
-        data = event.get("data") or {}
-        if event.get("event") == "edit" and data.get("file") == v_data.get("file"):
-            later_edit = True
-        if (
-            later_edit
-            and event.get("event") == "violation"
-            and data.get("check_id") == v_data.get("check_id")
-            and data.get("file") == v_data.get("file")
-        ):
-            return False
-    return later_edit
-
-
-def violation_fixed_batch(events: list) -> list[bool]:
-    """Batch twin of _violation_fixed: one reverse pass, identical semantics.
-
-    Segments the timeline per (session, file) at edits: a violation is fixed
-    iff an edit exists after it and no same-check violation exists in a later
-    segment. No slicing, no per-violation rescan: O(n) time.
-    """
-    fixed: dict[int, bool] = {}
-    edit_right: set[tuple[str, str]] = set()
-    current: dict[tuple[str, str], set[str]] = {}
-    later: dict[tuple[str, str], set[str]] = {}
-    for index in range(len(events) - 1, -1, -1):
-        event = events[index]
-        if not isinstance(event, dict):
-            continue
-        kind = event.get("event")
-        data = event.get("data")
-        if not isinstance(data, dict):
-            data = {}
-        key = (str(event.get("sid")), str(data.get("file")))
-        if kind == "edit":
-            later.setdefault(key, set()).update(current.get(key, ()))
-            current[key] = set()
-            edit_right.add(key)
-        elif kind == "violation":
-            check = str(data.get("check_id"))
-            fixed[index] = key in edit_right and check not in later.get(key, ())
-            current.setdefault(key, set()).add(check)
-    return [fixed[index] for index, event in enumerate(events) if isinstance(event, dict) and event.get("event") == "violation"]
-
-
-def quality_loop_summary(project_root: str, config: dict) -> dict:
-    """FEAT-05/02 度量聚合：Top 违规榜 / 修正率 / 误报与停用 / 降级组件。"""
-    switches = resolve_quality_loop(config)
-    events = cf_log.read_events(project_root, days=30)
-    summary = {"switches": switches, "window_days": 30}
-    if not events:
-        summary["note"] = "暂无数据"
-        return summary
-
-    violations = [e for e in events if e.get("event") == "violation"]
-    counts: dict = {}
-    for v in violations:
-        data = v.get("data") or {}
-        key = f"{data.get('spec', '?')}#{data.get('check_id', '?')}"
-        counts[key] = counts.get(key, 0) + 1
-    summary["top_violations"] = sorted(
-        ({"rule": k, "count": n} for k, n in counts.items()),
-        key=lambda item: -item["count"],
-    )[:10]
-
-    fixed = violation_fixed_batch(events)
-    summary["violation_total"] = len(violations)
-    summary["fix_rate"] = (
-        f"{round(sum(fixed) * 100 / len(violations))}%" if violations else "n/a"
-    )
-
-    state = load_check_state(project_root)
-    summary["checks"] = {
-        cid: {
-            "hit_count": entry.get("hit_count", 0),
-            "fp_count": entry.get("fp_count", 0),
-            "disabled": bool(entry.get("disabled")),
-            "disabled_reason": entry.get("disabled_reason", ""),
-        }
-        for cid, entry in state.items()
-        if isinstance(entry, dict) and not cid.startswith("_")
-    }
-
-    degraded: dict = {}
-    for event in events:
-        if event.get("event") != "degrade":
-            continue
-        data = event.get("data") or {}
-        component = data.get("component", "?")
-        item = degraded.setdefault(component, {"count": 0, "last_error": ""})
-        item["count"] += 1
-        item["last_error"] = data.get("error", "")
-    summary["degraded"] = degraded
-    return summary
-
-
-def _percent(numerator: int, denominator: int) -> str:
-    return f"{round(numerator * 100 / denominator)}%" if denominator else "n/a"
-
-
-def spec_workflow_summary(project_root: str) -> dict:
-    events = cf_log.read_events(project_root, days=30)
-    candidates = {
-        (str((event.get("data") or {}).get("task")), str((event.get("data") or {}).get("rule")))
-        for event in events if event.get("event") == "spec_candidate"
-    }
-    bound = {
-        (str((event.get("data") or {}).get("task")), str((event.get("data") or {}).get("rule")))
-        for event in events if event.get("event") == "spec_bound"
-    }
-    gates = [event for event in events if event.get("event") == "spec_gate"]
-    first_pass = sum((event.get("data") or {}).get("first_pass") is True for event in gates)
-    late = sum(event.get("event") == "late_violation" for event in events)
-    statuses = {"stale": 0, "conflict": 0, "not_applicable": 0}
-    for event in events:
-        status = (event.get("data") or {}).get("status")
-        if status in statuses:
-            statuses[status] += 1
-    degraded = sum(event.get("event") == "metrics_degraded" for event in events)
-    return {
-        "window_days": 30,
-        "coverage": _percent(len(bound & candidates), len(candidates)),
-        "first_compliance_rate": _percent(first_pass, len(gates)),
-        "late_violation_rate": _percent(late, len(bound)),
-        "statuses": statuses,
-        "data_complete": degraded == 0,
-        "degraded_events": degraded,
-        "read_note": "read 仅表示读取，不代表理解",
-    }
-
-
-def read_text(path: str) -> str:
-    try:
-        with open(path, "r", encoding="utf-8") as file:
-            return file.read().strip()
-    except Exception:
-        return ""
-
-
-def normalize_rel_path(path: str) -> str:
-    return path.replace(os.sep, "/")
-
-
-def extract_spec_path(spec_entry) -> str:
-    if isinstance(spec_entry, dict):
-        return normalize_rel_path(spec_entry.get("path", ""))
-    if isinstance(spec_entry, str):
-        return normalize_rel_path(spec_entry)
-    return ""
-
-
-def discover_specs(specs_root: str) -> dict:
-    discovered = {}
-    if not os.path.isdir(specs_root):
-        return discovered
-
-    for root, _, files in os.walk(specs_root):
-        for filename in files:
-            if not filename.endswith(".md"):
-                continue
-            full_path = os.path.join(root, filename)
-            rel = normalize_rel_path(os.path.relpath(full_path, specs_root))
-            parts = rel.split("/", 1)
-            if len(parts) < 2:
-                continue
-            domain = parts[0]
-            discovered.setdefault(domain, []).append(rel)
-
-    for domain in discovered:
-        discovered[domain] = sorted(set(discovered[domain]))
-    return discovered
-
-
-def configured_specs(config: dict, domain: str) -> list:
-    mapping = (config.get("path_mapping") or {}).get(domain) or {}
-    specs_config = mapping.get("specs") or []
-    result = []
-    for spec_entry in specs_config:
-        rel = extract_spec_path(spec_entry)
-        if rel:
-            result.append(rel)
-    return result
-
-
-def resolve_domains(config: dict, discovered: dict, domain_filter: Optional[str]) -> list:
-    if domain_filter:
-        if domain_filter in discovered:
-            return [domain_filter]
-        if domain_filter in (config.get("path_mapping") or {}):
-            return [domain_filter]
-        return []
-
-    if discovered:
-        return sorted(discovered.keys())
-    return sorted((config.get("path_mapping") or {}).keys())
-
-
-def _build_item(rel: str, raw_content: str) -> dict:
-    raw_tokens = estimate_tokens(raw_content)
-    compressed_tokens = estimate_tokens(compress_content(raw_content))
-    saved_pct = (
-        round((raw_tokens - compressed_tokens) * 100 / raw_tokens, 1)
-        if raw_tokens
-        else 0.0
-    )
-    return {
-        "path": rel,
-        "tokens": compressed_tokens,
-        "tokens_raw": raw_tokens,
-        "tokens_compressed": compressed_tokens,
-        "saved_pct": saved_pct,
-    }
-
-
-def collect_domain_items(
-    specs_root: str,
-    domain: str,
-    configured: list,
-    discovered: list,
-) -> tuple:
-    items = []
-    missing = []
-    seen = set()
-
-    for rel in configured:
-        if rel in seen:
-            continue
-        seen.add(rel)
-        full_path = os.path.join(specs_root, rel)
-        if not os.path.exists(full_path):
-            missing.append({"domain": domain, "path": rel})
-            continue
-        content = read_text(full_path)
-        if content:
-            items.append(_build_item(rel, content))
-
-    for rel in discovered:
-        if rel in seen:
-            continue
-        seen.add(rel)
-        full_path = os.path.join(specs_root, rel)
-        content = read_text(full_path)
-        if content:
-            items.append(_build_item(rel, content))
-
-    return items, missing
-
-
-def _arguments() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(prog=os.environ.get("CF_RUNTIME_COMMAND", "cf_stats.py"))
-    formats = parser.add_mutually_exclusive_group()
-    formats.add_argument("--human", action="store_true")
-    formats.add_argument("--json", action="store_true")
-    parser.add_argument("--audit", action="store_true")
-    parser.add_argument("--domain", default=None)
-    parser.add_argument("--platform", choices=("claude", "codex", "costrict", "opencode"), default="")
-    return parser.parse_args()
-
-
-def _budget_number(config: dict[str, object], key: str, default: int) -> int:
-    try:
-        return int(config.get(key, default))
-    except (TypeError, ValueError) as exc:
-        sys.stderr.write(f"cf-stats invalid {key}: {exc}; using {default}\n")
-        return default
-
-
-def _domain_usage(root: str, config: dict[str, object], domain_filter: Optional[str]) -> dict[str, object]:
-    specs_root = os.path.join(root, ".code-flow/specs")
-    discovered = discover_specs(specs_root)
-    mapping = build_effective_mapping(root, config.get("path_mapping") or {})
-    excluded = non_injectable_specs(mapping)
-    l1, spec_domains, missing_specs, empty_domains = {}, {}, [], []
-    for domain in resolve_domains(config, discovered, domain_filter):
-        configured = configured_specs(config, domain)
-        discovered_paths = discovered.get(domain, [])
-        items, missing = collect_domain_items(specs_root, domain, configured, discovered_paths)
-        for relative in configured + discovered_paths:
-            if relative:
-                spec_domains[relative] = domain
-        missing_specs.extend(missing)
-        for item in items:
-            item["injectable"] = item["path"] not in excluded
-        if items:
-            l1[domain] = items
-        elif configured and (not discovered or discovered_paths):
-            empty_domains.append(domain)
-    tokens = sum(item["tokens"] for items in l1.values() for item in items if item["injectable"])
-    templates = sum(item["tokens"] for items in l1.values() for item in items if not item["injectable"])
-    return {"l1": l1, "tokens": tokens, "template_tokens": templates, "excluded": sorted(excluded),
-            "missing_specs": missing_specs, "empty_domains": empty_domains, "spec_domain_map": spec_domains}
-
-
-def _compression_usage(l1: dict[str, list[dict[str, object]]]) -> dict[str, object]:
-    items = [item for values in l1.values() for item in values if item.get("injectable", True)]
-    raw = sum(item.get("tokens_raw", item["tokens"]) for item in items)
-    compressed = sum(item.get("tokens_compressed", item["tokens"]) for item in items)
-    return {"total_raw": raw, "total_compressed": compressed,
-            "total_saved_pct": round((raw - compressed) * 100 / raw, 1) if raw else 0.0}
-
-
-def _usage_warnings(l0_tokens: int, l0_budget: int, l1_budget: int, total: int,
-                    total_budget: int, usage: dict[str, object]) -> list[str]:
-    warnings = []
-    for exceeded, message in ((l0_tokens > l0_budget, "L0 超出预算"),
-                              (total - l0_tokens > min(total_budget, l1_budget), "L1 全量聚合超过单次注入上限（不代表单次编辑超限）"),
-                              (total > total_budget, "总预算超出")):
-        if exceeded:
-            warnings.append(message)
-    if usage["missing_specs"]:
-        warnings.append(f"配置的 spec 文件缺失: {len(usage['missing_specs'])} 个")
-    if usage["empty_domains"]:
-        domains = ", ".join(sorted(set(usage["empty_domains"])))
-        warnings.append(f"以下域未加载到任何 L1 spec: {domains}")
-    return warnings
-
-
-def _catalog_usage(root: str, config: dict[str, object], budget: dict[str, object]) -> dict[str, object]:
-    maximum = _budget_number(budget, "catalog_max", 200)
-    mapping = build_effective_mapping(root, config.get("path_mapping") or {})
-    text = build_spec_catalog(root, mapping, maximum)
-    return {"mode": "context_first", "tokens": estimate_tokens(text), "budget": maximum,
-            "entries": text.count("\n- `")}
-
-
-def _runtime_manifest_counts(manifest: Path) -> dict[str, int]:
-    from codeflow.acceptance.cf_acceptance_risk import risk_counts
-    from codeflow.acceptance.cf_acceptance_schema import scenario_check_ids
-    if not manifest.is_file():
-        return {}
-    try:
-        data = json.loads(manifest.read_text(encoding="utf-8"))
-        if not isinstance(data, dict):
-            raise ValueError("manifest must be an object")
-    except (OSError, ValueError) as exc:
-        sys.stderr.write(f"cf_stats: cannot read {manifest}: {exc}\n")
-        return {}
-    stale: set[str] = set()
-    for row in data.get("scenarios", []):
-        if isinstance(row, dict) and row.get("status") == "stale":
-            ids = row.get("stale_checks") or scenario_check_ids(row) or [str(row.get("id"))]
-            stale.update(str(value) for value in ids)
-    return {"stale_checks": len(stale), **risk_counts(data)}
-
-
-def _deferred_rule_count(context: Path) -> int:
-    from codeflow.cli.cf_spec_context import ContextError, load_context
-    from codeflow.spec.cf_stage_gate import evidence_deferral_kind
-    if not context.is_file():
-        return 0
-    try:
-        data = load_context(str(context))
-    except (OSError, ValueError, ContextError) as exc:
-        sys.stderr.write(f"cf_stats: cannot read {context}: {exc}\n")
-        return 0
-    return sum(any(
-        status.status == "unverified" and bool(status.evidence)
-        and evidence_deferral_kind(status.evidence[-1]) in ("review_stage", "heavy")
-        for status in rule.stage_status.values()
-    ) for binding in data.bindings for rule in binding.rules)
-
-
-def _runtime_usage(root: str) -> dict[str, object]:
-    """Counts describe unique checks, live risk acceptances and deferred rules."""
-    from codeflow.evidence.cf_evidence_store import EvidenceStore, requirement_key
-    marker = Path(root) / ".code-flow/.active-task.json"
-    task_dir = ""
-    if marker.is_file():
-        try:
-            data = json.loads(marker.read_text(encoding="utf-8"))
-            task_dir = str(data.get("task_dir") or "") if isinstance(data, dict) else ""
-        except (OSError, ValueError) as exc:
-            sys.stderr.write(f"cf_stats: cannot read {marker}: {exc}\n")
-    runtime: dict[str, object] = {
-        "task_dir": task_dir, "context_bytes": 0, "evidence_runs": 0,
-        "deferred_rules": 0, "stale_checks": 0, "accepted_risks": 0,
-        "recorded_risks": 0, "inactive_risks": 0,
-    }
-    if not task_dir:
-        return runtime
-    directory = (Path(root) / task_dir).resolve()
-    context = directory / "spec-context.yml"
-    if context.is_file():
-        runtime["context_bytes"] = context.stat().st_size
-    try:
-        store = EvidenceStore(root, requirement=requirement_key(directory))
-        runtime["evidence_runs"] = sum(
-            1 for path in store.directory.rglob("*.json")
-            if path.name != "latest.json" and "_context" not in path.parts
-        )
-    except (OSError, ValueError) as exc:
-        sys.stderr.write(f"cf_stats: cannot count evidence: {exc}\n")
-    runtime.update(_runtime_manifest_counts(directory / ".acceptance-manifest.json"))
-    runtime["deferred_rules"] = _deferred_rule_count(context)
-    return runtime
-
-
-def _stats_report(root: str, args: argparse.Namespace) -> dict[str, object]:
-    config = load_config(root)
-    budget = config.get("budget") or {}
-    l0_budget = _budget_number(budget, "l0_max", 800)
-    l1_budget = _budget_number(budget, "l1_max", 1700)
-    total_budget = _budget_number(budget, "total", l0_budget + l1_budget)
-    instruction = project_instruction_file(root, args.platform)
-    instruction_path = os.path.join(root, instruction)
-    l0_tokens = estimate_tokens(read_text(instruction_path)) if os.path.exists(instruction_path) else 0
-    usage = _domain_usage(root, config, args.domain)
-    total = l0_tokens + usage["tokens"]
-    report = {
-        "l0": {"file": instruction, "tokens": l0_tokens, "budget": l0_budget},
-        "l1": usage["l1"], "total_tokens": total, "total_budget": total_budget,
-        "budget_summary": {"aggregate_total": usage["tokens"], "single_edit_limit": min(total_budget, l1_budget)},
-        "utilization": f"{round(total * 100 / total_budget)}%" if total_budget else "0%",
-        "warnings": _usage_warnings(l0_tokens, l0_budget, l1_budget, total, total_budget, usage),
-        "spec_domain_map": usage["spec_domain_map"], "missing_specs": usage["missing_specs"],
-        "compression_summary": _compression_usage(usage["l1"]), "catalog": _catalog_usage(root, config, budget),
-        "quality_loop": quality_loop_summary(root, config), "spec_workflow": spec_workflow_summary(root),
-        "templates": {"tokens": usage["template_tokens"], "files": usage["excluded"],
-                      "note": "tags:[] 命令专用模板，永不自动注入，不计预算"},
-        "runtime": _runtime_usage(root),
-    }
-    if args.audit:
-        from codeflow.spec.cf_scan import build_report
-        scan = build_report(root, args.platform)
-        report["audit"] = {"files": [entry for entry in scan["files"] if entry.get("issues")],
-                           "review": scan["review"], "warnings": scan["audit_warnings"],
-                           "path_resolutions": [{"path": entry["path"], "resolved_paths": entry["resolved_paths"]}
-                                                for entry in scan["files"] if entry.get("resolved_paths")]}
-    return report
-
-
-def _print_domains(report: dict[str, object]) -> None:
-    for domain, items in report["l1"].items():
-        print(f"L1 {domain}:", sum(item["tokens"] for item in items if item.get("injectable", True)))
-        for item in items:
-            raw, compressed = item.get("tokens_raw", item["tokens"]), item.get("tokens_compressed", item["tokens"])
-            suffix = "" if item.get("injectable", True) else "（模板，不计预算）"
-            print(" -", item["path"], item["tokens"], f"(raw={raw}→compressed={compressed}, -{item.get('saved_pct', 0.0)}%)" + suffix)
-    if report["templates"]["tokens"]:
-        print("TEMPLATES (非注入):", f"{report['templates']['tokens']} tokens，不计预算")
-    if report["missing_specs"]:
-        print("MISSING SPECS:")
-        for item in report["missing_specs"]:
-            print(" -", item["domain"], item["path"])
-
-
-def _print_quality(summary: dict[str, object]) -> None:
-    print("QUALITY-LOOP:", "enabled" if summary["switches"]["enabled"] else "disabled")
-    if summary.get("note"):
-        print(" -", summary["note"])
-        return
-    print(" - violations:", summary.get("violation_total", 0), "| fix_rate:", summary.get("fix_rate", "n/a"))
-    for item in summary.get("top_violations", [])[:5]:
-        print("   ·", item["rule"], item["count"])
-    for check_id, info in summary.get("checks", {}).items():
-        if info["disabled"] or info["fp_count"]:
-            suffix = f" DISABLED({info['disabled_reason']})" if info["disabled"] else ""
-            print(f"   · {check_id}: hits={info['hit_count']} fp={info['fp_count']}" + suffix)
-    for component, info in summary.get("degraded", {}).items():
-        print(f"   · degraded {component}: {info['count']} ({info['last_error']})")
-
-
-def _print_audit(audit: Optional[dict[str, object]]) -> None:
-    if audit is None:
-        print("AUDIT: 运行 code-flow stats --audit 查看规范质量问题与待复审清单")
-        return
-    print("AUDIT (规范质量):")
-    if not audit["files"] and not audit["review"] and not audit.get("warnings"):
-        print(" - 无问题")
-    for warning in audit.get("warnings", []):
-        print(f" - 无效审计路径根: {warning['path']}")
-    for entry in audit["files"]:
-        print(" -", entry["path"], "|", " / ".join(entry["issues"]))
-    if audit["review"]:
-        print(" REVIEW (待复审):")
-        for item in audit["review"]:
-            print(f"   · {item['item']}: {item['reason']}")
-
-
-def _print_stats(report: dict[str, object]) -> None:
-    l0, compression, catalog = report["l0"], report["compression_summary"], report["catalog"]
-    print(f"L0 ({l0['file']}):", f"{l0['tokens']} / {l0['budget']}")
-    _print_domains(report)
-    print("TOTAL:", f"{report['total_tokens']} / {report['total_budget']}")
-    print("UTILIZATION:", report["utilization"])
-    print("COMPRESSION:", f"{compression['total_raw']} → {compression['total_compressed']} (-{compression['total_saved_pct']}%)")
-    print("CATALOG:", "mode=context_first,", f"{catalog['tokens']} / {catalog['budget']} tokens,", f"{catalog['entries']} entries")
-    _print_quality(report["quality_loop"])
-    runtime = report.get("runtime") or {}
-    if runtime.get("task_dir"):
-        print("RUNTIME:", f"context={runtime.get('context_bytes', 0)}B,",
-              f"evidence_runs={runtime.get('evidence_runs', 0)},",
-              f"deferred_rules={runtime.get('deferred_rules', 0)},",
-              f"stale_checks={runtime.get('stale_checks', 0)},",
-              f"accepted_risks={runtime.get('accepted_risks', 0)}")
-    if report["warnings"]:
-        print("WARNINGS:", "; ".join(report["warnings"]))
-    _print_audit(report.get("audit"))
-
-
-def main() -> None:
-    args = _arguments()
-    report = _stats_report(os.getcwd(), args)
-    if args.human:
-        _print_stats(report)
-    else:
-        sys.stdout.write(json.dumps(report, ensure_ascii=False) + "\n")