esaa-core 0.5.0b1__py3-none-any.whl

audit/amend_claude_md.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""FIX-1541 — Amenda CLAUDE.md substituindo 'enforcement.mode=reject' por '{reject, require_field, require_step}'.
+
+LES-0003 tem enforcement.mode=require_field, entao a redacao original (`mode=reject`)
+e estreita demais. Esta amenda reflete o conjunto real de modos enforcaveis.
+"""
+from __future__ import annotations
+import argparse
+from pathlib import Path
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    target = Path(args.root) / ".claude/CLAUDE.md"
+    if not target.exists():
+        print("CLAUDE.md not found; skipping")
+        return 0
+    txt = target.read_text(encoding="utf-8")
+    old = "Trate cada lesson com `enforcement.mode=reject` como **constraint inviolável**"
+    new = "Trate cada lesson com `enforcement.mode` em {`reject`, `require_field`, `require_step`} como **constraint inviolável**"
+    if old in txt:
+        txt = txt.replace(old, new)
+        target.write_text(txt, encoding="utf-8")
+        print("amended")
+    elif new in txt:
+        print("already amended")
+    else:
+        print("trecho nao encontrado; revise manualmente")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

audit/bump_version.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""FIX-1551 — Atualiza arquivos fora da boundary impl (pyproject.toml, roadmap.schema.json)
+para alinhar a 0.4.1.
+"""
+from __future__ import annotations
+import argparse, json, re
+from pathlib import Path
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    root = Path(args.root)
+
+    py = root / "pyproject.toml"
+    if py.exists():
+        txt = py.read_text(encoding="utf-8")
+        txt2 = re.sub(r'(?m)^version\s*=\s*"0\.4\.0"', 'version = "0.4.1"', txt)
+        if txt != txt2:
+            py.write_text(txt2, encoding="utf-8")
+            print("pyproject.toml -> 0.4.1")
+        else:
+            print("pyproject.toml ja em 0.4.1 ou nao encontrado padrao")
+
+    rsj = root / ".roadmap/roadmap.schema.json"
+    if rsj.exists():
+        data = json.loads(rsj.read_text(encoding="utf-8"))
+        sv = data.get("properties", {}).get("meta", {}).get("properties", {}).get("schema_version", {})
+        if sv.get("const") == "0.4.0":
+            sv["const"] = "0.4.1"
+            rsj.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+            print("roadmap.schema.json const -> 0.4.1")
+        else:
+            print(f"roadmap.schema.json const ja em {sv.get('const')}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

audit/contract_consistency.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""AUD-1001 — Verificador de consistência contrato/documento.
+
+Audita drift de versão e divergência de vocabulário entre os artefatos
+canônicos do ESAA. Read-only. Saída: JSON de findings.
+
+Uso: python contract_consistency.py --root <repo_root>
+"""
+from __future__ import annotations
+import argparse, json, re
+from pathlib import Path
+
+# M-04: vocabulario canonico de reject_codes vem de src/esaa/reject_codes.py.
+# Importacao defensiva: se PYTHONPATH=src nao estiver setado, cai para fallback
+# textual (mantem o checker funcional fora do dev environment).
+try:
+    import sys as _sys
+    _sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "src"))
+    from esaa.reject_codes import ALL_CODES as _RC_ALL, WORKFLOW_GATE_CODES as _RC_WG
+    DOC_REJECT_CODES = frozenset(_RC_WG)
+    ENGINE_ERROR_CODES = frozenset(_RC_ALL)
+except Exception:
+    DOC_REJECT_CODES = frozenset({
+        "MISSING_CLAIM", "MISSING_COMPLETE", "MISSING_VERIFICATION",
+        "PRIOR_STATUS_MISMATCH", "LOCK_VIOLATION", "ACTION_COLLAPSE",
+        "IMMUTABLE_DONE_VIOLATION",
+    })
+    ENGINE_ERROR_CODES = frozenset({
+        "SCHEMA_INVALID", "UNKNOWN_ACTION", "WORKFLOW_GATE_VIOLATION", "BOUNDARY_VIOLATION",
+        "IMMUTABLE_DONE_VIOLATION", "LOCK_VIOLATION", "TASK_NOT_FOUND",
+        "DUPLICATE_TASK", "ISSUE_NOT_FOUND",
+    })
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    root = Path(args.root)
+    findings = []
+
+    def declared_version(path: str, pattern: str) -> str | None:
+        p = root / path
+        if not p.exists():
+            return None
+        m = re.search(pattern, p.read_text(encoding="utf-8"))
+        return m.group(1) if m else None
+
+    protocol_versions = {
+        "AGENT_CONTRACT.yaml": declared_version(".roadmap/AGENT_CONTRACT.yaml", r'contract_version:\s*"([^"]+)"'),
+        "ORCHESTRATOR_CONTRACT.yaml": declared_version(".roadmap/ORCHESTRATOR_CONTRACT.yaml", r'contract_version:\s*"([^"]+)"'),
+        "agent_result.schema.json": declared_version(".roadmap/agent_result.schema.json", r'v(0\.\d\.\d)'),
+        "constants.py(SCHEMA_VERSION)": declared_version("src/esaa/constants.py", r'SCHEMA_VERSION\s*=\s*"([^"]+)"'),
+        "roadmap.schema.json(const)": declared_version(".roadmap/roadmap.schema.json", r'"const":\s*"(0\.\d\.\d)"'),
+    }
+    package_version = declared_version("pyproject.toml", r'version\s*=\s*"([^"]+)"')
+    distinct = {v for v in protocol_versions.values() if v}
+    if len(distinct) > 1:
+        findings.append({
+            "id": "R3", "severity": "high",
+            "title": "Version drift entre contratos e engine/projeções",
+            "evidence": protocol_versions,
+            "recommendation": "Migrar contratos, schemas e constants.py para a mesma versao de protocolo.",
+        })
+    if package_version and not package_version.startswith("0.5.0"):
+        findings.append({
+            "id": "R-PACKAGE-VERSION",
+            "severity": "low",
+            "title": "Versao do pacote nao esta na linha publica beta esperada",
+            "evidence": {"pyproject.toml": package_version, "protocol_versions": protocol_versions},
+            "recommendation": "Manter pacote 0.5.0b1 enquanto o protocolo permanece em 0.4.1.",
+        })
+
+    # Convenção de nome dos PARCER profiles
+    roadmap_dir = root / ".roadmap"
+    if roadmap_dir.exists():
+        profiles = [p.name for p in roadmap_dir.glob("PARCER_PROFILE*")]
+        dot = [n for n in profiles if n.startswith("PARCER_PROFILE.")]
+        underscore = [n for n in profiles if n.startswith("PARCER_PROFILE_")]
+        if dot and underscore:
+            findings.append({
+                "id": "R10", "severity": "low",
+                "title": "Convencao de nome de PARCER profile inconsistente (ponto vs underscore)",
+                "evidence": {"dot": dot, "underscore": underscore},
+                "recommendation": "Padronizar para um unico separador.",
+            })
+
+    # FIX-1812: runner.metrics deve estar em todas as fontes canonicas
+    rm_sources = {
+        "AGENT_CONTRACT.yaml(reserved)": "runner.metrics" in (root / ".roadmap/AGENT_CONTRACT.yaml").read_text(encoding="utf-8") if (root / ".roadmap/AGENT_CONTRACT.yaml").exists() else False,
+        "ORCHESTRATOR_CONTRACT.yaml(reserved)": "runner.metrics" in (root / ".roadmap/ORCHESTRATOR_CONTRACT.yaml").read_text(encoding="utf-8") if (root / ".roadmap/ORCHESTRATOR_CONTRACT.yaml").exists() else False,
+        "constants.py(CANONICAL_ACTIONS)": "runner.metrics" in (root / "src/esaa/constants.py").read_text(encoding="utf-8") if (root / "src/esaa/constants.py").exists() else False,
+        "AGENTS.md": "runner.metrics" in (root / "AGENTS.md").read_text(encoding="utf-8") if (root / "AGENTS.md").exists() else False,
+        ".claude/CLAUDE.md": "runner.metrics" in (root / ".claude/CLAUDE.md").read_text(encoding="utf-8") if (root / ".claude/CLAUDE.md").exists() else False,
+    }
+    missing_rm = [k for k, v in rm_sources.items() if not v]
+    if missing_rm:
+        findings.append({
+            "id": "R-RUNNER-METRICS-DRIFT", "severity": "medium",
+            "title": "runner.metrics ausente em fonte canonica",
+            "evidence": {"missing_in": missing_rm},
+            "recommendation": "Adicionar runner.metrics a todas as fontes do vocabulario reservado.",
+        })
+
+    # M-05: prior_status enum drift entre contract YAML e schema JSON
+    try:
+        import yaml as _yaml
+        ag_path = root / ".roadmap/AGENT_CONTRACT.yaml"
+        sch_path = root / ".roadmap/agent_result.schema.json"
+        if ag_path.exists() and sch_path.exists():
+            ag = _yaml.safe_load(ag_path.read_text(encoding="utf-8")) or {}
+            sch = json.loads(sch_path.read_text(encoding="utf-8"))
+            yaml_allowed = set(
+                ag.get("output_contract", {})
+                  .get("activity_event", {})
+                  .get("prior_status", {})
+                  .get("allowed_values", [])
+            )
+            schema_enum = set(
+                sch.get("properties", {})
+                   .get("activity_event", {})
+                   .get("properties", {})
+                   .get("prior_status", {})
+                   .get("enum", [])
+            )
+            if yaml_allowed != schema_enum:
+                findings.append({
+                    "id": "R-PRIOR-STATUS-ENUM-DRIFT", "severity": "medium",
+                    "title": "prior_status enum diverge entre AGENT_CONTRACT.yaml e agent_result.schema.json",
+                    "evidence": {
+                        "yaml_allowed_values": sorted(yaml_allowed),
+                        "schema_enum": sorted(schema_enum),
+                        "only_in_yaml": sorted(yaml_allowed - schema_enum),
+                        "only_in_schema": sorted(schema_enum - yaml_allowed),
+                    },
+                    "recommendation": "Alinhar AGENT_CONTRACT.yaml#prior_status.allowed_values com agent_result.schema.json enum.",
+                })
+    except Exception as exc:
+        findings.append({
+            "id": "R-PRIOR-STATUS-CHECK-FAILED", "severity": "low",
+            "title": "Falha ao executar check_prior_status_enum_drift",
+            "evidence": {"error": str(exc)[:120]},
+            "recommendation": "Verificar manualmente alinhamento entre AGENT_CONTRACT e agent_result.schema.",
+        })
+
+    print(json.dumps({"checker": "contract_consistency", "findings": findings}, indent=2, ensure_ascii=False))
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(main())

audit/critical_findings.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""AUD-1814 — Critical findings audit checker.
+
+Detects the architectural findings tracked by the critical-fixes trail:
+- R-RUNNER-METRICS-DRIFT: runner.metrics missing in any canonical source
+- R-NO-BASELINE-LESSON-RESEED: service.init not emitting baseline lessons event
+- R-REVIEW-ROLE-DRIFT: projector forces owner-only review (no _reviewer_role check)
+- R-NON-SERIALIZABLE-APPEND: append_transactional missing from store
+- R-FILE-EFFECT-ARTIFACTS: file_effects module missing
+- R-HOTFIX-VALIDATION: validate_hotfix_request missing
+- R-DONE-PRIOR-STATUS: agent_result.schema prior_status enum lacks 'done'
+- R-ATOMIC-FILE-EFFECTS: file_effects.stage_file_updates missing
+
+Usage: python src/audit/critical_findings.py --root <repo_root>
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+
+def _read(p: Path) -> str:
+    return p.read_text(encoding="utf-8") if p.exists() else ""
+
+
+def _yaml_safe_load(p: Path):
+    try:
+        import yaml
+        return yaml.safe_load(_read(p)) or {}
+    except Exception:
+        return {}
+
+
+def check_runner_metrics(root: Path) -> list[dict]:
+    findings = []
+    sources = {
+        "AGENT_CONTRACT.yaml": _yaml_safe_load(root / ".roadmap/AGENT_CONTRACT.yaml")
+            .get("vocabulary", {}).get("reserved_orchestrator_actions", []),
+        "ORCHESTRATOR_CONTRACT.yaml": _yaml_safe_load(root / ".roadmap/ORCHESTRATOR_CONTRACT.yaml")
+            .get("roles", {}).get("orchestrator", {}).get("reserved_actions", []),
+        "constants.py": "runner.metrics" in _read(root / "src/esaa/constants.py"),
+    }
+    missing = []
+    for name, value in sources.items():
+        if name == "constants.py":
+            if not value:
+                missing.append(name)
+        else:
+            if "runner.metrics" not in (value or []):
+                missing.append(name)
+    if missing:
+        findings.append({
+            "id": "R-RUNNER-METRICS-DRIFT",
+            "severity": "medium",
+            "title": "runner.metrics missing from canonical sources",
+            "evidence": {"missing_in": missing},
+            "recommendation": "Add runner.metrics to all reserved-action vocabularies.",
+        })
+    return findings
+
+
+def check_baseline_lessons_reseed(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/service.py")
+    findings = []
+    if "BASELINE_LESSONS" not in src:
+        findings.append({
+            "id": "R-NO-BASELINE-LESSON-RESEED",
+            "severity": "high",
+            "title": "service.py lacks BASELINE_LESSONS constant",
+            "evidence": {"file": "src/esaa/service.py"},
+            "recommendation": "Define BASELINE_LESSONS and emit baseline_reseed event in init.",
+        })
+    elif "baseline_reseed" not in src:
+        findings.append({
+            "id": "R-NO-BASELINE-LESSON-RESEED",
+            "severity": "high",
+            "title": "service.init not emitting baseline_reseed event",
+            "evidence": {"file": "src/esaa/service.py", "missing_marker": "baseline_reseed"},
+            "recommendation": "Append orchestrator.view.mutate with baseline_reseed in init.",
+        })
+    return findings
+
+
+def check_review_role(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/projector.py")
+    findings = []
+    if "_reviewer_role" not in src:
+        findings.append({
+            "id": "R-REVIEW-ROLE-DRIFT",
+            "severity": "high",
+            "title": "projector._apply_review missing role-based authorization",
+            "evidence": {"file": "src/esaa/projector.py"},
+            "recommendation": "Honor _reviewer_role in payload to allow qa_role mode.",
+        })
+    return findings
+
+
+def check_serializable_append(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/store.py")
+    findings = []
+    if "append_transactional" not in src:
+        findings.append({
+            "id": "R-NON-SERIALIZABLE-APPEND",
+            "severity": "critical",
+            "title": "store.append_transactional missing",
+            "evidence": {"file": "src/esaa/store.py"},
+            "recommendation": "Add lock-then-revalidate-then-write transactional API.",
+        })
+    return findings
+
+
+def check_file_effects_module(root: Path) -> list[dict]:
+    p = root / "src/esaa/file_effects.py"
+    findings = []
+    if not p.exists():
+        findings.append({
+            "id": "R-FILE-EFFECT-ARTIFACTS",
+            "severity": "high",
+            "title": "src/esaa/file_effects.py missing",
+            "evidence": {"expected_file": "src/esaa/file_effects.py"},
+            "recommendation": "Implement staging + content-addressed artifacts.",
+        })
+        return findings
+    src = _read(p)
+    required = ["stage_file_updates", "commit_staged", "discard_staged",
+                "compute_file_metadata", "write_artifact", "verify_artifact",
+                "read_artifact", "recover_file_effects"]
+    missing = [s for s in required if s not in src]
+    if missing:
+        findings.append({
+            "id": "R-FILE-EFFECT-ARTIFACTS",
+            "severity": "medium",
+            "title": "file_effects.py missing required functions",
+            "evidence": {"missing": missing},
+            "recommendation": "Implement: " + ", ".join(missing),
+        })
+    return findings
+
+
+def check_hotfix_validation(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/service.py")
+    findings = []
+    if "validate_hotfix_request" not in src:
+        findings.append({
+            "id": "R-HOTFIX-VALIDATION",
+            "severity": "medium",
+            "title": "service.validate_hotfix_request missing",
+            "evidence": {"file": "src/esaa/service.py"},
+            "recommendation": "Add validate_hotfix_request returning structured codes.",
+        })
+        return findings
+    expected_codes = ["HOTFIX_ISSUE_NOT_FOUND", "HOTFIX_TARGET_NOT_FOUND",
+                      "HOTFIX_TARGET_NOT_DONE", "HOTFIX_SCOPE_INVALID"]
+    missing = [c for c in expected_codes if c not in src]
+    if missing:
+        findings.append({
+            "id": "R-HOTFIX-VALIDATION",
+            "severity": "low",
+            "title": "validate_hotfix_request missing error codes",
+            "evidence": {"missing_codes": missing},
+            "recommendation": "Emit all hotfix structured reject codes.",
+        })
+    return findings
+
+
+def check_done_in_prior_status(root: Path) -> list[dict]:
+    p = root / ".roadmap/agent_result.schema.json"
+    findings = []
+    if not p.exists():
+        return findings
+    data = json.loads(_read(p))
+    enum = (
+        data.get("properties", {})
+        .get("activity_event", {})
+        .get("properties", {})
+        .get("prior_status", {})
+        .get("enum", [])
+    )
+    if "done" not in enum:
+        findings.append({
+            "id": "R-DONE-PRIOR-STATUS",
+            "severity": "high",
+            "title": "agent_result.schema prior_status enum lacks 'done'",
+            "evidence": {"current_enum": enum},
+            "recommendation": "Add 'done' to enable issue.report on done tasks.",
+        })
+    return findings
+
+
+def check_plugin_dispatch_parity(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/service.py")
+    findings = []
+    required = ["tasks_with_planned_plugins", "_accept_agent_output", "task.create"]
+    missing = [marker for marker in required if marker not in src]
+    if missing:
+        findings.append({
+            "id": "R-PLUGIN-DISPATCH-DRIFT",
+            "severity": "high",
+            "title": "run path no longer appears to consume planned plugin tasks",
+            "evidence": {"missing_markers": missing, "file": "src/esaa/service.py"},
+            "recommendation": "Keep run/eligible on the same tasks_with_planned_plugins view and admit task.create before claim.",
+        })
+    return findings
+
+
+def check_dry_run_semantics(root: Path) -> list[dict]:
+    src = _read(root / "src/esaa/service.py")
+    findings = []
+    required = ['"status": "dry_run"', "would_append_events", "simulated_last_event_seq"]
+    missing = [marker for marker in required if marker not in src]
+    if missing:
+        findings.append({
+            "id": "R-DRY-RUN-AMBIGUOUS",
+            "severity": "medium",
+            "title": "dry-run responses may be ambiguous",
+            "evidence": {"missing_markers": missing, "file": "src/esaa/service.py"},
+            "recommendation": "Return status=dry_run and simulated append metadata for every dry-run command.",
+        })
+    return findings
+
+
+CHECKS = [
+    ("runner_metrics", check_runner_metrics),
+    ("baseline_lessons_reseed", check_baseline_lessons_reseed),
+    ("review_role", check_review_role),
+    ("serializable_append", check_serializable_append),
+    ("file_effects_module", check_file_effects_module),
+    ("hotfix_validation", check_hotfix_validation),
+    ("done_in_prior_status", check_done_in_prior_status),
+    ("plugin_dispatch_parity", check_plugin_dispatch_parity),
+    ("dry_run_semantics", check_dry_run_semantics),
+]
+
+
+def run_checks(root: Path) -> dict:
+    all_findings = []
+    by_check = {}
+    for name, fn in CHECKS:
+        result = fn(root)
+        by_check[name] = len(result)
+        all_findings.extend(result)
+    severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+    all_findings.sort(key=lambda f: severity_order.get(f.get("severity"), 9))
+    return {
+        "checker": "critical_findings",
+        "total_findings": len(all_findings),
+        "by_check": by_check,
+        "by_severity": {
+            sev: sum(1 for f in all_findings if f.get("severity") == sev)
+            for sev in severity_order
+        },
+        "findings": all_findings,
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    result = run_checks(Path(args.root))
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result["total_findings"] == 0 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

audit/document_future_templates.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""FIX-1531 — Cria docs/spec/activity_future_templates.md documentando o arquivo."""
+from __future__ import annotations
+import argparse
+from pathlib import Path
+
+DOC = """# activity_future_templates.jsonl
+
+## Status: experimental / nao consumido pelo runtime
+
+O arquivo `.roadmap/activity_future_templates.jsonl` contem **templates** de
+eventos hipoteticos previstos para evolucao futura do protocolo ESAA. Ele:
+
+- **nao e lido** por `esaa.store.parse_event_store`;
+- **nao afeta** projecoes (`roadmap.json`/`issues.json`/`lessons.json`);
+- **nao afeta** `esaa verify` ou `esaa replay`;
+- serve como **referencia de design** para acoes/eventos ainda nao implementados.
+
+## Quando usar
+
+Ao propor uma nova acao no vocabulario, adicione um template no arquivo (sem
+event_seq, sem ts) ilustrando a estrutura esperada. Quando implementada, o
+template e movido para o event store canonico com event_seq real, e a entrada
+removida deste arquivo.
+
+## Garantia de nao-contaminacao
+
+O runtime so consome `.roadmap/activity.jsonl` (ver `EVENT_STORE_PATH` em
+`src/esaa/constants.py`). Qualquer outro arquivo `.jsonl` em `.roadmap/` e
+ignorado.
+"""
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    target = Path(args.root) / "docs/spec/activity_future_templates.md"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(DOC, encoding="utf-8")
+    print(f"wrote: {target}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

audit/eventstore_integrity.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""AUD-1201 — Integridade do event store e replay de projecao.
+
+Checa monotonicidade/gaps de event_seq, append-only e reprodutibilidade das
+projecoes por replay (em especial lessons.json). Read-only.
+"""
+from __future__ import annotations
+import argparse, json
+from pathlib import Path
+
+def parse_events(path: Path):
+    events = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if line:
+            events.append(json.loads(line))
+    return events
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    root = Path(args.root)
+    findings = []
+
+    store = root / ".roadmap/activity.jsonl"
+    if not store.exists():
+        print(json.dumps({"checker": "eventstore_integrity", "findings": [
+            {"id": "ERR", "severity": "high", "title": "event store ausente"}]}, indent=2))
+        return 0
+    events = parse_events(store)
+
+    seqs = [e["event_seq"] for e in events]
+    if seqs != sorted(seqs):
+        findings.append({"id": "R-order", "severity": "high",
+                         "title": "event_seq fora de ordem", "evidence": {"seqs": seqs}})
+    gaps = [i for i in range(1, len(seqs)) if seqs[i] != seqs[i-1] + 1]
+    if gaps:
+        findings.append({"id": "R-gap", "severity": "high",
+                         "title": "gaps em event_seq", "evidence": {"positions": gaps}})
+
+    # lessons reproducibility: lessons so nascem de issue.report(category=process,subtype=lesson)
+    lesson_sources = [e for e in events
+                      if e["action"] == "issue.report"
+                      and e.get("payload", {}).get("category") == "process"
+                      and e.get("payload", {}).get("subtype") == "lesson"]
+    stored = root / ".roadmap/lessons.json"
+    stored_lessons = json.loads(stored.read_text(encoding="utf-8")).get("lessons", []) if stored.exists() else []
+    if stored_lessons and not lesson_sources:
+        findings.append({
+            "id": "R1", "severity": "critical",
+            "title": "lessons.json NAO e reconstruivel por replay",
+            "evidence": {"stored_lessons": [l["lesson_id"] for l in stored_lessons],
+                         "lesson_creating_events": 0},
+            "recommendation": "Modelar lessons como eventos (issue.report/lesson) ou outra acao versionada; senao 'esaa project' apaga as lessons.",
+        })
+
+    # schema_version misto nos eventos
+    ev_versions = sorted({e.get("schema_version") for e in events})
+    if len(ev_versions) > 1:
+        findings.append({
+            "id": "R3b", "severity": "medium",
+            "title": "schema_version misto no event store",
+            "evidence": {"versions": ev_versions},
+            "recommendation": "make_event usa constante fixa e regride eventos novos para a versao antiga.",
+        })
+
+    print(json.dumps({"checker": "eventstore_integrity",
+                      "events": len(events), "findings": findings}, indent=2, ensure_ascii=False))
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(main())

audit/rename_parcer.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""FIX-1521 — Rename PARCER_PROFILE_agent-docs.yaml para PARCER_PROFILE.agent-docs.yaml.
+
+Adota convencao '.' (4 dos 5 profiles ja usam). Atualiza referencias textuais
+em CLAUDE.md e AGENTS.md. O evento 7 do event store permanece imutavel com o
+nome antigo (registro historico valido).
+
+Uso: python src/audit/rename_parcer.py --root <repo_root>
+"""
+from __future__ import annotations
+import argparse, re, shutil
+from pathlib import Path
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", default=".")
+    args = ap.parse_args()
+    root = Path(args.root)
+    old = root / ".roadmap/PARCER_PROFILE_agent-docs.yaml"
+    new = root / ".roadmap/PARCER_PROFILE.agent-docs.yaml"
+    if old.exists() and not new.exists():
+        shutil.move(str(old), str(new))
+        print(f"renamed: {old.name} -> {new.name}")
+    elif new.exists():
+        print("already renamed")
+    else:
+        print("source file not found; skipping")
+
+    for ref in (root / ".claude/CLAUDE.md", root / "AGENTS.md"):
+        if not ref.exists():
+            continue
+        txt = ref.read_text(encoding="utf-8")
+        new_txt = re.sub(r"PARCER_PROFILE_agent-docs\.yaml", "PARCER_PROFILE.agent-docs.yaml", txt)
+        if new_txt != txt:
+            ref.write_text(new_txt, encoding="utf-8")
+            print(f"updated refs in {ref}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())