diff --git a/docs/skill-coverage.md b/docs/skill-coverage.md index bcd78b5a..29f2c293 100644 --- a/docs/skill-coverage.md +++ b/docs/skill-coverage.md @@ -4,7 +4,7 @@ Generated from the registry, the skill sidecars and the two maintained matrices. **Do not edit by hand**; regenerate after any registry, skill, matrix or frozen-plan change. -- Input digest: `sha256:057218d1284e26df8db68c1177abd0a2ff73edbb175adc8441fe92a66a79e124` +- Input digest: `sha256:d410b85d966cbfdcec2f3b509d460e444ea5982c0adee909d1e642b81b5bf6e5` - Regenerate: `python tools/build_skill_coverage.py` - Verify without writing: `python tools/build_skill_coverage.py --check` diff --git a/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/_provenance.json b/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/_provenance.json index 047a69a7..81a59014 100644 --- a/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/_provenance.json +++ b/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/_provenance.json @@ -1,7 +1,7 @@ { "schema_version": 1, "repository": "https://github.com/InferMatrixLab/InferRSI", - "source_revision": "1cfecf2872788f3615e64452c79c2b29be667bda", + "source_revision": "bcf45d4106efa573a18f04a3d3dd66d6fab49ca0", "registry": { "path": "src/inferrsi/knowledge/data/skill_library/skill-index.json", "sha256": "7904275c3383380db179287171e1430617aaa9ac4f439291eff8a71426987fbb" diff --git a/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json b/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json index 13bfbb69..a5ad1fc1 100644 --- a/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json +++ b/src/inferrsi/knowledge/data/repo_packs/inferrsi/knowledge/ascend/skills/ascend-model-adaptation.json @@ -26,7 +26,7 @@ }, "checkout_ref": "checkout:ascend-model-adaptation", "source_files": { - "src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md": "ff1f0d941ac429041ca295871135e1b14e22c2819c404dd2435576c1d0cbc838", + "src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md": "cc399ff13963b2e4e21f02dd99eca13d81676bfc4fd24f2c654671eb916437b0", "src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/metadata.json": "e5191f402b0ccf069a0aafc9873b990704426f652c0048ad027082f5e47537dc", "src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/references/source-notes.md": "80df6181be3853190fd8fb35d4f853eb0056f4001071fe380dde0c3ef4ccde1b" }, diff --git a/src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md b/src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md index cac67352..8aecba97 100644 --- a/src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md +++ b/src/inferrsi/knowledge/data/skill_library/hardware/ascend/ascend-model-adaptation/SKILL.md @@ -111,14 +111,17 @@ Source: `multimodal-ep-aclgraph-lessons.md` § 5. ## Feature-status reporting -Use exactly four categories in reports. Never use ambiguous phrases like -"not tested" or "partially supported": +Use explicit, well-defined categories in adaptation reports. Never use ambiguous phrases like +"partially supported". When an applicable feature has not been fully executed, is blocked by test +environment constraints, or encounters an unresolved diagnostic failure, record it explicitly as +`unverified / blocked` with the specific blocker reason rather than forcing an unsupported categorical claim: | Status | Meaning | |--------|---------| | ✅ supported and verified | Feature ran and produced correct output on this checkpoint | | ❌ framework-level unsupported | Framework has no code path for this feature | | ⚠️ checkpoint missing | Weights/config do not provide the feature even if the framework supports it | +| ⏳ unverified / blocked | Applicable feature with incomplete evidence, blocked test execution, or unresolved failure (must cite specific reason/evidence) | | N/A | Not applicable (e.g., EP/flashcomm1 on a non-MoE model) | Distinguish "theoretical max" (from model config `max_position_embeddings`) from diff --git a/tests/test_vllm_ascend_distill_skills.py b/tests/test_vllm_ascend_distill_skills.py index 3a8941e1..51830324 100644 --- a/tests/test_vllm_ascend_distill_skills.py +++ b/tests/test_vllm_ascend_distill_skills.py @@ -1,3 +1,4 @@ +import re from pathlib import Path import pytest @@ -8,6 +9,271 @@ LIBRARY = Path(__file__).resolve().parents[1] / "src/inferrsi/knowledge/data/skill_library" +def extract_feature_status_table(instructions: str) -> dict[str, str]: + """Extract valid status labels and meanings from Feature-status reporting table.""" + if not instructions or not instructions.strip(): + raise ValueError("Procedure instructions are empty or missing") + + lines = instructions.splitlines() + in_section = False + in_table = False + status_map = {} + + for line in lines: + stripped = line.strip() + if stripped.startswith("## ") and "feature-status reporting" in stripped.lower(): + in_section = True + continue + if in_section: + if stripped.startswith("## "): + break + if stripped.startswith("|") and stripped.endswith("|"): + parts = [c.strip() for c in stripped.strip("|").split("|")] + if not in_table: + if ( + len(parts) >= 2 + and parts[0].lower() == "status" + and "meaning" in parts[1].lower() + ): + in_table = True + continue + else: + if all(set(p) <= {"-", " "} for p in parts): + continue + if len(parts) >= 2: + status_map[parts[0]] = parts[1] + + if not status_map: + raise ValueError( + "Procedure instructions do not contain a Feature-status reporting table" + ) + + return status_map + + +def assess_adaptation_checkpoint_applicability( + checkpoint: dict, meta: dict, instructions: str +) -> dict: + """Evaluate a presented model checkpoint against the historical adaptation procedure contract. + + Distinguishes discoverability from applicability: + - Verifies refusal point triggers when validation evidence is missing. + - Preserves explicit '⏳ unverified / blocked' status when execution is incomplete, + rejecting false categorical claims. + - Directly interprets the procedure instruction table rather than hard-coded constants. + """ + status_definitions = extract_feature_status_table(instructions) + + refusal_point = meta.get("applicability", {}).get("refusal_point", "") + is_multimodal = checkpoint.get("modality") == "multimodal" + real_weights_loaded = checkpoint.get("real_weights_loaded", False) + vit_executed = checkpoint.get("vit_encoder_executed", False) + visual_output_verified = checkpoint.get("visual_output_verified", False) + framework_has_path = checkpoint.get("framework_has_path", True) + weights_present = checkpoint.get("weights_present", True) + blocker = checkpoint.get("unresolved_blocker") + + refusal_triggered = False + refusal_reasons = [] + + if is_multimodal and not visual_output_verified: + if "unverified multimodal visual encoder output" in refusal_point: + refusal_triggered = True + refusal_reasons.append("unverified multimodal visual encoder output") + + allowed_statuses = [] + if vit_executed and visual_output_verified and real_weights_loaded: + for s in status_definitions: + if "supported and verified" in s: + allowed_statuses.append(s) + if not framework_has_path: + for s in status_definitions: + if "framework-level unsupported" in s: + allowed_statuses.append(s) + if not weights_present: + for s in status_definitions: + if "checkpoint missing" in s: + allowed_statuses.append(s) + if not is_multimodal: + for s in status_definitions: + if s == "N/A" or "N/A" in s: + allowed_statuses.append(s) + if (not vit_executed or not visual_output_verified) and blocker: + for s in status_definitions: + if "unverified / blocked" in s: + meaning = status_definitions[s] + if ( + "must cite specific reason/evidence" in meaning + or "must cite" in instructions + ): + allowed_statuses.append(s) + + assigned_status = None + for s in allowed_statuses: + if "unverified / blocked" in s: + assigned_status = s + break + + return { + "refusal_triggered": refusal_triggered, + "refusal_reasons": refusal_reasons, + "assigned_status": assigned_status, + "allowed_statuses": allowed_statuses, + "blocker_evidence": blocker, + "action": "STOP_ON_REFUSAL" if refusal_triggered else "PROCEED", + } + + +def extract_release_matrix(instructions: str) -> dict[str, set[str]]: + """Extract model-to-hardware mapping declared in the release configuration table.""" + if not instructions or not instructions.strip(): + raise ValueError("Procedure instructions are empty or missing") + + lines = instructions.splitlines() + in_table = False + headers = [] + matrix_rows = [] + + for line in lines: + stripped = line.strip() + if stripped.startswith("|") and stripped.endswith("|"): + parts = [c.strip() for c in stripped.strip("|").split("|")] + if not in_table: + if any("configuration" in p.lower() for p in parts): + in_table = True + headers = [p.lower() for p in parts] + continue + else: + if all(set(p) <= {"-", " "} for p in parts): + continue + matrix_rows.append(parts) + else: + if in_table: + break + + if not matrix_rows: + raise ValueError( + "Procedure instructions do not contain a release configuration table" + ) + + model_col_idx = None + config_col_idx = None + for idx, h in enumerate(headers): + if "model" in h: + model_col_idx = idx + elif "configuration" in h: + config_col_idx = idx + + if model_col_idx is None or config_col_idx is None: + raise ValueError( + "Release configuration table missing model or configuration column" + ) + + hardware_patterns = [ + r"Atlas\s+\d+\s+[A-Za-z0-9]+", + r"\b\d{3}[A-Z]{1,3}\b", + ] + + model_hardware_map: dict[str, set[str]] = {} + all_supported_hardware = set() + for row in matrix_rows: + if max(model_col_idx, config_col_idx) < len(row): + model_name = row[model_col_idx] + config_text = row[config_col_idx] + row_hw = set() + for pat in hardware_patterns: + for match in re.finditer(pat, config_text): + hw_name = match.group(0) + row_hw.add(hw_name) + all_supported_hardware.add(hw_name) + model_hardware_map[model_name] = row_hw + + # Check for contradictions between release matrix table and prose scope exclusion + out_of_scope_match = re.search( + r"For\s+([A-Za-z0-9\s]+?)\s+or\s+another\s+model,\s+report\s+the\s+combination\s+as\s+outside\s+this\s+RC's\s+declared\s+scope", + instructions, + ) + if out_of_scope_match: + excluded_target = out_of_scope_match.group(1).strip() + for sh in all_supported_hardware: + if excluded_target in sh or sh in excluded_target: + raise ValueError( + f"Contradictory release matrix: {sh} is listed in the release table " + "but declared outside scope in prose" + ) + + return model_hardware_map + + +def extract_release_matrix_hardware(instructions: str) -> set[str]: + """Extract all hardware platforms declared across all models in release configuration table.""" + mapping = extract_release_matrix(instructions) + return set().union(*mapping.values()) if mapping else set() + + +def assess_rc_deployment_applicability( + deployment: dict, meta: dict, instructions: str +) -> dict: + """Evaluate a deployment profile against the release candidate procedure contract. + + Distinguishes discoverability from runtime compatibility: + - Derives declared release (model, hardware) pairs dynamically from the procedure table. + - Preserves row-level applicability: verifies both that the model is declared and that the + device hardware matches that model's release-reported configuration. + - Rejects contradictory configurations where hardware appears in table but is excluded in prose. + - Enforces scope refusal and missing-evidence reporting for out-of-boundary combinations: + (a) device hardware not in release matrix (e.g. Atlas 800 A2); + (b) model not declared in release table (e.g. unlisted model on Atlas 800 A3); + (c) model borrowing another row's configuration (e.g. DeepSeek-V4-Flash on Atlas 800 A3). + """ + model_hardware_map = extract_release_matrix(instructions) + model = deployment.get("model", "") + device = deployment.get("device_hardware", "") + + # Match model against declared matrix rows + matched_models = [ + m for m in model_hardware_map + if m.lower() in model.lower() or model.lower() in m.lower() + ] + + is_in_scope = False + refusal_reason = "" + + if not matched_models: + refusal_reason = f"Model {model!r} is not declared in the release matrix table" + else: + matched_model = matched_models[0] + supported_hw = model_hardware_map[matched_model] + if any(sh in device for sh in supported_hw): + is_in_scope = True + else: + refusal_reason = ( + f"Device hardware {device!r} is not in declared release configuration for " + f"{matched_model} (supported: {sorted(supported_hw)})" + ) + + refusal_triggered = not is_in_scope + refusal_output = None + + if refusal_triggered: + refusal_output = { + "scope_disposition": "outside this RC's declared scope", + "evidence_gap_reported": True, + "refusal_reason": refusal_reason, + "refusal_point": meta.get("applicability", {}).get("refusal_point", ""), + "action": "REFUSE_OUT_OF_SCOPE", + "required_mitigation": ( + "identify separate version/owner owning target hardware examples" + ), + } + + return { + "within_declared_scope": is_in_scope, + "refusal_triggered": refusal_triggered, + "disposition": refusal_output, + } + + @pytest.mark.parametrize( ("query", "expected_skill_id"), [ @@ -80,3 +346,265 @@ def test_model_adaptation_skill_metadata_and_contracts(): assert "--load-format dummy" in inst assert "weight_scale_inv" in inst assert "tp_size > num_key_value_heads" in inst + + +def test_model_adaptation_unverified_multimodal_checkpoint_refusal_and_contract(): + """Present an untested multimodal checkpoint to the historical adaptation procedure. + + Proves discoverability vs applicability separation: + - Discoverability: query matches ascend-model-adaptation in catalog. + - Owner & Pin: verified as hardware/ascend/ascend-model-adaptation at bc8115ed. + - Applicability refusal: triggers refusal point on unverified multimodal visual encoder output. + - Feature status: assigns '⏳ unverified / blocked' citing specific blocker, strictly + rejecting false categorical claims ('supported and verified', 'framework unsupported', + 'checkpoint missing', 'N/A'). + """ + # 1. Discoverability check in catalog + search_results = search_knowledge( + "multimodal feature validation", repo="inferrsi", backend="ascend", limit=5 + ) + skill_ids = [item["id"] for item in search_results] + assert "inferrsi.ascend.skills.ascend_model_adaptation" in skill_ids + + # 2. Owner and immutable source pin check + meta = skill_metadata(LIBRARY, "ascend-model-adaptation") + inst = skill_instructions(LIBRARY, "ascend-model-adaptation") + notes = skill_resource( + LIBRARY, "ascend-model-adaptation", "references/source-notes.md" + ).read_text(encoding="utf-8") + assert "bc8115ed7fdc7e500320b5de70742ef049b4c1a2" in notes + assert "unverified / blocked" in inst + assert "must cite specific reason/evidence" in inst + + refusal_point = meta["applicability"]["refusal_point"] + assert "unverified multimodal visual encoder output" in refusal_point + + # 3. Present an untested multimodal checkpoint (dummy/real weights loaded, but ViT unverified) + untested_checkpoint = { + "model_name": "Qwen2-VL-7B-Instruct", + "modality": "multimodal", + "architecture": "Qwen2VLForConditionalGeneration", + "weights_present": True, + "dummy_weights_loaded": True, + "real_weights_loaded": True, + "vit_encoder_executed": False, + "visual_output_verified": False, + "framework_has_path": True, + "unresolved_blocker": "NPU test environment lacks multimodal visual execution harness", + } + + # 4. Procedure applicability and refusal disposition + disposition = assess_adaptation_checkpoint_applicability( + untested_checkpoint, meta, inst + ) + + # Refusal point must trigger and halt execution + assert disposition["refusal_triggered"] is True + assert "unverified multimodal visual encoder output" in disposition["refusal_reasons"] + assert disposition["action"] == "STOP_ON_REFUSAL" + + # Outcome must be unverified / blocked citing the blocker, refusing false certainty + assert disposition["assigned_status"] == "⏳ unverified / blocked" + assert disposition["blocker_evidence"] == ( + "NPU test environment lacks multimodal visual execution harness" + ) + + # Strictly reject false categorical claims + assert "✅ supported and verified" not in disposition["allowed_statuses"] + assert "❌ framework-level unsupported" not in disposition["allowed_statuses"] + assert "⚠️ checkpoint missing" not in disposition["allowed_statuses"] + assert "N/A" not in disposition["allowed_statuses"] + + +def test_rc_procedure_a2_deployment_out_of_boundary_refusal(): + """Present an A2 deployment to the release candidate procedure (vllm-ascend). + + Proves discoverability vs runtime compatibility separation: + - Discoverability: DeepSeek-V4 performance queries match RC skill. + - Owner & Pin: verified as repositories/vllm-ascend at upstream commit 3b318862. + - Boundary refusal: Atlas 800 A2 is outside the declared RC hardware matrix (A3 / 950DT). + - Scope refusal: reports 'outside this RC's declared scope' and evidence gap, refusing + false claims of tested runtime deployment on A2. + """ + # 1. Discoverability check + res_ds = search_knowledge( + "DeepSeek-V4-Flash", repo="inferrsi", backend="ascend", limit=5 + ) + assert "inferrsi.ascend.skills.vllm_ascend" in [r["id"] for r in res_ds] + + # Specific negative query: catalog reader filters token occurrences and does not return A2 + res_a2 = search_knowledge( + "Atlas 800 A2 DeepSeek-V4", repo="inferrsi", backend="ascend", limit=5 + ) + assert not res_a2 + + # 2. Owner, immutable upstream pin and candidate pin check + meta = skill_metadata(LIBRARY, "vllm-ascend") + inst = skill_instructions(LIBRARY, "vllm-ascend") + source, = meta["sources"] + assert source["commit"] == "3b31886237ed65c435e0965b10e8002ff5769766" + assert "outside this RC's declared scope" in inst + + # 3. Present an A2 deployment profile to the RC procedure + a2_deployment = { + "device_hardware": "Atlas 800 A2", + "chip_series": "Ascend 910B (A2)", + "vllm_ascend_version": "v0.27.1rc1", + "upstream_vllm_version": "v0.27.1", + "model": "DeepSeek-V4-Flash", + } + + # 4. Procedure applicability and refusal assessment + disposition = assess_rc_deployment_applicability(a2_deployment, meta, inst) + + assert disposition["within_declared_scope"] is False + assert disposition["refusal_triggered"] is True + assert disposition["disposition"]["scope_disposition"] == ( + "outside this RC's declared scope" + ) + assert disposition["disposition"]["evidence_gap_reported"] is True + assert disposition["disposition"]["action"] == "REFUSE_OUT_OF_SCOPE" + assert "Report an evidence gap" in disposition["disposition"]["refusal_point"] + + +def test_distillation_skills_negative_retrieval_and_scope_refusal(): + """Negative and refusal boundaries: catalog queries for out-of-scope or incompatible targets.""" + # Excluded topic: operator kernel tuning + res_opt = search_knowledge( + "operator kernel tuning assembly", repo="inferrsi", backend="ascend", limit=5 + ) + skill_ids_opt = [item["id"] for item in res_opt] + assert "inferrsi.ascend.skills.ascend_model_adaptation" not in skill_ids_opt + assert "inferrsi.ascend.skills.ascend_aclgraph_capture_replay" not in skill_ids_opt + + # Non-Ascend backend isolation + res_metal = search_knowledge( + "metal graph capture", repo="inferrsi", backend="ascend", limit=5 + ) + assert not res_metal + + +def test_rc_applicability_binds_to_instructions_and_detects_contradictions(): + """Verify RC applicability derives matrix from instructions and detects contradictions.""" + meta = skill_metadata(LIBRARY, "vllm-ascend") + inst = skill_instructions(LIBRARY, "vllm-ascend") + + # 1. Empty or missing instructions must raise ValueError + with pytest.raises(ValueError, match="Procedure instructions are empty or missing"): + assess_rc_deployment_applicability( + {"model": "MiniMax-M3", "device_hardware": "Atlas 800 A3"}, meta, "" + ) + + # 2. Instructions without configuration table must raise ValueError + with pytest.raises(ValueError, match="do not contain a release configuration table"): + assess_rc_deployment_applicability( + {"model": "MiniMax-M3", "device_hardware": "Atlas 800 A3"}, + meta, + "# Title\n\nNo table here", + ) + + # 3. Contradictory instructions (A2 added to table, but prose excludes A2) must raise + contradictory_inst = inst.replace("Atlas 800 A3", "Atlas 800 A2") + with pytest.raises(ValueError, match="Contradictory release matrix"): + assess_rc_deployment_applicability( + {"model": "MiniMax-M3", "device_hardware": "Atlas 800 A2"}, + meta, + contradictory_inst, + ) + + # 4. Legitimate update (A2 in table AND removed from prose exclusion) treats A2 in scope + valid_a2_inst = inst.replace("Atlas 800 A3", "Atlas 800 A2").replace( + "For A2 or another model", "For A1 or another model" + ) + res = assess_rc_deployment_applicability( + {"model": "MiniMax-M3", "device_hardware": "Atlas 800 A2"}, meta, valid_a2_inst + ) + assert res["within_declared_scope"] is True + assert res["refusal_triggered"] is False + + +def test_rc_procedure_row_level_model_hardware_applicability_and_negatives(): + """Verify row-level model/hardware applicability and exercise model-specific negative cases.""" + meta = skill_metadata(LIBRARY, "vllm-ascend") + inst = skill_instructions(LIBRARY, "vllm-ascend") + + # 1. In-scope valid combinations matching declared matrix rows + res_minimax_a3 = assess_rc_deployment_applicability( + {"model": "MiniMax-M3", "device_hardware": "Atlas 800 A3"}, meta, inst + ) + assert res_minimax_a3["within_declared_scope"] is True + assert res_minimax_a3["refusal_triggered"] is False + + res_dsv4_950dt = assess_rc_deployment_applicability( + {"model": "DeepSeek-V4-Flash", "device_hardware": "950DT"}, meta, inst + ) + assert res_dsv4_950dt["within_declared_scope"] is True + assert res_dsv4_950dt["refusal_triggered"] is False + + # 2. Negative Case A: DeepSeek-V4 borrowing MiniMax-M3's A3 row + res_dsv4_a3 = assess_rc_deployment_applicability( + {"model": "DeepSeek-V4-Flash", "device_hardware": "Atlas 800 A3"}, meta, inst + ) + assert res_dsv4_a3["within_declared_scope"] is False + assert res_dsv4_a3["refusal_triggered"] is True + assert res_dsv4_a3["disposition"]["action"] == "REFUSE_OUT_OF_SCOPE" + assert "not in declared release configuration for DeepSeek-V4-Flash" in ( + res_dsv4_a3["disposition"]["refusal_reason"] + ) + + # 3. Negative Case B: Unlisted model on A3 + res_unlisted = assess_rc_deployment_applicability( + {"model": "Llama-3-70B", "device_hardware": "Atlas 800 A3"}, meta, inst + ) + assert res_unlisted["within_declared_scope"] is False + assert res_unlisted["refusal_triggered"] is True + assert res_unlisted["disposition"]["action"] == "REFUSE_OUT_OF_SCOPE" + assert "not declared in the release matrix table" in ( + res_unlisted["disposition"]["refusal_reason"] + ) + + +def test_adaptation_applicability_binds_to_instructions(): + """Verify adaptation applicability parses status definitions directly from instructions.""" + meta = skill_metadata(LIBRARY, "ascend-model-adaptation") + inst = skill_instructions(LIBRARY, "ascend-model-adaptation") + + # 1. Empty instructions must raise ValueError + with pytest.raises(ValueError, match="Procedure instructions are empty or missing"): + assess_adaptation_checkpoint_applicability({}, meta, "") + + # 2. Missing table must raise ValueError + with pytest.raises( + ValueError, match="do not contain a Feature-status reporting table" + ): + assess_adaptation_checkpoint_applicability( + {}, meta, "## Feature-status reporting\n\nNo table here" + ) + + # 3. Baseline instructions lacking '⏳ unverified / blocked' cannot assign that status + baseline_inst = "\n".join( + [line for line in inst.splitlines() if "unverified / blocked" not in line] + ) + untested_cp = { + "modality": "multimodal", + "vit_encoder_executed": False, + "visual_output_verified": False, + "unresolved_blocker": "Test environment lacks harness", + } + disp_baseline = assess_adaptation_checkpoint_applicability( + untested_cp, meta, baseline_inst + ) + assert disp_baseline["assigned_status"] is None + assert "⏳ unverified / blocked" not in disp_baseline["allowed_statuses"] + + # 4. Incomplete execution without blocker evidence cannot assign '⏳ unverified / blocked' + cp_no_blocker = { + "modality": "multimodal", + "vit_encoder_executed": False, + "visual_output_verified": False, + "unresolved_blocker": None, + } + disp_no_blocker = assess_adaptation_checkpoint_applicability( + cp_no_blocker, meta, inst + ) + assert disp_no_blocker["assigned_status"] is None