its-magic 0.1.2-37 → 0.1.2-38

package/installer.ps1

@@ -405,6 +405,24 @@ function Invoke-ScratchpadPostinstall {
   if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 }
 
+function Invoke-InstallCompletenessValidation {
+  param(
+    [string]$TargetRoot
+  )
+  $installerPy = Join-Path $scriptDir "installer.py"
+  if (-not (Test-Path $installerPy -PathType Leaf)) {
+    Write-Host "[INSTALL_COMPLETENESS_FAILED] installer.py missing next to installer.ps1."
+    exit 1
+  }
+  $py = Get-Command python -ErrorAction SilentlyContinue
+  if (-not $py) {
+    Write-Host "[INSTALL_COMPLETENESS_FAILED] PYTHON_NOT_FOUND: Python is required for deterministic installer completeness validation."
+    exit 1
+  }
+  & python $installerPy --validate-install-completeness --target $TargetRoot
+  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+}
+
 function Show-ItsMagicBanner([switch]$IncludeInstallMessage) {
   $prev = [Console]::OutputEncoding
   [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
@@ -643,6 +661,7 @@ if ($mode -eq "upgrade") {
   }
 
   Invoke-ScratchpadPostinstall -TargetRoot $targetRoot -Mode "upgrade"
+  Invoke-InstallCompletenessValidation -TargetRoot $targetRoot
 
   Write-InstalledVersion $targetRoot $appVersion
   Sync-RootReadmeToItsMagic $targetRoot | Out-Null
@@ -724,6 +743,7 @@ foreach ($rel in $files) {
 }
 
 Invoke-ScratchpadPostinstall -TargetRoot $targetRoot -Mode $mode
+Invoke-InstallCompletenessValidation -TargetRoot $targetRoot
 
 Write-InstalledVersion $targetRoot $appVersion
 Sync-RootReadmeToItsMagic $targetRoot | Out-Null

package/installer.py

@@ -11,6 +11,7 @@ from datetime import datetime
 
 REPO_URL = "https://github.com/fl0wm0ti0n/its-magic"
 MANIFEST_RELATIVE_PATH = os.path.join("docs", "engineering", "context", "installer-owned-paths.manifest")
+MANIFEST_REQUIRED_SCRIPTS_SECTION = "required_install_script_paths"
 
 
 def normalize(path):
@@ -67,12 +68,42 @@ def load_ownership_manifest(source_root, script_dir):
             continue
         install_paths = read_manifest_paths(path, "install_include_paths")
         clean_paths = read_manifest_paths(path, "clean_paths")
+        required_script_paths = read_manifest_paths(path, MANIFEST_REQUIRED_SCRIPTS_SECTION)
         if not install_paths or not clean_paths:
             raise RuntimeError(f"[INSTALL_MANIFEST_ERROR] {path} is missing required sections or entries.")
-        return install_paths, clean_paths
+        if not required_script_paths:
+            raise RuntimeError(
+                f"[INSTALL_MANIFEST_ERROR] {path} is missing [{MANIFEST_REQUIRED_SCRIPTS_SECTION}] entries."
+            )
+        return install_paths, clean_paths, required_script_paths, path
     raise RuntimeError("[INSTALL_SOURCE_ERROR] installer-owned-paths.manifest not found. Reinstall its-magic package.")
 
 
+def validate_install_completeness(target_root, source_root, required_script_paths, manifest_path):
+    missing_paths = []
+    for rel in sorted(set(required_script_paths)):
+        src = os.path.join(source_root, rel)
+        dst = os.path.join(target_root, rel)
+        if not os.path.isfile(src) or not os.path.isfile(dst):
+            missing_paths.append(rel.replace("\\", "/"))
+    if not missing_paths:
+        return True
+    print(
+        "[INSTALL_COMPLETENESS_FAILED] Required installer scripts are missing after "
+        "copy/classification invariant check."
+    )
+    for rel in missing_paths:
+        print(f"[INSTALL_REQUIRED_SCRIPT_MISSING:{rel}]")
+    print(
+        "Fix: update manifest parity and required-script inventory at "
+        f"{MANIFEST_RELATIVE_PATH} (section [{MANIFEST_REQUIRED_SCRIPTS_SECTION}]), "
+        "ensure each listed script exists in template/scripts and clean-path ownership, "
+        "then rerun installer missing/upgrade."
+    )
+    print(f"Manifest source: {manifest_path}")
+    return False
+
+
 def ensure_parent(path):
     parent = os.path.dirname(path)
     if parent and not os.path.isdir(parent):
@@ -684,6 +715,12 @@ def main():
         action="store_true",
         help=argparse.SUPPRESS,
     )
+    parser.add_argument("--source-root", help=argparse.SUPPRESS)
+    parser.add_argument(
+        "--validate-install-completeness",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
     args = parser.parse_args()
 
     if len(sys.argv) == 1 or args.help:
@@ -694,6 +731,9 @@ def main():
         print(f"its-magic v{version}")
         return 0
 
+    if args.source_root:
+        source_root = normalize(args.source_root)
+
     if args.scratchpad_postinstall:
         target_root = normalize(args.target) if args.target else normalize(".")
         mode = args.mode or "missing"
@@ -712,11 +752,31 @@ def main():
         ok = run_scratchpad_postinstall(target_root, source_root, mode, print_ok=True)
         return 0 if ok else 1
 
+    if args.validate_install_completeness:
+        target_root = normalize(args.target) if args.target else normalize(".")
+        if not os.path.isdir(target_root):
+            print(f"[INSTALL_COMPLETENESS_FAILED] target directory missing: {target_root}")
+            return 1
+        if not os.path.isdir(source_root):
+            print("[INSTALL_SOURCE_ERROR] template directory is missing. Reinstall its-magic package.")
+            return 1
+        try:
+            _install_paths, _clean_paths, required_script_paths, manifest_path = load_ownership_manifest(
+                source_root, script_dir
+            )
+        except RuntimeError as exc:
+            print(str(exc))
+            return 1
+        ok = validate_install_completeness(target_root, source_root, required_script_paths, manifest_path)
+        return 0 if ok else 1
+
     if not os.path.isdir(source_root):
         print("[INSTALL_SOURCE_ERROR] template directory is missing. Reinstall its-magic package.")
         return 1
     try:
-        include_paths, clean_paths = load_ownership_manifest(source_root, script_dir)
+        include_paths, clean_paths, required_script_paths, manifest_path = load_ownership_manifest(
+            source_root, script_dir
+        )
     except RuntimeError as exc:
         print(str(exc))
         return 1
@@ -818,6 +878,8 @@ def main():
 
         if not run_scratchpad_postinstall(target_root, source_root, "upgrade", print_ok=True):
             return 1
+        if not validate_install_completeness(target_root, source_root, required_script_paths, manifest_path):
+            return 1
 
         write_installed_version(target_root, version)
         sync_root_readme_to_its_magic(target_root)
@@ -896,6 +958,8 @@ def main():
 
     if not run_scratchpad_postinstall(target_root, source_root, mode, print_ok=True):
         return 1
+    if not validate_install_completeness(target_root, source_root, required_script_paths, manifest_path):
+        return 1
 
     write_installed_version(target_root, version)
     sync_root_readme_to_its_magic(target_root)

package/installer.sh

@@ -151,6 +151,23 @@ scratchpad_postinstall() {
   fi
 }
 
+validate_install_completeness() {
+  target_root="$1"
+  installer_py="$SCRIPT_DIR/installer.py"
+  if [ ! -f "$installer_py" ]; then
+    printf "%s\n" "[INSTALL_COMPLETENESS_FAILED] installer.py missing next to installer.sh."
+    exit 1
+  fi
+  if command -v python3 >/dev/null 2>&1; then
+    python3 "$installer_py" --validate-install-completeness --target "$target_root" || exit $?
+  elif command -v python >/dev/null 2>&1; then
+    python "$installer_py" --validate-install-completeness --target "$target_root" || exit $?
+  else
+    printf "%s\n" "[INSTALL_COMPLETENESS_FAILED] PYTHON_NOT_FOUND: Python is required for deterministic installer completeness validation."
+    exit 1
+  fi
+}
+
 classify_file() {
   rel="$1"
   case "$rel" in
@@ -535,6 +552,7 @@ if [ "$MODE" = "upgrade" ]; then
   done
 
   scratchpad_postinstall "$TARGET_ROOT" "upgrade"
+  validate_install_completeness "$TARGET_ROOT"
 
   write_installed_version "$TARGET_ROOT" "$APP_VERSION"
   sync_root_readme_to_its_magic "$TARGET_ROOT" || true
@@ -606,6 +624,7 @@ for rel in $FILES; do
 done
 
 scratchpad_postinstall "$TARGET_ROOT" "$MODE"
+validate_install_completeness "$TARGET_ROOT"
 
 write_installed_version "$TARGET_ROOT" "$APP_VERSION"
 sync_root_readme_to_its_magic "$TARGET_ROOT" || true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "its-magic",
-  "version": "0.1.2-37",
+  "version": "0.1.2-38",
   "description": "its-magic - AI dev team workflow for Cursor.",
   "license": "MIT",
   "bin": {
@@ -16,6 +16,7 @@
     "scripts/intake_evidence_lib.py",
     "scripts/intake_bug_routing_guard.py",
     "scripts/check_intake_template_parity.py",
+    "scripts/materialize_codebase_map.py",
     "bin/its-magic.js",
     "bin/postinstall.js"
   ],

package/scripts/intake_evidence_lib.py

@@ -1,5 +1,6 @@
 """
-Deterministic intake evidence validation (US-0078 / DEC-0060 / R-0055).
+Deterministic intake evidence validation
+(US-0078 / US-0083 / DEC-0060 / DEC-0067 / R-0055).
 
 Consumes a logical intake_evidence bundle (dict). PO workflows MUST run this
 gate before mutating backlog/acceptance; failures are fail-closed.
@@ -14,6 +15,7 @@ from dataclasses import dataclass, field
 from typing import Any
 
 IE_REF_RE = re.compile(r"^ie:([^:]+):(\d+):([0-9a-f]{16})$")
+PLAN_AREA_ID_RE = re.compile(r"^[a-z0-9][a-z0-9_-]{1,63}$")
 
 PACK_REQUIRED_KEYS: dict[str, tuple[str, ...]] = {
     "first-intake-pack": (
@@ -51,6 +53,8 @@ SAFE_ASSUMPTION_LITERALS = frozenset(
 )
 
 FALSE_CONFIRMATION_LITERALS = frozenset({"yes", "true", "confirmed"})
+ALLOWED_SATISFIED_BY = frozenset({"answer_ref", "assumption_confirmation_ref", "delegation_ref"})
+DELEGATION_CONFIDENCE_VALUES = frozenset({"low", "medium", "high"})
 
 
 def canonical_json_sha256_16(obj: dict[str, Any]) -> str:
@@ -187,6 +191,197 @@ def _row_turn(row: dict[str, Any]) -> int | None:
         return None
 
 
+def _row_uses_equivalent_evidence(row: dict[str, Any]) -> bool:
+    """
+    US-0083 AC-1: allow required-topic accounting without forcing repetitive asks
+    when equivalent evidence is already captured and explicitly referenced.
+    """
+    marker = str(row.get("evidence_source") or "").strip()
+    if marker != "equivalent_evidence_ref":
+        return False
+    return bool(str(row.get("equivalent_evidence_ref") or "").strip())
+
+
+def _candidate_story_ids(bundle: dict[str, Any]) -> set[str]:
+    out: set[str] = set()
+
+    raw_ids = bundle.get("candidate_story_ids")
+    if isinstance(raw_ids, list):
+        for sid in raw_ids:
+            sv = str(sid).strip()
+            if sv:
+                out.add(sv)
+
+    raw_story_ids = bundle.get("story_ids")
+    if isinstance(raw_story_ids, list):
+        for sid in raw_story_ids:
+            sv = str(sid).strip()
+            if sv:
+                out.add(sv)
+
+    raw_story_map = bundle.get("story_map")
+    if isinstance(raw_story_map, list):
+        for row in raw_story_map:
+            if not isinstance(row, dict):
+                continue
+            sv = str(row.get("story_id") or "").strip()
+            if sv:
+                out.add(sv)
+
+    return out
+
+
+def _validate_plan_coverage_contract(bundle: dict[str, Any], res: ValidationResult) -> None:
+    inventory_raw = bundle.get("plan_area_inventory")
+    coverage_raw = bundle.get("plan_area_coverage")
+    coverage_complete_raw = bundle.get("coverage_complete")
+    candidate_story_ids = _candidate_story_ids(bundle)
+
+    inventory_rows = inventory_raw if isinstance(inventory_raw, list) else []
+    coverage_rows = coverage_raw if isinstance(coverage_raw, list) else []
+
+    inventory_ids: list[str] = []
+    coverage_by_id: dict[str, dict[str, Any]] = {}
+
+    coverage_missing = False
+    id_invalid = False
+    contract_invalid = False
+    deferred_ref_missing = False
+
+    if not inventory_rows:
+        coverage_missing = True
+        res.diagnostics.append(
+            "Remediation: plan_area_inventory must be a non-empty list for first/new/broad intake."
+        )
+    if not coverage_rows:
+        coverage_missing = True
+        res.diagnostics.append(
+            "Remediation: plan_area_coverage must be a non-empty list for first/new/broad intake."
+        )
+
+    seen_inventory_ids: set[str] = set()
+    for row in inventory_rows:
+        if not isinstance(row, dict):
+            id_invalid = True
+            continue
+        plan_area_id = str(row.get("plan_area_id") or "").strip()
+        if not PLAN_AREA_ID_RE.match(plan_area_id):
+            id_invalid = True
+            continue
+        if plan_area_id in seen_inventory_ids:
+            id_invalid = True
+            continue
+        seen_inventory_ids.add(plan_area_id)
+        inventory_ids.append(plan_area_id)
+
+    for row in coverage_rows:
+        if not isinstance(row, dict):
+            id_invalid = True
+            continue
+        plan_area_id = str(row.get("plan_area_id") or "").strip()
+        if not PLAN_AREA_ID_RE.match(plan_area_id):
+            id_invalid = True
+            continue
+        if plan_area_id in coverage_by_id:
+            id_invalid = True
+            continue
+        coverage_by_id[plan_area_id] = row
+
+    inventory_id_set = set(inventory_ids)
+    coverage_id_set = set(coverage_by_id.keys())
+
+    if inventory_id_set != coverage_id_set:
+        coverage_missing = True
+        missing_ids = sorted(inventory_id_set - coverage_id_set)
+        extra_ids = sorted(coverage_id_set - inventory_id_set)
+        if missing_ids:
+            res.diagnostics.append(
+                "Remediation: add plan_area_coverage rows for uncovered plan_area_id values: "
+                + ", ".join(missing_ids)
+            )
+        if extra_ids:
+            contract_invalid = True
+            res.diagnostics.append(
+                "Remediation: remove unknown plan_area_coverage plan_area_id values not in plan_area_inventory: "
+                + ", ".join(extra_ids)
+            )
+
+    for plan_area_id in sorted(inventory_id_set & coverage_id_set):
+        row = coverage_by_id[plan_area_id]
+        story_ids_raw = row.get("story_ids")
+        deferred_ref = str(row.get("deferred_ref") or "").strip()
+
+        story_ids: list[str] = []
+        if isinstance(story_ids_raw, list):
+            for sid in story_ids_raw:
+                sv = str(sid).strip()
+                if sv:
+                    story_ids.append(sv)
+        has_story_ids = bool(story_ids)
+        has_deferred_ref = bool(deferred_ref)
+
+        if has_story_ids == has_deferred_ref:
+            contract_invalid = True
+            res.diagnostics.append(
+                "Remediation: each plan_area_coverage row must set exactly one mapping path "
+                "(story_ids xor deferred_ref) for plan_area_id "
+                + repr(plan_area_id)
+                + "."
+            )
+            continue
+
+        if has_story_ids:
+            if candidate_story_ids:
+                unknown_story_ids = sorted({sid for sid in story_ids if sid not in candidate_story_ids})
+                if unknown_story_ids:
+                    contract_invalid = True
+                    res.diagnostics.append(
+                        "Remediation: plan_area_id "
+                        + repr(plan_area_id)
+                        + " references unknown story_ids not present in candidate story set: "
+                        + ", ".join(unknown_story_ids)
+                    )
+        else:
+            deferred_reason = str(row.get("deferred_reason") or "").strip()
+            if not deferred_reason:
+                deferred_ref_missing = True
+                res.diagnostics.append(
+                    "Remediation: deferred mapping for plan_area_id "
+                    + repr(plan_area_id)
+                    + " requires both deferred_ref and deferred_reason."
+                )
+
+    derived_coverage_complete = not (coverage_missing or id_invalid or contract_invalid or deferred_ref_missing)
+    if coverage_complete_raw is not True:
+        contract_invalid = True
+        res.diagnostics.append(
+            "Remediation: set coverage_complete=true only after plan_area_inventory and "
+            "plan_area_coverage pass deterministic validation."
+        )
+    if bool(coverage_complete_raw) != derived_coverage_complete:
+        contract_invalid = True
+        res.diagnostics.append(
+            "Remediation: coverage_complete must match derived contract result from "
+            "plan_area_inventory/plan_area_coverage validation."
+        )
+
+    if coverage_missing:
+        res.ok = False
+        res.add_code("INTAKE_PLAN_COVERAGE_MISSING")
+    if id_invalid:
+        res.ok = False
+        res.add_code("INTAKE_PLAN_AREA_ID_INVALID")
+        res.diagnostics.append(
+            "Remediation: plan_area_id must be unique and match ^[a-z0-9][a-z0-9_-]{1,63}$ in inventory and coverage."
+        )
+    if deferred_ref_missing:
+        res.ok = False
+        res.add_code("INTAKE_PLAN_DEFERRED_REF_MISSING")
+    if contract_invalid:
+        res.ok = False
+        res.add_code("INTAKE_PLAN_COVERAGE_CONTRACT_INVALID")
+
+
 def validate_intake_evidence(
     bundle: dict[str, Any],
     *,
@@ -232,15 +427,44 @@ def validate_intake_evidence(
             qtxt = ""
         qtxt = str(qtxt)
 
-        if sat not in ("answer_ref", "assumption_confirmation_ref"):
+        if sat not in ALLOWED_SATISFIED_BY:
             res.ok = False
             res.diagnostics.append(
                 f"Remediation: topic {k!r} must set satisfied_by to "
-                f"'answer_ref' or 'assumption_confirmation_ref' (got {sat!r})."
+                f"'answer_ref', 'assumption_confirmation_ref', or 'delegation_ref' (got {sat!r})."
             )
             missing_cov.append(k)
             continue
 
+        if sat == "delegation_ref":
+            scope = str(row.get("delegation_scope") or "").strip()
+            rationale = str(row.get("delegation_rationale") or "").strip()
+            confidence = str(row.get("delegation_confidence") or "").strip().lower()
+            if not scope or not rationale or not confidence:
+                res.ok = False
+                res.add_code("INTAKE_DELEGATION_EVIDENCE_MISSING")
+                missing_fields = []
+                if not scope:
+                    missing_fields.append("delegation_scope")
+                if not rationale:
+                    missing_fields.append("delegation_rationale")
+                if not confidence:
+                    missing_fields.append("delegation_confidence")
+                res.diagnostics.append(
+                    f"Remediation: delegated topic {k!r} requires non-empty fields: "
+                    + ", ".join(missing_fields)
+                    + "."
+                )
+                continue
+            if confidence not in DELEGATION_CONFIDENCE_VALUES:
+                res.ok = False
+                res.add_code("INTAKE_DELEGATION_EVIDENCE_INVALID")
+                res.diagnostics.append(
+                    f"Remediation: delegated topic {k!r} delegation_confidence must be one of "
+                    f"{sorted(DELEGATION_CONFIDENCE_VALUES)!r} (got {confidence!r})."
+                )
+                continue
+
         irid = _row_run_id(bundle, row)
         tit = _row_turn(row)
         if irid is None or tit is None:
@@ -261,11 +485,18 @@ def validate_intake_evidence(
             quoted_user_text=qtxt,
         ):
             res.ok = False
-            res.diagnostics.append(
-                f"Remediation: topic {k!r} ref is malformed or hash mismatch — rebuild ie: ref "
-                f"with DEC-0060 canonical JSON (sorted keys) and quoted_user_text."
-            )
-            missing_cov.append(k)
+            if sat == "delegation_ref":
+                res.add_code("INTAKE_DELEGATION_EVIDENCE_INVALID")
+                res.diagnostics.append(
+                    f"Remediation: delegated topic {k!r} ref is malformed or hash mismatch — rebuild ie: ref "
+                    f"with DEC-0060 canonical JSON (sorted keys) and quoted_user_text."
+                )
+            else:
+                res.diagnostics.append(
+                    f"Remediation: topic {k!r} ref is malformed or hash mismatch — rebuild ie: ref "
+                    f"with DEC-0060 canonical JSON (sorted keys) and quoted_user_text."
+                )
+                missing_cov.append(k)
 
     if missing_cov:
         res.ok = False
@@ -283,16 +514,23 @@ def validate_intake_evidence(
         if k not in by_key:
             continue
         if k not in asked:
+            row = by_key[k]
+            if _row_uses_equivalent_evidence(row):
+                continue
             res.ok = False
             res.add_code("INTAKE_REQUIRED_TOPIC_MISSING")
             res.diagnostics.append(
-                f"Remediation: add {k!r} to asked_topics — covered topics must have been "
-                f"prompted in-session (R-0055 asked-vs-covered; DEC-0060)."
+                f"Remediation: add {k!r} to asked_topics or mark evidence_source='equivalent_evidence_ref' "
+                f"with equivalent_evidence_ref when reusing previously captured equivalent evidence."
             )
             if k not in res.missing_topics:
                 res.missing_topics.append(k)
     res.missing_topics = sorted(set(res.missing_topics))
 
+    # US-0081 / DEC-0064: first/new/broad intake requires complete-plan coverage contract.
+    if pack == "first-intake-pack":
+        _validate_plan_coverage_contract(bundle, res)
+
     ac = bundle.get("assumptions_confirmed")
     ac_str = ac if isinstance(ac, str) else ("(none)" if ac is None else str(ac))
 
@@ -397,3 +635,69 @@ def self_test() -> None:
     r1 = validate_intake_evidence(bundle, intake_guided_mode=1)
     assert r0.ok and r1.ok
     assert r0.primary_codes == r1.primary_codes
+
+    # US-0083 delegated-topic pass path
+    delegated_key = "done_definition"
+    rows2 = []
+    for i, key in enumerate(small):
+        sat = "delegation_ref" if key == delegated_key else "answer_ref"
+        txt = f"d{i}"
+        row = {
+            "topic_key": key,
+            "satisfied_by": sat,
+            "quoted_user_text": txt,
+            "intake_run_id": rid,
+            "turn_index": 200 + i,
+            "ref": build_ie_ref(rid, 200 + i, key, sat, txt),
+        }
+        if sat == "delegation_ref":
+            row["delegation_scope"] = "Implementation defaults for done criteria wording"
+            row["delegation_rationale"] = "User asked to proceed without additional specificity."
+            row["delegation_confidence"] = "medium"
+        rows2.append(row)
+    delegated_bundle = {
+        "selected_pack": "small-intake-pack",
+        "intake_run_id": rid,
+        "asked_topics": list(small),
+        "missing_topics": [],
+        "assumptions_confirmed": "(none)",
+        "topic_coverage": rows2,
+    }
+    d0 = validate_intake_evidence(delegated_bundle, intake_guided_mode=0)
+    d1 = validate_intake_evidence(delegated_bundle, intake_guided_mode=1)
+    assert d0.ok and d1.ok
+    assert d0.primary_codes == d1.primary_codes
+
+    # First-intake full-plan coverage contract (US-0081 / DEC-0064)
+    first = PACK_REQUIRED_KEYS["first-intake-pack"]
+    first_rows = []
+    for i, key in enumerate(first):
+        first_rows.append(
+            {
+                "topic_key": key,
+                "satisfied_by": "answer_ref",
+                "quoted_user_text": f"b{i}",
+                "intake_run_id": rid,
+                "turn_index": i,
+                "ref": build_ie_ref(rid, i, key, "answer_ref", f"b{i}"),
+            }
+        )
+    full_bundle = {
+        "selected_pack": "first-intake-pack",
+        "intake_run_id": rid,
+        "asked_topics": list(first),
+        "missing_topics": [],
+        "assumptions_confirmed": "(none)",
+        "topic_coverage": first_rows,
+        "candidate_story_ids": ["US-9001", "US-9002"],
+        "plan_area_inventory": [
+            {"plan_area_id": "auth", "title": "Auth"},
+            {"plan_area_id": "billing", "title": "Billing"},
+        ],
+        "plan_area_coverage": [
+            {"plan_area_id": "auth", "story_ids": ["US-9001"]},
+            {"plan_area_id": "billing", "story_ids": ["US-9002"]},
+        ],
+        "coverage_complete": True,
+    }
+    assert validate_intake_evidence(full_bundle, intake_guided_mode=0).ok

package/scripts/intake_evidence_validate.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Validate intake_evidence JSON bundles (US-0078 / DEC-0060).
+Validate intake_evidence JSON bundles (US-0078 / US-0083 / DEC-0060 / DEC-0067).
 
 Used by PO workflow preflight and CI fixtures.
 """
@@ -21,7 +21,7 @@ import intake_evidence_lib  # noqa: E402
 
 
 def main() -> int:
-    p = argparse.ArgumentParser(description="Validate intake_evidence JSON (US-0078).")
+    p = argparse.ArgumentParser(description="Validate intake_evidence JSON (US-0078/US-0083).")
     p.add_argument("--file", help="Path to JSON file containing one intake_evidence object.")
     p.add_argument(
         "--stdin",