YAO
31ce04c655
Merge the beta-ready Yao Meta Skill architecture, report, evidence gate, and release-boundary updates.\n\nRelease boundary: beta/public testing is allowed; formal world-class, fully reviewed, or superiority claims remain blocked until the pending evidence gates are accepted.
287 lines
12 KiB
Python
287 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Build machine-readable repair checklists for world-class submission kits."""
|
|
|
|
from collections import defaultdict
|
|
import re
|
|
from typing import Any
|
|
|
|
|
|
SCRIPT_INTERFACE = "internal-module"
|
|
SCRIPT_INTERFACE_REASON = "Shared by submission kit generation to turn readiness blockers into actionable repair rows."
|
|
|
|
|
|
OWNER_BY_EVIDENCE = {
|
|
"provider-holdout": "operator with provider credentials",
|
|
"human-adjudication": "human reviewer",
|
|
"native-permission-enforcement": "target client or installer integrator",
|
|
"native-client-telemetry": "Browser/Chrome/IDE/provider client integrator",
|
|
}
|
|
|
|
REPAIR_PHASES = {
|
|
"unknown-key": ("select-evidence", 5),
|
|
"draft": ("prepare-draft", 10),
|
|
"precheck": ("unblock-access", 20),
|
|
"artifact": ("attach-artifacts", 30),
|
|
"source-check": ("collect-source", 40),
|
|
}
|
|
|
|
|
|
def _by_key(rows: list[dict[str, Any]], key_name: str = "evidence_key") -> dict[str, list[dict[str, Any]]]:
|
|
grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
|
for row in rows:
|
|
key = str(row.get(key_name, "")).strip()
|
|
if key:
|
|
grouped[key].append(row)
|
|
return dict(grouped)
|
|
|
|
|
|
def _slug(value: str) -> str:
|
|
slug = re.sub(r"[^a-zA-Z0-9_.-]+", "-", value.strip()).strip("-")
|
|
return slug or "repair"
|
|
|
|
|
|
def repair_verification_command(evidence_key: str, repair_type: str) -> str:
|
|
preflight = "python3 scripts/yao.py world-class-preflight . --submissions-dir evidence/world_class/submissions"
|
|
if repair_type == "draft":
|
|
return (
|
|
"python3 scripts/yao.py world-class-submission-kit . "
|
|
f"--evidence-key {evidence_key} --output-dir evidence/world_class/submissions"
|
|
)
|
|
if repair_type == "artifact":
|
|
return (
|
|
"python3 scripts/yao.py world-class-submission-kit . "
|
|
f"--evidence-key {evidence_key} --output-dir evidence/world_class/submissions --prefill-artifacts"
|
|
)
|
|
if repair_type == "unknown-key":
|
|
return "python3 scripts/yao.py world-class-intake . --submissions-dir evidence/world_class/submissions"
|
|
if evidence_key == "provider-holdout" and repair_type == "source-check":
|
|
return (
|
|
"python3 scripts/yao.py output-exec --provider-runner <openai|deepseek> "
|
|
"--provider-model <model> --timeout-seconds 60 && "
|
|
+ preflight
|
|
)
|
|
if evidence_key == "human-adjudication" and repair_type == "source-check":
|
|
return "python3 scripts/yao.py output-review && " + preflight
|
|
if evidence_key == "native-permission-enforcement" and repair_type == "source-check":
|
|
return "python3 scripts/yao.py runtime-permissions . --package-dir dist && " + preflight
|
|
if evidence_key == "native-client-telemetry" and repair_type == "source-check":
|
|
return (
|
|
"python3 scripts/yao.py telemetry-import . "
|
|
"--input-jsonl .yao/telemetry_spool/external_events.jsonl && "
|
|
+ preflight
|
|
)
|
|
return preflight
|
|
|
|
|
|
def _repair_row(
|
|
*,
|
|
evidence_key: str,
|
|
repair_type: str,
|
|
target: str,
|
|
status: str,
|
|
blocking_reason: str,
|
|
next_action: str,
|
|
source: str,
|
|
) -> dict[str, Any]:
|
|
phase, priority = REPAIR_PHASES.get(repair_type, ("repair", 90))
|
|
return {
|
|
"action_id": _slug(f"{evidence_key}:{repair_type}:{target}"),
|
|
"evidence_key": evidence_key,
|
|
"repair_type": repair_type,
|
|
"target": target,
|
|
"phase": phase,
|
|
"priority": priority,
|
|
"owner": OWNER_BY_EVIDENCE.get(evidence_key, "release reviewer"),
|
|
"status": status,
|
|
"blocking_reason": blocking_reason,
|
|
"next_action": next_action,
|
|
"verification_command": repair_verification_command(evidence_key, repair_type),
|
|
"source": source,
|
|
"counts_as_completion": False,
|
|
}
|
|
|
|
|
|
def sort_repair_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
|
return sorted(
|
|
rows,
|
|
key=lambda row: (
|
|
int(row.get("priority", 90) or 90),
|
|
str(row.get("evidence_key", "")),
|
|
str(row.get("target", "")),
|
|
),
|
|
)
|
|
|
|
|
|
def build_repair_checklist(
|
|
evidence_items: list[dict[str, Any]],
|
|
files: list[dict[str, Any]],
|
|
artifact_checklist: list[dict[str, Any]],
|
|
source_checklist: list[dict[str, Any]],
|
|
unknown_keys: list[str],
|
|
) -> list[dict[str, Any]]:
|
|
"""Return concrete repair rows for every draft, artifact, and source blocker."""
|
|
files_by_key = _by_key(files)
|
|
artifacts_by_key = _by_key(artifact_checklist)
|
|
sources_by_key = _by_key(source_checklist)
|
|
rows: list[dict[str, Any]] = []
|
|
known_keys = [str(item.get("evidence_key", "")).strip() for item in evidence_items]
|
|
|
|
for key in known_keys:
|
|
if not key:
|
|
continue
|
|
draft_rows = files_by_key.get(key, [])
|
|
if not draft_rows:
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="draft",
|
|
target=key,
|
|
status="blocked",
|
|
blocking_reason="Submission draft was not generated.",
|
|
next_action="Run the submission kit command again for this evidence key.",
|
|
source="files",
|
|
)
|
|
)
|
|
for draft in draft_rows:
|
|
draft_status = str(draft.get("status", "")).strip()
|
|
if draft_status not in {"written", "exists"}:
|
|
target = str(draft.get("output_path") or draft.get("template_path") or key)
|
|
errors = draft.get("errors", [])
|
|
error_text = "; ".join(str(error) for error in errors) if isinstance(errors, list) else ""
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="draft",
|
|
target=target,
|
|
status="blocked",
|
|
blocking_reason=error_text or f"Draft status is {draft_status or 'unknown'}.",
|
|
next_action="Fix template generation before asking for ledger review.",
|
|
source="files",
|
|
)
|
|
)
|
|
|
|
for artifact in artifacts_by_key.get(key, []):
|
|
if artifact.get("artifact_ref_ready"):
|
|
continue
|
|
target = str(artifact.get("path") or artifact.get("source_pattern") or key)
|
|
artifact_status = str(artifact.get("status", "missing"))
|
|
role = str(artifact.get("artifact_role", "supporting-evidence"))
|
|
if artifact.get("concrete_reference_required"):
|
|
action = "Replace the glob with concrete files, then reference the generated SHA-256 digests."
|
|
elif artifact.get("submission_ref_required"):
|
|
action = "Create the required submission artifact or update artifact_refs to a concrete existing aggregate file."
|
|
else:
|
|
action = "Add the supporting artifact if it is needed for reviewer audit."
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="artifact",
|
|
target=target,
|
|
status="blocked",
|
|
blocking_reason=f"{role} artifact is {artifact_status}.",
|
|
next_action=action,
|
|
source="artifact_checklist",
|
|
)
|
|
)
|
|
|
|
for source in sources_by_key.get(key, []):
|
|
if source.get("status") == "pass":
|
|
continue
|
|
field = str(source.get("field") or source.get("label") or key)
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="source-check",
|
|
target=field,
|
|
status="blocked",
|
|
blocking_reason=f"Current value {source.get('actual')!r} does not satisfy {source.get('expected')!r}.",
|
|
next_action=str(source.get("next_action") or "Collect the required source evidence."),
|
|
source="source_checklist",
|
|
)
|
|
)
|
|
|
|
for key in unknown_keys:
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="unknown-key",
|
|
target=key,
|
|
status="blocked",
|
|
blocking_reason="Requested evidence key is not present in the operator checklist.",
|
|
next_action="Use one of the evidence keys listed by world-class-intake.",
|
|
source="unknown_evidence_keys",
|
|
)
|
|
)
|
|
|
|
return sort_repair_rows(rows)
|
|
|
|
|
|
def build_preflight_repair_checklist(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
|
"""Return repair rows from preflight precheck and source-check blockers."""
|
|
rows: list[dict[str, Any]] = []
|
|
for item in items:
|
|
key = str(item.get("evidence_key", "")).strip()
|
|
if not key:
|
|
continue
|
|
for precheck in item.get("prechecks", []):
|
|
if not isinstance(precheck, dict):
|
|
continue
|
|
if precheck.get("required") is not True or precheck.get("status") == "pass":
|
|
continue
|
|
target = str(precheck.get("key") or precheck.get("label") or key)
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="precheck",
|
|
target=target,
|
|
status="blocked",
|
|
blocking_reason=(
|
|
f"Required {precheck.get('kind', 'precheck')} precheck is "
|
|
f"{precheck.get('status', 'unknown')}."
|
|
),
|
|
next_action=str(precheck.get("next_action") or "Complete the required preflight action."),
|
|
source="prechecks",
|
|
)
|
|
)
|
|
for source in item.get("source_checklist", []):
|
|
if not isinstance(source, dict):
|
|
continue
|
|
if source.get("status") == "pass":
|
|
continue
|
|
target = str(source.get("field") or source.get("label") or key)
|
|
rows.append(
|
|
_repair_row(
|
|
evidence_key=key,
|
|
repair_type="source-check",
|
|
target=target,
|
|
status="blocked",
|
|
blocking_reason=(
|
|
f"Current value {source.get('actual')!r} does not satisfy "
|
|
f"{source.get('expected')!r}."
|
|
),
|
|
next_action=str(source.get("next_action") or "Collect the required source evidence."),
|
|
source="source_checklist",
|
|
)
|
|
)
|
|
return sort_repair_rows(rows)
|
|
|
|
|
|
def summarize_repair_checklist(rows: list[dict[str, Any]]) -> dict[str, Any]:
|
|
blocked_count = sum(1 for row in rows if row.get("status") != "ready")
|
|
phase_counts: dict[str, int] = {}
|
|
for row in rows:
|
|
phase = str(row.get("phase", "repair"))
|
|
phase_counts[phase] = phase_counts.get(phase, 0) + 1
|
|
next_row = sort_repair_rows(rows)[0] if rows else {}
|
|
return {
|
|
"repair_checklist_count": len(rows),
|
|
"repair_blocked_count": blocked_count,
|
|
"repair_ready_count": len(rows) - blocked_count,
|
|
"repair_phase_counts": phase_counts,
|
|
"next_repair_action_id": next_row.get("action_id", ""),
|
|
"next_repair_phase": next_row.get("phase", ""),
|
|
"next_repair_owner": next_row.get("owner", ""),
|
|
"next_repair_command": next_row.get("verification_command", ""),
|
|
"repair_counts_as_completion": False,
|
|
}
|