Files
Jonathan Boniface e22d037ab0 ALZ-F02 Assessment: individual agents, intake, rate card input, critic fixes
- Six declarative agents generated from the v1.1 stories (scaffold_from_stories.py, ADR 0001),
  and a 9-step workflow export (build_workflow.py).
- Code-only intake (ADR 0008) verifies the one Discovery package in code before any agent.
- The rate card is the run input rate_card_document; no upload step (ADR 0009).
- Critic 0.1.6 after live runs on crucible-kab-dev:
  - K-12 model independence checked at build time against each agent's deployed model
    (ADR 0010); the critic reports it from its two inputs;
  - receives in_cloud_estate for K-10; an unverified K-10 never fails the run alone;
  - K-08 allows the scoring note to list findings as advisory, as ALZ-ASM-04 must;
  - carries ALZ-ASM-03's and ALZ-ASM-04's rule sections, copied by the scaffold, so it can
    recalculate risk, confidence and TCO.
- The scaffold refuses to regenerate unless every story file is present.
- Case azure-crucible-kab-dev-assessment with an illustrative rate card.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 22:13:25 +00:00

115 lines
5.5 KiB
Python

"""The Assessment intake (F02 ADR 0008): the Discovery package is checked in code before any Assessment agent reads it.
`p1` (Parse Assessment Files over the selected artifacts) hands over each artifact's text, joined by the platform's
file separator. A JSON artifact arrives as its raw text, so the package is found by parsing each document and
looking, at any depth (KAB may wrap a step's output, or hold it as a JSON string), for the object Discovery's package
step writes: `package_version` and `manifest` (F01 ADR 0020).
Checks, all in code:
- exactly one package among the selected artifacts;
- a `package_version` this intake reads;
- every part the manifest lists is present, and its `sha256` over the part's canonical JSON matches;
- the manifest says `complete`, and the critic's verdict is `pass`;
- the manifest's execution id and engagement match the run's `discovery_execution_id` and `engagement_id`.
Any failure refuses the intake, so the step fails and no Assessment agent runs on an unchecked package. No model is
involved.
"""
from __future__ import annotations
import hashlib
import json
from typing import Any, Dict, Iterator, List, Optional
FILE_SEPARATOR = "\n\n---\n\n" # the platform's join between parsed files (data_file_processing.py)
READS = ("1.0",)
class IntakeRefused(RuntimeError):
"""The Discovery package failed a check: the step fails, and Assessment does not start."""
def __init__(self, problems: List[str]):
super().__init__("The Discovery package was refused: " + "; ".join(problems))
self.problems = problems
def digest(part: Any) -> str:
"""The same canonical form the package step hashes (F01 ADR 0020)."""
text = json.dumps(part, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return "sha256:" + hashlib.sha256(text.encode("utf-8")).hexdigest()
def _decode(value: Any, depth: int = 0) -> Any:
while isinstance(value, str) and depth < 3:
try:
value, depth = json.loads(value), depth + 1
except ValueError:
return value
return value
def _packages(value: Any, depth: int = 0) -> Iterator[Dict[str, Any]]:
value = _decode(value)
if depth > 6:
return
if isinstance(value, dict):
if "package_version" in value and isinstance(value.get("manifest"), dict):
yield value
return
for item in value.values():
yield from _packages(item, depth + 1)
elif isinstance(value, list):
for item in value:
yield from _packages(item, depth + 1)
def find(documents: Optional[str]) -> List[Dict[str, Any]]:
found = []
for document in (documents or "").split(FILE_SEPARATOR):
found += list(_packages(document.strip()))
return found
def check(payload: Dict[str, Any]) -> Dict[str, Any]:
packages = find(payload.get("discovery_documents"))
if len(packages) != 1:
raise IntakeRefused([f"{len(packages)} Discovery packages among the selected artifacts; select exactly one "
"(the Discovery run's package step output)"])
package = packages[0]
manifest = package["manifest"]
problems = []
if package.get("package_version") not in READS:
problems.append(f"package version {package.get('package_version')} is not one this intake reads ({', '.join(READS)})")
verified = []
for name, entry in (manifest.get("parts") or {}).items():
if name not in package:
problems.append(f"part {name} is listed in the manifest but missing")
elif digest(package[name]) != entry.get("sha256"):
problems.append(f"part {name} does not match its sha256: it changed after the package was made")
else:
verified.append(name)
if not manifest.get("complete"):
problems.append("the package is not complete: " + ("; ".join(manifest.get("problems") or []) or "no reason given"))
if manifest.get("critic_verdict") != "pass":
problems.append(f"the Discovery critic's verdict is {manifest.get('critic_verdict') or 'absent'}, not pass")
expected = payload.get("discovery_execution_id")
if expected and manifest.get("execution_id") != expected:
problems.append(f"the package is from {manifest.get('execution_id') or 'an unknown run'}, not {expected}")
if payload.get("engagement_id") and manifest.get("engagement_id") != payload["engagement_id"]:
problems.append(f"the package is for engagement {manifest.get('engagement_id')}, not {payload['engagement_id']}")
if problems:
raise IntakeRefused(problems)
grouped = package.get("applications") or {}
return {
"engagement_id": payload.get("engagement_id"), "run_id": payload.get("run_id"),
"verified": True, "package_version": package["package_version"],
"discovery_execution_id": manifest.get("execution_id"), "discovery_run_id": manifest.get("run_id"),
"critic_verdict": manifest["critic_verdict"], "provider": manifest.get("provider"),
"parts_verified": verified, "absent_parts": manifest.get("absent_parts") or [],
"source_gaps": manifest.get("source_gaps") or [], "agent_versions": manifest.get("agent_versions") or {},
"applications": grouped.get("applications") or [], "ungrouped_assets": grouped.get("ungrouped_assets") or [],
"scorecard": manifest.get("scorecard") or {},
"note": (f"Discovery package {manifest.get('execution_id')} verified: {len(verified)} parts match their "
f"sha256, the critic passed, {len(grouped.get('applications') or [])} applications."),
}