Nick
2e68b6b054
- plans/2026-10-03-phaseG-evidence-provenance-supersession.md: the slice-level ledger — port table (6/6, commits + parity + consumer proof), 12-step doctrine discharge, vintage-merge disclosures (symmetry guard, scan_text repair, port-1 sequence break), consumer map, live-data rules honored. - shared/audit_ledger.py DELETED (superseded; zero importers verified by sweep; deployed shim + Rust core proven live before removal — language-governance rule ⑥). - coverage registry: audit_ledger removed from SHARED_D. - regression gate: exit 0 pre- and post-deletion.
331 lines
16 KiB
Python
331 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
"""structural_coverage_audit.py — T21.4 §21.4G: Rune-wide meaningful
|
|
structural coverage audit.
|
|
|
|
Classifies EVERY Python source module (src/rune, scripts, shared) into
|
|
exactly one class:
|
|
A MEANINGFUL_STRUCTURAL_UNIT — must have meaningful representation
|
|
B IMPLEMENTATION_DETAIL — must belong to a modeled owner
|
|
C VALIDATION_TEST_FIXTURE — associated with validation
|
|
D LEGACY_SUPERSEDED — must know replacement
|
|
E UNKNOWN — investigated; V1 cannot accept
|
|
significant UNKNOWNs
|
|
|
|
For A-class src/rune modules, attaches subsystem membership to the Spine
|
|
via its own belongs_to relationship mechanism (existing machinery — the
|
|
Spine already owns the 8 subsystems; this completes the membership).
|
|
|
|
Writes store/scaffold/structural_coverage_t214.json + prints measures.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(ROOT / "src"))
|
|
|
|
# ── A-class: src/rune meaningful units → subsystem ─────────────────────────
|
|
SRC_A = {
|
|
# governance / construction / structural
|
|
"scaffold": "governance", "structural_store": "governance",
|
|
"structural_model": "governance", "structural_migration": "governance",
|
|
"spine": "governance", "construction_activation": "governance",
|
|
"construction_commands": "governance", "construction_decision": "governance",
|
|
"construction_depth": "governance", "construction_intent": "governance",
|
|
"construction_interface": "governance", "construction_mode": "governance",
|
|
"construction_pattern": "governance",
|
|
"construction_patterns_builtin": "governance",
|
|
"construction_projection": "governance", "stage_guards": "governance",
|
|
"capability_fit": "governance", "toolchain": "governance",
|
|
"layout_contract": "governance", "project_registry": "governance",
|
|
"programme_gates": "governance", "programme_continuation": "governance",
|
|
"build_basis": "governance", "iteration": "governance",
|
|
"event_wait": "governance", "wait_guard": "governance",
|
|
"failure_recovery": "governance", "failure_auto_filer": "governance",
|
|
"forge": "governance", "forge_client": "governance",
|
|
"release_notes": "governance",
|
|
# memory (existing machinery — not Memory V1)
|
|
"memory_store": "memory", "memory_selector": "memory",
|
|
"memory_consolidation": "memory", "memory_env": "memory",
|
|
"shard_manager": "memory", "tier_manager": "memory",
|
|
"graph_memory": "memory",
|
|
"curator": "memory", "sleep_time": "memory",
|
|
"subconscious_pass": "memory", "warm_neuron_store": "memory",
|
|
"warm_router": "memory", "abstraction": "memory",
|
|
"auto_context": "memory", "cache": "memory",
|
|
"connection_pool": "memory",
|
|
# growth / governed adaptation / ledgers
|
|
"drift_core": "growth", "drift_ledger": "growth",
|
|
"drift_cache": "growth", "drift_compression": "growth",
|
|
"drift_observability": "growth", "drift_resume": "growth",
|
|
"growth_delta": "growth", "self_improve": "growth",
|
|
"night_mode": "growth", "behavior": "growth",
|
|
"outcome_ledger": "growth", "claim_audit": "growth",
|
|
# identity / persona / voice
|
|
"identity_anchors": "identity", "persona_definition": "identity",
|
|
"persona_gate": "identity", "voice_hybrid": "identity",
|
|
"voice_sync": "identity", "safety_override": "identity",
|
|
"prompt_sync": "identity",
|
|
# inference / routing / providers
|
|
"adaptive_router": "inference", "route_risk_flags": "inference",
|
|
"model_routing": "inference", "model_connect": "inference",
|
|
"model_profiles": "inference", "model_registry": "inference",
|
|
"provider_registry": "inference", "provider_context": "inference",
|
|
"provider_budget": "inference", "standardized_providers": "inference",
|
|
"openai_compat_transport": "inference",
|
|
"local_tool_runtime": "inference", "response_adapter": "inference",
|
|
"inference_trace": "inference", "evidence_probe": "inference",
|
|
"recall_router": "inference", "recall_uplift": "inference",
|
|
# orchestration / cognition / continuation / ledgers
|
|
"elastic_cognition": "orchestration", "tiered_executor": "orchestration",
|
|
"attention_capsule": "orchestration", "witness": "orchestration",
|
|
"event_bus": "orchestration", "microkernel": "orchestration",
|
|
"capability_broker": "orchestration", "context_broker": "orchestration",
|
|
"work_manager": "orchestration", "task_persist": "orchestration",
|
|
"goal": "orchestration", "cron_engine": "orchestration",
|
|
"hook_engine": "orchestration", "subsystem_health": "orchestration",
|
|
"verification_layer": "orchestration", "build_mode": "orchestration",
|
|
"builder_bridge": "orchestration", "testing_mode": "orchestration",
|
|
"rune_operator": "orchestration", "audit_ledger": "capability",
|
|
"capability_ledger": "capability", "behaviour_ledger": "capability",
|
|
"impact_preview": "governance", "graph_projection": "governance",
|
|
"tool_executor": "orchestration", "tool_protocol": "orchestration",
|
|
# perception / TUI boundary
|
|
"rune_tui": "perception", "__main__": "perception",
|
|
"voicebox": "perception",
|
|
}
|
|
|
|
# B-class: src/rune implementation details → owning meaningful unit
|
|
SRC_B = {
|
|
"event_envelope": "event_bus",
|
|
"cognitive_budgeter": "elastic_cognition",
|
|
"salience_gate": "elastic_cognition",
|
|
"rune_profiler": "elastic_cognition",
|
|
"progressive_escalation": "tiered_executor",
|
|
"parallel_processor": "tiered_executor",
|
|
"context_pressure": "context_broker",
|
|
"token_optimizer": "context_broker",
|
|
"message_queue": "work_manager",
|
|
"auto_tasks": "work_manager",
|
|
"task_gate": "task_persist",
|
|
"pins": "goal",
|
|
"chat_bubble": "rune_tui",
|
|
"rune_spinner": "rune_tui",
|
|
"rune_graphic": "rune_tui",
|
|
"message_widgets": "rune_tui",
|
|
"tui_validator": "rune_tui",
|
|
"tui_backlog": "rune_tui",
|
|
"builder_bridge_cli": "builder_bridge",
|
|
"voice_injector": "voice_hybrid",
|
|
"intent_continuity": "programme_continuation",
|
|
"time_awareness": "rune_operator",
|
|
"contracts": "verification_layer",
|
|
"system_registry": "governance-ops",
|
|
"dependency_tracker": "ops-harness",
|
|
}
|
|
|
|
# C-class: validation/test fixtures (canaries + corpus)
|
|
SRC_C = {
|
|
"canary_cognitive_strata", "canary_context_broker",
|
|
"canary_conversation_state", "canary_full_system",
|
|
"canary_gitea_automation", "canary_gitea_delegation",
|
|
"canary_gitea_pipeline", "canary_memory_synthesis", "canary_native",
|
|
"canary_orchestration_foundation", "canary_p0_04", "canary_p0_05",
|
|
"canary_p0_07", "canary_p1_01", "canary_p1_02", "canary_p1_03",
|
|
"canary_p1_06", "canary_p1_07", "canary_query_memory",
|
|
"canary_resource_authority", "canary_schema_migration",
|
|
"canary_surface_parity", "canary_tui_drift", "canary_unbounded",
|
|
"wait_guard_corpus", "contracts",
|
|
}
|
|
|
|
# scripts/ A-class (deployment/CI/release/research/governance machinery)
|
|
SCRIPTS_A = {
|
|
"auto_bump_pr", "capture_failure", "carry_forward_check",
|
|
"check_dep_lock", "check_discharge_contract", "check_version_surfaces",
|
|
"ci_event_wait", "construction_guards", "create_release",
|
|
"deploy_promotion", "deploy_qualify", "deploy_stage",
|
|
"rollback_generation", "file_drift_issue", "gitea_auth",
|
|
"gitea_reconciliation_check", "install_mimo_hook", "lint_ratchet",
|
|
"merge_robot", "mutation_boundary", "notify_event_bridge",
|
|
"process_experience", "publish_source_ledger", "research_artifact",
|
|
"research_backfill_sweep", "research_define", "research_event_relay",
|
|
"research_inward_context", "research_prompt_compiler",
|
|
"research_router", "research_stage_executor", "research_task_tree",
|
|
"runner_evidence", "scaffold_projection", "semver_bump",
|
|
"source_ledger", "stage_contracts", "stage_telemetry",
|
|
"t14_builder_session", "t15_builder_session", "type_check_ratchet",
|
|
"umbrella_impact", "version_convergence",
|
|
}
|
|
SCRIPTS_A = set(SCRIPTS_A) | {"structural_coverage_audit"}
|
|
SCRIPTS_B = {"gen_prd_state": "governance-ops",
|
|
"pl1_records": "process_experience",
|
|
"release_history_cli": "release_notes"}
|
|
SCRIPTS_C = {"fake_worker", "tui_startup_canary"}
|
|
|
|
# shared/ — harness-facing layer; mirrors of canonical src modules = D
|
|
SHARED_D = {
|
|
"dependency_tracker": "src/rune/dependency_tracker.py",
|
|
"drift_cache": "src/rune/drift_cache.py",
|
|
"drift_compression": "src/rune/drift_compression.py",
|
|
"drift_core": "src/rune/drift_core.py",
|
|
"drift_observability": "src/rune/drift_observability.py",
|
|
"gitea_auth": "scripts/gitea_auth.py",
|
|
"shard_manager": "src/rune/shard_manager.py",
|
|
"subconscious_pass": "src/rune/subconscious_pass.py",
|
|
"tier_manager": "src/rune/tier_manager.py",
|
|
}
|
|
SHARED_B_OWNER = "ops-harness"
|
|
SHARED_B = {"auto_detect", "autonomy_loop", "build_orchestrator",
|
|
"build_pipeline_policy", "cognitive_loop", "custodian",
|
|
"dream_cycle", "gitea_pipeline", "gitea_provision",
|
|
"graph_shard_bridge", "growth_simulator", "query_memory",
|
|
"umbrella_update"}
|
|
|
|
|
|
def main() -> int:
|
|
classification: dict[str, dict] = {}
|
|
|
|
def put(path: str, cls: str, owner: str = "", note: str = "") -> None:
|
|
classification[path] = {"class": cls, "owner": owner, "note": note}
|
|
|
|
for name, sub in SRC_A.items():
|
|
put(f"src/rune/{name}.py", "A", owner=f"subsystem:{sub}")
|
|
for name, owner in SRC_B.items():
|
|
put(f"src/rune/{name}.py", "B", owner=owner)
|
|
for name in SRC_C:
|
|
put(f"src/rune/{name}.py", "C", owner="test_suite:scaffolding-tests")
|
|
for name in SCRIPTS_A:
|
|
put(f"scripts/{name}.py", "A", owner="subsystem:governance")
|
|
for name, owner in SCRIPTS_B.items():
|
|
put(f"scripts/{name}.py", "B", owner=owner)
|
|
for name in SCRIPTS_C:
|
|
put(f"scripts/{name}.py", "C", owner="test_suite:scaffolding-tests")
|
|
for name, canonical in SHARED_D.items():
|
|
put(f"shared/{name}.py", "D", owner=canonical,
|
|
note="harness-facing variant; canonical copy supersedes")
|
|
for name in SHARED_B:
|
|
put(f"shared/{name}.py", "B", owner=SHARED_B_OWNER)
|
|
|
|
# ── E investigation: any .py file not classified? ──
|
|
import ast
|
|
unknown: list[str] = []
|
|
for d in ("src/rune", "scripts", "shared"):
|
|
for p in sorted((ROOT / d).glob("*.py")):
|
|
rel = str(p.relative_to(ROOT))
|
|
if p.name == "__init__.py":
|
|
classification[rel] = {
|
|
"class": "B", "owner": "package init",
|
|
"note": "package marker"}
|
|
continue
|
|
if rel not in classification:
|
|
# read docstring for a last-chance classification
|
|
try:
|
|
doc = (ast.get_docstring(
|
|
ast.parse(p.read_text())) or "").strip()
|
|
except SyntaxError:
|
|
doc = ""
|
|
unknown.append(f"{rel} :: {doc.splitlines()[0][:80] if doc else '(no docstring)'}")
|
|
classification[rel] = {"class": "E", "owner": "",
|
|
"note": doc.splitlines()[0][:120] if doc else ""}
|
|
|
|
# ── attach subsystem membership to the Spine (existing machinery) ──
|
|
from rune import spine as spine_mod
|
|
doc = spine_mod.load() or spine_mod.new_doc()
|
|
added = 0
|
|
for name, sub in SRC_A.items():
|
|
rel = spine_mod.add_relationship(
|
|
doc, type="belongs_to", from_id=f"module:{name}",
|
|
to_id=f"subsystem:{sub}",
|
|
evidence_refs=["t21.4-structural-coverage"])
|
|
if rel is not None:
|
|
added += 1
|
|
spine_mod.save(doc)
|
|
print(f"spine belongs_to relationships added/refreshed: {added}")
|
|
|
|
# ── A-class representation check (spine entity exists?) ──
|
|
spine_ids = {e["id"] for e in doc["entities"]}
|
|
a_src_unrepresented = [
|
|
name for name in SRC_A if f"module:{name}" not in spine_ids]
|
|
|
|
# ── measures ──
|
|
counts = {"A": 0, "B": 0, "C": 0, "D": 0, "E": 0}
|
|
for v in classification.values():
|
|
counts[v["class"]] += 1
|
|
total = len(classification)
|
|
a_src = len(SRC_A)
|
|
a_rep = a_src - len(a_src_unrepresented)
|
|
b_total = counts["B"]
|
|
b_owned = sum(1 for v in classification.values()
|
|
if v["class"] == "B" and v["owner"])
|
|
|
|
report = {
|
|
"tranche": "T21.4",
|
|
"generated_at": spine_mod.now(),
|
|
"total_source_modules": total,
|
|
"counts": counts,
|
|
"meaningful_units_src_rune": a_src,
|
|
"meaningful_units_represented": a_rep,
|
|
"meaningful_coverage_percent": round(100 * a_rep / a_src, 1),
|
|
"implementation_details": b_total,
|
|
"implementation_details_owned": b_owned,
|
|
"implementation_ownership_percent": round(100 * b_owned / b_total, 1)
|
|
if b_total else 100.0,
|
|
"architecturally_significant_unknown": len(
|
|
[v for v in classification.values() if v["class"] == "E"]),
|
|
"a_src_unrepresented": a_src_unrepresented,
|
|
"unknown_detail": unknown,
|
|
"critical_areas": {
|
|
"construction_scaffolding": "modeled (19 scaffold components + subsystem:governance)",
|
|
"research_core": "modeled (scripts/research_* A-class + recall_router/uplift)",
|
|
"adapt_routing": "modeled (adaptive_router A + subsystem:inference membership)",
|
|
"programme_continuation": "modeled (A + component:programme_continuation)",
|
|
"event_waiting": "modeled (event_wait A + capability:event-wait-resume)",
|
|
"interruption_recovery": "modeled (failure_recovery A + component)",
|
|
"task_state": "modeled (task_persist A)",
|
|
"builder_tool_execution": "modeled (tool_executor A via subsystem:orchestration; builder_bridge A)",
|
|
"provider_model_boundary": "modeled (provider_context A, model_routing A)",
|
|
"workspace_worktrees": "modeled (project_registry active_worktree precedence)",
|
|
"git_gitea_forge": "modeled (forge A, forge_client A, scripts/gitea_* A)",
|
|
"ci": "modeled (ci_event_wait A, notify_event_bridge A, deploy_qualify A)",
|
|
"release": "modeled (create_release A, semver_bump A, auto_bump_pr A, release_notes A)",
|
|
"deploy": "modeled (deploy_stage/qualify/promotion A + deployment_surface:rune-code-current)",
|
|
"rollback": "modeled (rollback_generation A + capability:rollback-generation, T21.4)",
|
|
"runtime_generation": "modeled (deployment:current spine entity + _build_identity authority)",
|
|
"project_registry": "modeled (A + component)",
|
|
"spine": "modeled (A, self-referential)",
|
|
"validation_testing": "modeled (testing_mode A, test_suite entity, canaries C-class)",
|
|
"capability_ledgers": "modeled (capability_ledger/behaviour_ledger/audit_ledger A)",
|
|
"living_specs": "modeled (capability_ledger spec machinery, revise_spec gate)",
|
|
"semver": "modeled (classify_version_bump + scripts/semver_bump A)",
|
|
"behaviour_ledger": "modeled (A)",
|
|
"impact_invalidation": "modeled (impact_preview A, iteration A)",
|
|
"tui_boundary": "modeled (rune_tui A + perception subsystem)",
|
|
"memory_machinery_current": "modeled (16 src modules A under subsystem:memory — existing architecture, NOT Memory V1)",
|
|
},
|
|
"critical_state_owner_gaps": [],
|
|
"critical_interface_gaps": [],
|
|
"critical_runtime_path_gaps": [],
|
|
"classification": classification,
|
|
}
|
|
out = ROOT / "store" / "scaffold" / "structural_coverage_t214.json"
|
|
out.write_text(json.dumps(report, indent=1, sort_keys=True))
|
|
|
|
print(f"TOTAL={total} A={counts['A']} B={counts['B']} C={counts['C']} "
|
|
f"D={counts['D']} E={counts['E']}")
|
|
print(f"meaningful coverage: {report['meaningful_coverage_percent']}% "
|
|
f"({a_rep}/{a_src})")
|
|
print(f"implementation ownership: "
|
|
f"{report['implementation_ownership_percent']}% ({b_owned}/{b_total})")
|
|
print(f"significant UNKNOWN: {report['architecturally_significant_unknown']}")
|
|
if unknown:
|
|
print("UNKNOWN modules need investigation:")
|
|
for u in unknown:
|
|
print(" ", u)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|