Learn
Build the mental model and inspect the mechanism beneath the API.
ONE+i OPEN LEARNINGVISION / FIELD GUIDE
ONE+i OPEN LEARNING · NOTEBOOK FIRST · MEASUREMENT LED
Start with pixels you can inspect, then compare learned representations with real modern encoders. Break the system on purpose, measure the failure, and carry that discipline into multimodal, spatial, embodied, and enterprise vision.
Build the mental model and inspect the mechanism beneath the API.
Run deterministic code, change one variable, and observe intermediate state.
Explain the trade-off, diagnose a failure, and choose the next experiment.
THE 2026 CAPABILITY PATH
Fundamentals stay visible, while the course moves quickly into foundation, multimodal, spatial, embodied, and enterprise systems. Current research is labeled by maturity and tied to primary sources.
Modern architectures · Detection / segmentation / tracking · Vision transformers · Self-supervised learning
Promptable vision · Open-vocabulary vision · Foundation segmentation · Vision embeddings
Vision-language models · Multimodal reasoning · Video LLMs · Multimodal RAG · Visual agents
Depth / geometry · 3D reconstruction · Gaussian splatting · Generative 3D · 4D scenes · Spatial reasoning
Vision-language-action · Robot learning · Egocentric vision · World models · Simulation · Vision-based planning
Synthetic data · Edge vision · Evaluation · Observability · Security / robustness · Privacy · Governance
CHOOSE YOUR ENVIRONMENT
Browse without installing, create one course-sized environment, or install the complete contributor stack. Python 3.13 is the tested default; every course pins its exercised dependencies.
Read every chapter and complete all 24 checkpoints directly in this Hub.
Open the curriculum ↓make setup-course \
COURSE=curriculum/beginner/01-modern-computer-vision-foundationsInstalls only that lesson and its tested constraints.
make setup
make checkInstalls the contributor/CI environment and verifies every notebook.
THE CURRICULUM MAP
Complete lessons link to runnable notebooks and source chapters. Planned tracks make the progression explicit without pretending unfinished material is available.
YOUR LOCAL PROGRESS
0 / 24 published courses completed
Saved only in this browser after a perfect checkpoint score.Edge systems, evaluation, observability, security, robustness, privacy, and governance.
Inspection, multimodal knowledge, video operations, spatial twins, and embodied agents.
BEGINNER · COURSE 01
8–10 HOURS · CPU DEFAULT
OUTCOME
Frame a vision task, learn and reuse visual representations, measure clean and shifted performance, and turn model confidence into a bounded enterprise decision.
Follow one five-class quality-inspection scenario from image contracts and convolution through scratch CNN training, frozen ResNet/ConvNeXt embeddings, partial fine-tuning, failure analysis, abstention, and monitoring.
PRACTICAL LAB
Compare a scratch CNN, two frozen pretrained encoders, and partial fine-tuning; inspect embeddings; inject shift; and save an enterprise decision record.
Run the guided notebook ↗model, weights, _ = build_frozen_encoder("resnet18")
features, labels, _ = extract_features(model, weights, frame)
probe.fit(features[train_rows], labels[train_rows])
shifted_probs = probe.predict_proba(shifted_features)
stress = quality_metrics(test_labels, shifted_probs)
BEGINNER · COURSE 02
8–10 HOURS · CPU DEFAULT
OUTCOME
Explain modern residual and efficient ConvNet design, measure representation quality and real execution separately, and choose a backbone against a written deployment contract.
Follow one source-aware inspection benchmark across ResNet-18, ResNet-50, MobileNetV3-Large, EfficientNet-B0, and ConvNeXt-Tiny. Compare frozen probes, resolution, partial fine-tuning, representation drift, robustness, and Pareto efficiency.
PRACTICAL LAB
Benchmark five official encoders, profile batch-1 and batched execution, sweep resolution, test robustness, construct Pareto fronts, and save a deployment decision record.
Run the guided notebook ↗encoder, weights, dim = build_encoder("MobileNetV3-Large")
features, labels = extract_features(encoder, frame, transform)
probe.fit(normalize(train_features), train_labels)
timing = profile_model(encoder, resolution=128, batch_size=1)
efficient = pareto_mask(candidates, "robust_f1", "median_ms_b1")
BEGINNER · COURSE 03
8–10 HOURS · CPU DEFAULT
OUTCOME
Explain how patches, positions, and attention form visual representations; compare flat and hierarchical transformers with CNNs; and measure the quality and systems consequences of tokenization.
Follow one source-aware inspection scenario from patch projection and hand-computed attention through a minimal ViT, four official pretrained backbones, resolution interpolation, attention distance, and a provisional enterprise decision.
PRACTICAL LAB
Verify patch projection and attention, train a tiny ViT, compare ResNet/ConvNeXt/ViT/Swin frozen probes, sweep patch size and resolution, profile tails, and save a transformer decision record.
Run the guided notebook ↗patches = patchify(images, patch_size=16)
manual = softmax(q @ k.T / sqrt(d_k)) @ v
encoder = build_encoder("ViT-B/16")
features = extract_features(encoder, source_held_out_rows)
representation, attention = vit_forward_with_attention(encoder, images)
BEGINNER · COURSE 04
9–12 HOURS · CPU DEFAULT
OUTCOME
Explain how visual representations can be learned without manual pretraining labels, implement the core objectives, diagnose collapse and shortcuts, and evaluate whether reusable features reduce downstream label demand.
Follow one industrial archive from augmentation contracts and manual NT-Xent through a tiny SimCLR encoder, EMA teacher and masked-patch mechanics, random/supervised/SSL feature comparison, probing, retrieval, source separation, and a governed representation decision.
PRACTICAL LAB
Compare three objectives on one tiny encoder, expose collapse and source shortcuts, repeat label budgets across five seeds, test nearest-patch correspondence, and save an enterprise option matrix and decision record.
Run the guided notebook ↗loss, trace = ntxent_loss(z1, z2, temperature=0.1, return_trace=True)
encoder, history, elapsed = train_simclr("domain_valid")
diagnostics = collapse_diagnostics(features, "domain SSL")
probe.fit(features[label_budget], labels[label_budget])
retrieval_p5 = retrieval_precision_at_k(gallery, gallery_y, query, query_y)
BEGINNER · COURSE 05
9–12 HOURS · CPU DEFAULT
OUTCOME
Turn images into localized, confidence-ranked decisions; explain assignment and post-processing; compare dense and set prediction; and choose a detector against source-aware quality, systems, and governance evidence.
Follow one multi-object factory inspection scenario from coordinate contracts, IoU, matching, and AP through anchors, feature pyramids, a trained anchor-free detector, NMS, Hungarian assignment, YOLO/DETR design philosophies, and an open-vocabulary extension.
PRACTICAL LAB
Verify box math and AP, inspect anchor coverage, train a tiny anchor-free detector, tune NMS on development data, evaluate a held-out factory by size, execute Hungarian matching, and save a detector decision record.
Run the guided notebook ↗overlap = box_iou(predicted_boxes, target_boxes)
model = TinyAnchorFreeDetector()
loss = objectness_loss + box_loss + classification_loss
keep = class_aware_nms(boxes, scores, labels, nms_iou)
rows, columns = linear_sum_assignment(hungarian_cost)
BEGINNER · COURSE 06
10–12 HOURS · CPU DEFAULT
OUTCOME
Turn exact pixels into a governed prediction contract; compare semantic, instance, panoptic, and prompted masks; and choose an operating model using source, boundary, prompt, and review evidence.
Move from label-mask integrity, U-Net skips, loss priorities, and boundary metrics through Factory C failure slices, point and box prompts, detector-box perturbation, human correction, and a current but isolated SAM 3.1 adapter.
PRACTICAL LAB
Generate source-aware masks, verify transforms and scratch metrics, train a tiny U-Net under three losses, diagnose boundary/source slices, evaluate interactive prompts, and save a separated evidence bundle.
Run the guided notebook ↗assert set(torch.unique(nearest).tolist()) <= {0.0, 4.0}
model = TinyUNet(classes=len(CLASS_NAMES), base=8)
miou = mean_iou(prediction, target, CLASS_NAMES)
edge_score = boundary_f1(prediction > 0, target > 0, tolerance=1)
mask = box_prompt_proxy(image, perturbed_detector_box)
BEGINNER · COURSE 07
10–12 HOURS · CPU DEFAULT
OUTCOME
Define what similarity means for a product decision, learn and evaluate a normalized embedding space, and operate exact or approximate retrieval without confusing speed, scale, and semantic quality.
Follow one multi-factory archive through frozen ResNet baselines, triplet learning, P×K batches, online mining, simulated oracle adjudication, group-isolated duplicate evaluation, exact-search parity, HNSW tuning, metadata filters, drift, and blue/green embedding migration.
PRACTICAL LAB
Compare frozen and learned features, quantify sampler signal, review hard negatives, verify NumPy/scikit-learn/FAISS parity, tune HNSW recall, expose filter misses, and save a versioned evidence bundle.
Run the guided notebook ↗embeddings = F.normalize(encoder(images), dim=1)
anchors, positives, negatives = mine_online_triplets(embeddings, labels, "semi-hard", rng, margin)
exact = faiss.IndexFlatIP(dimension)
hnsw = faiss.IndexHNSWFlat(dimension, 16)
ann_recall = ann_recall_at_k(exact_ids, approximate_ids, k=10)
BEGINNER · COURSE 08
10–12 HOURS · CPU DEFAULT
OUTCOME
Maintain measurable identity through time, attach landmarks and geometry to each track, and diagnose whether a temporal-state failure began in detection, association, pose, or smoothing.
Follow one procedural workcell from timestamped video and detector observations through IoU/Hungarian matching, lifecycle, motion, appearance, Byte-style recovery, identity metrics, heatmaps, PCK, pose geometry, Camera C shift, and versioned evidence.
PRACTICAL LAB
Build a transparent tracker, compare geometry/motion/appearance association, stress occlusion, recover weak detections, decode keypoint heatmaps, measure pose and temporal quality, and save separated evidence.
Run the guided notebook ↗cost = geometry_weight * (1 - iou) + appearance_weight * cosine_cost
rows, columns = linear_sum_assignment(cost)
tracks = tracker.update(detections, timestamp_s, frame)
pck_score = pck(predicted, target, visibility, object_scale)
velocity = np.diff(keypoints, axis=0) / np.diff(timestamps)[:, None]
BEGINNER · COURSE 09
10–12 HOURS · CPU DEFAULT
OUTCOME
Reuse visual representations and promptable interfaces across tasks while preserving capability-specific evaluation, provenance, and bounded operating contracts.
Synthesize the Beginner track through normalized image–text alignment, prompt and vocabulary sensitivity, global versus patch features, open-vocabulary grounding, detector→segmenter error propagation, the adaptation ladder, and current foundation-model governance.
PRACTICAL LAB
Exercise alignment, prompt ensembles, vocabulary shifts, retrieval, patch correspondence, phrase grounding, composed segmentation, adaptation, failure attribution, and separated evidence without hidden local modules.
Run the guided notebook ↗similarity = normalize(image_features) @ normalize(text_features).T
prompt_results = evaluate_prompt_suite(images, approved_templates)
grounded_boxes = local_grounding_proxy(scene, phrase)
masks = box_prompt_segmenter_proxy(scene, grounded_boxes[0]["box"])
evidence = separate(local_measurements, optional_models, assumptions)
INTERMEDIATE · COURSE 01
10–12 HOURS · CPU DEFAULT
OUTCOME
Trace visual features into a language generator and evaluate whether its answers remain tied to the supplied evidence.
Move from CLIP-style alignment through visual tokens, projection, resampling, cross-attention, autoregressive generation, instruction tuning, resolution budgets, grounding, hallucination diagnostics, capability-specific evaluation, and enterprise inference contracts.
PRACTICAL LAB
Build a tiny causal VLM, compare connector interfaces, run four-capability evidence ablations, evaluate capability-specific grounding and abstention, validate structured outputs, and preserve an enterprise decision record.
Run the guided notebook ↗visual_tokens = projector(patch_features)
answer, eos, evidence, probabilities = model.generate(visual_tokens, question, separator)
ablation = compare(correct_image, blank_image, wrong_image, counterfactual_image)
contract = validate_contract(payload, trusted_record)
INTERMEDIATE · COURSE 02
10–12 HOURS · CPU DEFAULT
OUTCOME
Turn a bounded visual question into a conclusion whose required facts, evidence, tool calls, checks, and uncertainty can be independently reviewed.
Move from recognition to task DAGs, observed and derived facts, capability-specific evidence, exact tools, four-valued states, contradictions, relevant and irrelevant counterfactuals, multi-image attribution, and governed decisions—without treating hidden reasoning traces as an audit artifact.
PRACTICAL LAB
Build a transparent reasoning DAG, version deterministic geometry/count/arithmetic tools, score claim evidence, inject and attribute failures, test counterfactuals and image binding, propagate uncertainty, and export a governed evidence record.
Run the guided notebook ↗plan = topological_order(nodes, observed_facts)
claims, tool_events = execute_reasoning_graph(observations)
checks = evidence_checks(run)
decision = "review_required" if required_fact_is_uncertain else apply_rule(claims)
INTERMEDIATE · COURSE 03
12–14 HOURS · CPU DEFAULT
OUTCOME
Convert mixed, multi-page documents into structured fields whose page, region, span or cell, and transformation provenance can be independently replayed.
Route digital and scanned inputs; preserve coordinate frames; separate OCR, layout, reading order, tables, forms, and normalization; then evaluate source shift, perturbations, unsupported values, and human-review policy.
PRACTICAL LAB
Generate three source-isolated document templates, inspect page and OCR contracts, compare reading-order and field-binding baselines, preserve merged-table and cross-page structure, inject provenance failures, and export a governed evidence record.
Run the guided notebook ↗ocr_rows = local_ocr_proxy(document)
bindings = semantic_geometry_bind(ocr_rows)
structured = build_structured_document(document)
checks = verify_field(document, "invoice_total", structured["fields"]["invoice_total"])
INTERMEDIATE · COURSE 04
12–14 HOURS · CPU DEFAULT
OUTCOME
Retrieve the minimum sufficient authorized multimodal evidence and produce claims whose granular citations can be independently checked.
Preserve document, page, cell, figure, image, region, canonical, version, and access lineage; compare lexical, semantic, visual, structured, and multi-vector retrieval; then separate retrieval, assembly, generation, citation, and freshness failures.
PRACTICAL LAB
Build authorized lexical, semantic, visual, structured, and multi-vector indexes; fuse and rerank candidates; assemble bounded evidence; verify citations; inject access, distractor, generation, and staleness failures; and export a governed record.
Run the guided notebook ↗eligible, access_log = authorized_units(principal, corpus, filters)
rankings = generate_candidates(query, eligible)
fused = reciprocal_rank_fusion(rankings)
bundle = assemble_evidence(query, reranked)
checks = verify_claim_citations(query, bundle, output)
INTERMEDIATE · COURSE 05
12–14 HOURS · CPU DEFAULT
OUTCOME
Turn timestamped streams into event intervals and multi-event answers whose temporal evidence, identities, permissions, and citations can be independently checked.
Preserve presentation time through sampling and representation; separate candidate retrieval from boundary grounding; use deterministic interval tools; then test complete evidence, counterfactuals, long-video hierarchy, streaming delay, frame drops, and audio–visual conflict.
PRACTICAL LAB
Generate three source-isolated workcell streams, compare temporal sampling and segmentation, retrieve and localize events, verify multi-event citations, perturb timing and order, simulate backpressure, and export governed evidence.
Run the guided notebook ↗sampled = event_aware_sample(frames, base_fps=1.0)
hits = retrieve_clips(public_request(query), authorized_clips, top_k=8)
interval = localize_from_observations(event_type, frames, candidate_clips)
relation = interval_relation(first_interval, second_interval)
checks = verify_temporal_claim(claim, evidence_bundle, principal, required_events)
INTERMEDIATE · COURSE 06
12–14 HOURS · CPU DEFAULT
OUTCOME
Turn verified image, document, and video evidence into an observable, permissioned, bounded tool loop that stops or escalates safely.
Define typed state and tool contracts; separate planning from execution; enforce capability and resource policy before invocation; validate inputs and outputs; promote only source-bound evidence; and evaluate selection, authorization, recovery, and termination independently.
PRACTICAL LAB
Build a deterministic visual inspection agent over Site A/B/C image, manual, and video evidence; then inject selection, argument, runtime, output, freshness, permission, loop, budget, and tool-removal failures.
Run the guided notebook ↗action = local_planner_proxy(state)
allowed, reason = authorize(principal, contract, action.arguments)
result, evidence, facts, trace = execute_action(state, action)
promote(state, action, evidence, facts)
assert unauthorized_executions == 0
ADVANCED · COURSE 01
14–18 HOURS · CPU DEFAULT
OUTCOME
Recover frame-aware 3D structure from calibrated observations, quantify geometric uncertainty, and turn reconstruction into auditable metric spatial evidence.
Move from coordinate frames, pinhole projection, back-projection, distortion, and calibration through robust epipolar matching, stereo depth, triangulation, pose, structure from motion, point clouds, representation choice, occlusion, and source-held-out spatial decisions.
PRACTICAL LAB
Build a synthetic calibrated rig; implement projection, DLT, RANSAC, stereo uncertainty, triangulation, pose and point refinement; measure a floor clearance; then freeze Site B policy and report Site C.
Run the guided notebook ↗pixels, z = project_points(points_world, camera)
F, inliers, residual = ransac_fundamental(uv_a, uv_b)
points_3d = triangulate_dlt(uv_a[inliers], uv_b[inliers], cam_a, cam_b)
sigma_z = stereo_sigma_z(disparity, focal_px, baseline_m, sigma_d)
assert site_c_report["policy_hash"] == frozen_policy_hash
ADVANCED · COURSE 02
14–18 HOURS · CPU DEFAULT
OUTCOME
Build and evaluate view-synthesis systems without confusing a convincing image with correct geometry or deployable scene evidence.
Move from calibrated rays, bounds, positional encoding, transmittance, and hierarchical sampling through camera-held-out NeRF evaluation, appearance–geometry disagreement, explicit Gaussian projection and splatting, density-control lineage, compression, editability, dynamics, and semantic fields.
PRACTICAL LAB
Generate calibrated rays; verify volume rendering and gradients; expose sampling, pose, exposure, and floater failures; project and rasterize 3D Gaussians; then freeze a Site B policy and report Site C.
Run the guided notebook ↗rays = camera.generate_rays()
rgb, opacity, depth = volume_render(sigma, colours, deltas, t_samples)
screen_mean, screen_cov = project_gaussian(primitive, camera)
image = splat_render(primitives, camera)
assert site_c_report["policy_hash"] == frozen_policy_hash
ADVANCED · COURSE 03
14–18 HOURS · CPU DEFAULT
OUTCOME
Represent persistent world state, predict action-conditioned futures, and evaluate whether model-based plans remain supported and physically consistent.
Move from observations, memory, structured actions, and explicit transitions through 4D representations, recursive and stochastic futures, object permanence, counterfactual tests, planning exploitation, source shift, and governed evidence.
PRACTICAL LAB
Build typed state/action contracts and a true simulator; fit action-aware and passive proxies; test rollout, counterfactuals, permanence, and physics; then expose and mitigate a planning exploit before reporting Site C.
Run the guided notebook ↗prediction = local_world_model_proxy.predict(state, action)
rollout_metrics = evaluate_rollout(model, hidden_dynamics)
violations = validate_rollout(predicted_states)
choice = support_aware_plan(candidates, frozen_policy)
assert evidence["authorization"] == "none"
ADVANCED · COURSE 04
14–18 HOURS · CPU DEFAULT
OUTCOME
Convert grounded multimodal observations and goals into embodiment-compatible action proposals, then validate, execute in bounded simulation, verify, and recover without granting a model physical authority.
Move from proprioception, frames, referent ambiguity, affordances, and action spaces through behavioral cloning, tokenized/continuous/diffusion VLA families, action chunks, independent feasibility checks, freshness, postconditions, and held-out embodiment evidence.
PRACTICAL LAB
Build typed embodiment, observation, goal, affordance, action, and permit contracts; compare visual-only and proprioceptive policies; inject ambiguity, disturbance, latency, collision, replay, and failed-grasp cases; then freeze policy before Site C.
Run the guided notebook ↗proposal = local_vla_policy_proxy.propose(observation, grounded_goal)
decision = validate_action(proposal, embodiment, constraints)
permit = issue_simulation_permit(proposal, decision)
outcome = simulation_executor.execute(proposal, permit)
assert evidence["physical_authorization"] == "none"
ADVANCED · COURSE 05
14–18 HOURS · CPU DEFAULT
OUTCOME
Turn partial, timestamped observations into persistent and queryable world knowledge without confusing memory with current truth.
Move from pose, drift, occupancy evidence, unknown space, object association, permanence, and moved-object history through relation provenance, typed queries, semantic candidate verification, hierarchical navigation, source-held-out evaluation, and dependency-selective plan invalidation.
PRACTICAL LAB
Build an industrial inspection memory from noisy odometry and limited views; compare stale-memory policies; prove rejected loop closures cannot mutate trusted state; selectively invalidate plans; then freeze Site B policy before shifted Site C.
Run the guided notebook ↗candidate = descriptions[int(np.argmax(scores))]
verified = query_engine.locate_object("toolbox_7")
plan = astar(known, (0, 0), (4, 2), unknown_policy="block")
assert evidence["physical_authorization"] == "none"
ADVANCED · COURSE 06
14–18 HOURS · CPU DEFAULT
OUTCOME
Acquire useful capability on a new domain while making legacy interference, alignment drift, forgetting, lineage, and rollback evidence explicit.
Diagnose shift before training; compare frozen reuse, projectors, adapters, prompts, LoRA, partial, and full fine-tuning; then move through replay, regularization, distillation, parameter isolation, capability regression, and trusted release control.
PRACTICAL LAB
Adapt a tiny image–text encoder to Site B, measure representation and alignment drift, run a separate continual stream with replay/EWC/distillation/routing, freeze policy before Site C, and emit a digest-bound shadow/reject/rollback decision.
Run the guided notebook ↗candidate = AdaptedDualEncoder(base_model, "lora", rank=2)
target_gain = adapted_B["macro_f1"] - base_B["macro_f1"]
legacy_regression = adapted_A["macro_f1"] - base_A["macro_f1"]
validate_candidate_contract(CANDIDATE, BASE_CONTRACT)
assert promotion_decision.authorization == "none"
ADVANCED · COURSE 07
14–18 HOURS · CPU DEFAULT
OUTCOME
Design a vision system that measures degradation, recognizes incomplete evidence, abstains under a frozen risk policy, and verifies every attempted recovery.
Keep robustness, softmax confidence, calibration, uncertainty, OOD evidence, error detection, and conformal coverage distinct; then connect them through fail-closed policy and bounded recovery.
PRACTICAL LAB
Stress a tiny inspection ensemble, expose high-confidence error, calibrate on Site B, compare OOD and error evidence, construct conformal sets and risk–coverage policy, then test verified and failed recovery paths before reporting on Site C.
Run the guided notebook ↗proposal = bounded_recovery_policy(case, now_s=100.0)
decision = finalize_with_independent_verification(
proposal, synthetic_evaluation_oracle
)
assert decision.authorization == "none"
assert decision.terminal_state != "verified_recovery" or decision.verified_success
ADVANCED · COURSE 08
14–18 HOURS · CPU DEFAULT
OUTCOME
Optimize a spatial or multimodal system without silently deleting evidence, reliability, isolation, or rollback capability.
Profile the complete path; compare input, token, precision, structure, distillation, export, batching, caching, and temporal-reuse choices; then freeze a capability-aware gate before shifted evaluation.
PRACTICAL LAB
Profile a tiny dual encoder, expose unsafe local optimizations, test export parity and load behavior, defend cache scope, gate feasibility before Pareto selection, compare against keeping the reference, freeze Site B policy, and reject shifted Site C evidence when required checks fail.
Run the guided notebook ↗assert not candidate_matrix.query("not eligible")[
"feasible_pareto_efficient"
].any()
site_b_selection = select_optimized_or_reference(candidate_matrix)
assert decision.authorization == "none"
ADVANCED · COURSE 09
14–18 HOURS · CPU DEFAULT
OUTCOME
Operate a complete spatial or multimodal AI configuration while preserving calibration, coordinate consistency, lineage, capability evidence, rollback, and safe recovery.
Move from immutable manifests and typed registries through structural, temporal, and operational readiness; time-valid frames; persisted calibration state; capability dependencies; drift and delayed outcomes; progressive delivery; fleet convergence; stateful rollback; incident recovery; and audit.
PRACTICAL LAB
Operate a synthetic inspection service across camera movement, calibration expiry, split-brain rollout, stale index, and runtime regression; selectively disable affected capabilities; reject an incomplete rollback; verify recalibration; and export a non-authorizing incident evidence pack.
Run the guided notebook ↗impact = capability_impact(component_states)
kill_switch = apply_selective_kill_switch(impact, policy_hash)
assert "classification" in kill_switch["remaining_capabilities"]
assert deployment_convergence["status"] == "FAIL"
assert recovery_decision.authorization == "none"