Port guarded Qwen3.5 QSystem adapter and field runtime

Adapter-only experimental port. Excludes base weights, training data, credentials, and private memories. Includes explicit unreviewed-data and non-physical-quantum disclosures.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

PORT_MANIFEST.json

@@ -0,0 +1,77 @@
+{
+  "adapter_only": true,
+  "base_weights_included": false,
+  "files": {
+    "README.md": {
+      "bytes": 3152,
+      "sha256": "c90ca45194226006a6dba005708a162400e0b009f502af773ea64a65985de8e3"
+    },
+    "adapter_config.json": {
+      "bytes": 1528,
+      "sha256": "ba4c65b8bf0a6ae3047e62ded3e191120c7ac1577f267cc0bf07ee4bf25e85df"
+    },
+    "adapter_model.safetensors": {
+      "bytes": 42505112,
+      "sha256": "c317c8cf66815b64af8f440a0c5e99da8c6bcd416fd297a0c57419a1eff96e47"
+    },
+    "artifacts/field.deployment.json": {
+      "bytes": 952,
+      "sha256": "e405b118ec18fcdd7c191100157da15f353e0c03633add9f5863f91ad8b27968"
+    },
+    "artifacts/field.json": {
+      "bytes": 1417,
+      "sha256": "58cad94a6487316da55248ff826930827d566c90f3aa78bf9a0dff2fe8fad317"
+    },
+    "artifacts/wave.deployment.json": {
+      "bytes": 1629,
+      "sha256": "68e16241e9012e54c7458bab16ea43ef6c6adc523c9d2ecb93c53e7be5e1dfc4"
+    },
+    "artifacts/wave.json": {
+      "bytes": 1257,
+      "sha256": "e0c68eeb94bbf2e0463d4d03555e6f8545827c3cd68f37ecd34d469fc1f2d7e4"
+    },
+    "chat_template.jinja": {
+      "bytes": 7756,
+      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
+    },
+    "portable_qsystem.py": {
+      "bytes": 4961,
+      "sha256": "f618ffabf98b33ea825902788c78d0e343dd6cc5cc404d8e63a37c61f5273feb"
+    },
+    "requirements.txt": {
+      "bytes": 73,
+      "sha256": "023dac9615c0477f9b4ee4ce982bdfe7d4418abab7da2c82a61b70bd6c191277"
+    },
+    "runtime/field_reranker.py": {
+      "bytes": 10337,
+      "sha256": "9448cfc7c4fe49e9e7a0a2c4e6a502991e90f9b061f7c1face9146e10520662b"
+    },
+    "runtime/wave_reranker.py": {
+      "bytes": 13599,
+      "sha256": "802e0bc6490bcdcd0ddb4dbd52810abe7b6792160d202b475c3064220f0c5513"
+    },
+    "tokenizer.json": {
+      "bytes": 19989343,
+      "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+    },
+    "tokenizer_config.json": {
+      "bytes": 1102,
+      "sha256": "930c80792230ce9a8d3330eccc0aebd727f0d0de2723d0baf3a72973d4ad3b49"
+    },
+    "training_summary.json": {
+      "bytes": 801,
+      "sha256": "cb45664d68e3976b7dbe1a1da38c0b21b756a00ccd90c52f15e24b4ff08877e1"
+    },
+    "validation_summary.json": {
+      "bytes": 777,
+      "sha256": "528f9321d0ec723e49f40cefb00e0810d4210bd4b291d92da76e2d457c3b14f3"
+    }
+  },
+  "guarded_system_passed": true,
+  "physical_quantum_state": false,
+  "raw_adapter_passed": false,
+  "repo_id": "o0Hailey-DSynth0o/Experimental_QSystem",
+  "schema_version": 1,
+  "source_human_approved": false,
+  "training_data_included": false
+}

README.md

@@ -1,3 +1,87 @@
----
-license: cc-by-nc-4.0
----
+---
+license: cc-by-nc-4.0
+base_model:
+- Qwen/Qwen3.5-4B-Base
+- unsloth/Qwen3.5-4B-Base
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- lora
+- sft
+- hscm
+- quantum-inspired
+- guarded-generation
+---
+
+# Experimental QSystem
+
+An **experimental adapter/system bundle** for Qwen3.5-4B-Base. It combines a
+language-layer LoRA verbalizer with portable NumPy field and complex-wave
+rerankers. The full persistent HSCM memory engine is external to these weights.
+
+## Accuracy boundary
+
+- This is not a physically quantum LLM. The transformer, neural weights, and KV
+  cache are classical.
+- Complex amplitudes, phase, interference, attractive/repellent signals, and the
+  two-qubit field are routing analogues over HSCM candidates.
+- The earlier IBM QPU candidate was rejected by held-out gates and is not the
+  active artifact included here.
+- The raw adapter failed one missing-evidence generation probe by inventing a
+  number. It must be used with the supplied evidence-boundary prompt and
+  fail-closed output guard.
+
+## Data status
+
+Training used 182 examples: 150 Hope bridge candidates and 32 grounding-repair
+examples. **None were human-approved.** The source package explicitly labelled
+them `HUMAN_REVIEW_REQUIRED`; this bounded user-requested experiment does not
+promote them to authentic or production-reviewed persona data. No training rows,
+private memories, credentials, or source text are included in this repository.
+
+## Training and evaluation
+
+- BF16, rank-16 LoRA, language attention/MLP projections only
+- 21,233,664 trainable parameters (0.4656% of the loaded model)
+- validation loss: 3.4935 -> 2.7221
+- test loss: 3.5912 -> 2.7644
+- guarded Windows end-to-end gate: 11/11 checks
+- local project regression at export: 760 passed, 1 optional skip
+
+The raw adapter remains quarantined; only the guarded composition passed.
+
+## Portable use
+
+```python
+from portable_qsystem import PortableQSystem
+
+system = PortableQSystem("o0Hailey-DSynth0o/Experimental_QSystem")
+result = system.generate(
+    "What exact number was in the sealed result?",
+    ["The notes mention a sealed result but do not give its value."],
+    unmet_need=True,
+)
+print(result["text"])
+```
+
+`unmet_need` must come from a trusted retrieval/controller layer. If you do not
+have that layer, treat this as an experimental LoRA—not a grounded system.
+
+The default 8 GiB GPU / 96 GiB CPU memory limits allow Accelerate to offload
+overflow to RAM. Override them with `QSYSTEM_GPU_MEMORY` and
+`QSYSTEM_CPU_MEMORY`.
+
+## Included artifacts
+
+- PEFT adapter and authoritative Qwen tokenizer/template
+- `portable_qsystem.py`: official-template inference plus fail-closed guard
+- `runtime/field_reranker.py`: NumPy two-qubit field evaluator
+- `runtime/wave_reranker.py`: NumPy complex-wave controller
+- `artifacts/`: hash-gated active scalar/wave parameters
+- sanitized training and validation summaries
+
+## License
+
+This repository is shared under CC BY-NC 4.0. The referenced base models retain
+their own licenses. Users are responsible for checking compatibility for their
+use case.

adapter_config.json

@@ -0,0 +1,46 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen3_5ForConditionalGeneration",
+    "parent_library": "transformers.models.qwen3_5.modeling_qwen3_5",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/Qwen3.5-4B-Base",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": "(?:.*?(?:language|text).*?(?:self_attn|attention|attn|mixer|mlp|feed_forward|ffn|dense|mixer).*?(?:q_proj|k_proj|v_proj|o_proj|gate_proj|up_proj|down_proj))|(?:\\bmodel\\.layers\\.[\\d]{1,}\\.(?:self_attn|attention|attn|mixer|mlp|feed_forward|ffn|dense|mixer)\\.(?:(?:q_proj|k_proj|v_proj|o_proj|gate_proj|up_proj|down_proj)))",
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c317c8cf66815b64af8f440a0c5e99da8c6bcd416fd297a0c57419a1eff96e47
+size 42505112

artifacts/field.deployment.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "active",
+  "rollback_mode": "shadow",
+  "artifact_sha256": "58cad94a6487316da55248ff826930827d566c90f3aa78bf9a0dff2fe8fad317",
+  "artifact_id": "astra-field-completion-v1",
+  "feature_sha256": "328aa5414e4c005bb438b17bbe4d79e82212f209322b17319eff4d4e8b7207ca",
+  "final_feature_sha256": "38f9af692ed8ca2256164d4b81ca008c4a3af0eb1d34c03a5452d48db7bfe0d1",
+  "activation_gates": {
+    "final_pool_coverage_at_least_0_95": true,
+    "final_shortlist_coverage_64_at_least_0_95": true,
+    "final_mrr_not_below_hscm": true,
+    "final_hit1_not_below_hscm": true,
+    "final_quality_noninferior_ci_margin_0_02": true,
+    "scalar_batch_p95_128_under_50ms": true,
+    "artifact_was_not_fit_on_final_features": true
+  },
+  "canary_eligible": true,
+  "promotion_requires_manual_status_change": false,
+  "promoted_at": "2026-08-22",
+  "promotion_authority": "explicit_user_operator_instruction",
+  "qpu_authorized": false
+}

artifacts/field.json

@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "artifact_id": "astra-field-completion-v1",
+  "feature_order": [
+    "semantic_support",
+    "lexical_support",
+    "coherence",
+    "path_quality"
+  ],
+  "feature_scaler": {
+    "min": [0.0, 0.0, 0.0, 0.0],
+    "max": [1.0, 1.0, 1.0, 1.0]
+  },
+  "circuit": {
+    "ansatz": "astra-field-v1",
+    "qubits": 2,
+    "trainable_weights": 8,
+    "output": "even-parity-probability"
+  },
+  "weights": [
+    0.6887883660412828,
+    0.21568877725908164,
+    0.2919163878217943,
+    -0.12790156455312518,
+    -0.6341863258168909,
+    -0.030390240841024596,
+    0.1441088749758026,
+    -0.283611054562376
+  ],
+  "fusion_weight": 0.18,
+  "score_calibration": "batch_max",
+  "training_stage": "operational-hybrid-v1-transfer-validated",
+  "metadata": {
+    "feature_sha256": "328aa5414e4c005bb438b17bbe4d79e82212f209322b17319eff4d4e8b7207ca",
+    "source_artifact_sha256": "f8497cd851abb7775c130a8faa1e5ff7d75ec29a01dd1f5a7af46d172e179cac",
+    "final_feature_sha256": "38f9af692ed8ca2256164d4b81ca008c4a3af0eb1d34c03a5452d48db7bfe0d1",
+    "final_report_sha256": "64b0d5e50998c6b1b7266a708bb438786ffb30f5e9989249a62bf2b483d7ac75",
+    "final_metrics": {
+      "coverage_at_64": 0.97,
+      "mrr": 0.39563449019071006,
+      "hit_at_1": 0.295,
+      "p95_batch_ms": 34.542304996284656
+    },
+    "classical_shadow_accepted": true,
+    "qpu_authorized": false,
+    "physical_quantum_state": false
+  }
+}

artifacts/wave.deployment.json

@@ -0,0 +1,46 @@
+{
+  "schema_version": 1,
+  "status": "active-protected",
+  "rollback_mode": "shadow-observer",
+  "applied_to_ranking": true,
+  "artifact_sha256": "e0c68eeb94bbf2e0463d4d03555e6f8545827c3cd68f37ecd34d469fc1f2d7e4",
+  "artifact_id": "astra-wave-completion-v1",
+  "physical_quantum_state": false,
+  "behaviours": [
+    "normalized_complex_path_amplitudes",
+    "phase_sensitive_interference",
+    "decoherence",
+    "measurement_entropy",
+    "effective_path_count",
+    "scalar_protected_nested_counterfactual"
+  ],
+  "nested_wave_alpha": 0.7,
+  "nested_shortlist": 64,
+  "activation_gates": {
+    "exact_artifact_hash": true,
+    "scalar_protected_shortlist": true,
+    "evidence_admission_unchanged": true,
+    "paired_e2e_combined_wins_at_least_losses": true,
+    "automatic_shadow_fallback": true,
+    "operator_override_authorized": true
+  },
+  "operator_override": {
+    "authorized": true,
+    "authorized_at": "2026-08-22",
+    "authority": "explicit_user_operator_instruction",
+    "decision": "activate protected phase combination despite statistically inconclusive e2e interval",
+    "statistically_conclusive": false,
+    "paired_exact_mcnemar_p": 0.375,
+    "top1_delta_ci95": [-0.009615, 0.076923]
+  },
+  "safety_invariants": {
+    "can_rank": true,
+    "protected_scalar_shortlist": true,
+    "unrestricted_wave_ranker": false,
+    "can_admit_evidence": false,
+    "can_change_answers": true,
+    "telemetry_contains_text": false
+  },
+  "physical_qpu_used_for_activation": false,
+  "reason": "operator-authorized protected activation after favorable but statistically inconclusive classical end-to-end comparison"
+}

artifacts/wave.json

@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "artifact_id": "astra-wave-completion-v1",
+  "mode": "wave",
+  "feature_order": [
+    "semantic_support",
+    "lexical_support",
+    "coherence",
+    "path_quality"
+  ],
+  "aux_order": [
+    "phase_residual",
+    "holonomy",
+    "relative_weight",
+    "state_amplitude"
+  ],
+  "input_weights": [
+    2.2449848651885986,
+    0.9888409972190857,
+    0.42518511414527893,
+    0.19510437548160553,
+    0.20227433741092682,
+    -0.12414798885583878
+  ],
+  "logit_scale": 8.435023307800293,
+  "kernel_log_weights": [
+    -0.9233665466308594,
+    1.7070022821426392,
+    -1.7411715984344482,
+    -1.1259512901306152
+  ],
+  "phase_gains": {
+    "residual": 0.9412479400634766,
+    "holonomy": 0.0009446322219446301
+  },
+  "mixing": 0.07407242059707642,
+  "decoherence": 0.1738409698009491,
+  "fusion_weight": 0.25,
+  "training_stage": "operational-wave-classical",
+  "metadata": {
+    "feature_sha256": "c7e6ef608f804579229e124ef42769e46115886a6d9c88792a84dd88ee7f76a6",
+    "seed": 0,
+    "physical_quantum_state": false,
+    "nested_wave_alpha": 0.7,
+    "nested_shortlist": 64,
+    "nested_selection": "selected on the 90-query development validation split; final result is exploratory"
+  }
+}

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

portable_qsystem.py

@@ -0,0 +1,116 @@
+"""Portable guarded inference boundary for the Experimental QSystem adapter.
+
+This module does not implement Astra's persistent HSCM memory engine. Callers
+must provide admitted semantic evidence and the controller's ``unmet_need``
+decision. The deterministic guard prevents a known missing answer slot from
+being replaced by a fluent model guess.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Sequence
+
+
+UNCERTAINTY = re.compile(
+    r"\b(?:don't know|do not know|don't have|do not have|not enough|no record|"
+    r"no evidence|not given|not provided|not supplied|not mentioned|not specified|"
+    r"can't tell|cannot tell|can't determine|cannot determine|uncertain|unknown)\b",
+    re.I,
+)
+
+
+def grounded_messages(query: str, evidence: Sequence[str], *,
+                      unmet_need: bool = False) -> list[dict[str, str]]:
+    facts = [str(item).strip() for item in evidence if str(item).strip()][:9]
+    context = "\n".join(f"- {item}" for item in facts) or "(no grounded evidence)"
+    boundary = (
+        "\nEvidence boundary: the requested specific is not supplied. State that "
+        "you do not know it; do not estimate or invent it."
+        if unmet_need else ""
+    )
+    system = (
+        "You are Astra's local verbalizer. Be concise and direct. Treat only the "
+        "grounded evidence supplied by the controller as factual. A listed question "
+        "does not supply its answer. Separate inference from fact, and plainly state "
+        "when requested evidence is missing. Complex phase and field values are "
+        "classical routing signals, not physical quantum states."
+    )
+    user = f"Context:\n{context}{boundary}\n\nQuestion:\n{str(query)[:500]}"
+    return [{"role": "system", "content": system},
+            {"role": "user", "content": user}]
+
+
+def guard_output(text: str, *, unmet_need: bool = False) -> tuple[str, bool]:
+    body = str(text or "").strip()
+    if unmet_need and body and not UNCERTAINTY.search(body):
+        return "I don't know the requested specific from the evidence I have.", True
+    return body, False
+
+
+class PortableQSystem:
+    """Qwen3.5 BF16 LoRA mouth with optional GPU-to-RAM placement."""
+
+    def __init__(
+        self,
+        adapter: str | Path = ".",
+        base_model: str = "unsloth/Qwen3.5-4B-Base",
+        *,
+        max_new_tokens: int = 128,
+        gpu_memory: str | None = None,
+        cpu_memory: str | None = None,
+    ):
+        self.adapter = str(adapter)
+        self.base_model = str(base_model)
+        self.max_new_tokens = int(max_new_tokens)
+        self.gpu_memory = gpu_memory or os.getenv("QSYSTEM_GPU_MEMORY", "8GiB")
+        self.cpu_memory = cpu_memory or os.getenv("QSYSTEM_CPU_MEMORY", "96GiB")
+        self.model = None
+        self.tokenizer = None
+
+    def load(self) -> None:
+        if self.model is not None:
+            return
+        import torch
+        from peft import PeftModel
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        self.tokenizer = AutoTokenizer.from_pretrained(self.adapter, use_fast=True)
+        options = {"dtype": torch.bfloat16, "low_cpu_mem_usage": True}
+        if torch.cuda.is_available():
+            options.update({
+                "device_map": "auto",
+                "max_memory": {0: self.gpu_memory, "cpu": self.cpu_memory},
+            })
+        base = AutoModelForCausalLM.from_pretrained(self.base_model, **options)
+        self.model = PeftModel.from_pretrained(
+            base, self.adapter, is_trainable=False)
+        self.model.eval()
+
+    def generate(self, query: str, evidence: Sequence[str], *,
+                 unmet_need: bool = False) -> dict[str, object]:
+        import torch
+
+        self.load()
+        rendered = self.tokenizer.apply_chat_template(
+            grounded_messages(query, evidence, unmet_need=unmet_need),
+            tokenize=False, add_generation_prompt=True, enable_thinking=False)
+        encoded = self.tokenizer(rendered, return_tensors="pt")
+        input_device = self.model.get_input_embeddings().weight.device
+        encoded = {key: value.to(input_device) for key, value in encoded.items()}
+        input_length = int(encoded["input_ids"].shape[1])
+        with torch.inference_mode():
+            generated = self.model.generate(
+                **encoded, max_new_tokens=self.max_new_tokens,
+                do_sample=False, use_cache=True,
+                pad_token_id=self.tokenizer.pad_token_id,
+                eos_token_id=self.tokenizer.eos_token_id)
+        raw = self.tokenizer.decode(
+            generated[0][input_length:], skip_special_tokens=False)
+        raw = raw.split("<|im_end|>", 1)[0]
+        raw = re.sub(r"\A\s*<think>[\s\S]*?</think>\s*", "", raw, count=1)
+        raw = re.sub(r"</?think>", "", raw).strip()
+        delivered, guarded = guard_output(raw, unmet_need=unmet_need)
+        return {"text": delivered, "guarded": guarded, "raw": raw}
+

requirements.txt

@@ -0,0 +1,5 @@
+accelerate>=1.12
+numpy>=2.0
+peft>=0.20
+torch>=2.6
+transformers>=5.5

runtime/field_reranker.py

@@ -0,0 +1,234 @@
+"""Small, optional learned reranker for the Astra/HSCM memory field.
+
+The runtime implementation is deliberately NumPy-only.  Qiskit is used by the
+experiment harness to train and validate the same two-qubit circuit, but normal
+Astra recall only evaluates the eight learned angles stored in a JSON artifact.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping, Sequence
+
+import numpy as np
+
+
+FIELD_ARTIFACT_SCHEMA_VERSION = 1
+FIELD_DEPLOYMENT_SCHEMA_VERSION = 1
+FIELD_FEATURE_ORDER = (
+    "semantic_support",
+    "lexical_support",
+    "coherence",
+    "path_quality",
+)
+
+
+def _finite_vector(values: Sequence[float], size: int, label: str) -> np.ndarray:
+    result = np.asarray(values, dtype=np.float64)
+    if result.shape != (size,) or not np.all(np.isfinite(result)):
+        raise ValueError(f"{label} must contain {size} finite values")
+    return result
+
+
+@dataclass(frozen=True)
+class FieldRerankerArtifact:
+    """Validated, secret-free representation of one learned field circuit."""
+
+    artifact_id: str
+    weights: tuple[float, ...]
+    fusion_weight: float = 0.10
+    score_calibration: str = "none"
+    feature_min: tuple[float, ...] = (0.0, 0.0, 0.0, 0.0)
+    feature_max: tuple[float, ...] = (1.0, 1.0, 1.0, 1.0)
+    training_stage: str = "experimental"
+    metadata: Mapping | None = None
+
+    def __post_init__(self) -> None:
+        if not str(self.artifact_id).strip():
+            raise ValueError("field artifact_id must not be empty")
+        _finite_vector(self.weights, 8, "field weights")
+        lo = _finite_vector(self.feature_min, 4, "feature_min")
+        hi = _finite_vector(self.feature_max, 4, "feature_max")
+        if np.any(hi <= lo):
+            raise ValueError("every feature_max must exceed feature_min")
+        if not math.isfinite(float(self.fusion_weight)) or not 0.0 <= float(self.fusion_weight) <= 0.25:
+            raise ValueError("fusion_weight must be finite and within [0, 0.25]")
+        if self.score_calibration not in {"none", "batch_max"}:
+            raise ValueError("unsupported field score calibration")
+        try:
+            json.dumps(dict(self.metadata or {}), allow_nan=False)
+        except (TypeError, ValueError) as exc:
+            raise ValueError("field metadata must be finite JSON data") from exc
+
+    @classmethod
+    def from_mapping(cls, payload: Mapping) -> "FieldRerankerArtifact":
+        if int(payload.get("schema_version", -1)) != FIELD_ARTIFACT_SCHEMA_VERSION:
+            raise ValueError("unsupported field artifact schema")
+        if tuple(payload.get("feature_order", ())) != FIELD_FEATURE_ORDER:
+            raise ValueError("field artifact feature order mismatch")
+        circuit = payload.get("circuit") or {}
+        if (int(circuit.get("qubits", -1)) != 2
+                or int(circuit.get("trainable_weights", -1)) != 8
+                or circuit.get("ansatz") != "astra-field-v1"
+                or circuit.get("output") != "even-parity-probability"):
+            raise ValueError("unsupported field circuit")
+        scaler = payload.get("feature_scaler") or {}
+        return cls(
+            artifact_id=str(payload.get("artifact_id", "")),
+            weights=tuple(float(value) for value in payload.get("weights", ())),
+            fusion_weight=float(payload.get("fusion_weight", 0.10)),
+            score_calibration=str(payload.get("score_calibration", "none")),
+            feature_min=tuple(float(value) for value in scaler.get("min", ())),
+            feature_max=tuple(float(value) for value in scaler.get("max", ())),
+            training_stage=str(payload.get("training_stage", "experimental")),
+            metadata=dict(payload.get("metadata") or {}),
+        )
+
+    def to_mapping(self) -> dict:
+        return {
+            "schema_version": FIELD_ARTIFACT_SCHEMA_VERSION,
+            "artifact_id": self.artifact_id,
+            "feature_order": list(FIELD_FEATURE_ORDER),
+            "feature_scaler": {
+                "min": [float(value) for value in self.feature_min],
+                "max": [float(value) for value in self.feature_max],
+            },
+            "circuit": {
+                "ansatz": "astra-field-v1",
+                "qubits": 2,
+                "trainable_weights": 8,
+                "output": "even-parity-probability",
+            },
+            "weights": [float(value) for value in self.weights],
+            "fusion_weight": float(self.fusion_weight),
+            "score_calibration": self.score_calibration,
+            "training_stage": self.training_stage,
+            "metadata": dict(self.metadata or {}),
+        }
+
+
+def _ry(angle: float) -> np.ndarray:
+    half = 0.5 * float(angle)
+    return np.asarray([[math.cos(half), -math.sin(half)],
+                       [math.sin(half), math.cos(half)]], dtype=np.complex128)
+
+
+def _rz(angle: float) -> np.ndarray:
+    half = 0.5 * float(angle)
+    return np.asarray([[np.exp(-1j * half), 0.0],
+                       [0.0, np.exp(1j * half)]], dtype=np.complex128)
+
+
+_IDENTITY = np.eye(2, dtype=np.complex128)
+_CZ = np.diag([1.0, 1.0, 1.0, -1.0]).astype(np.complex128)
+
+
+def _single_qubit(gate: np.ndarray, qubit: int) -> np.ndarray:
+    # Qiskit basis ordering is |q1 q0>; q0 is the least-significant qubit.
+    return np.kron(_IDENTITY, gate) if int(qubit) == 0 else np.kron(gate, _IDENTITY)
+
+
+def field_circuit_probability(features: Sequence[float], weights: Sequence[float]) -> float:
+    """Evaluate the v1 circuit's even-parity probability exactly."""
+    values = np.clip(_finite_vector(features, 4, "field features"), 0.0, 1.0)
+    theta = _finite_vector(weights, 8, "field weights")
+    state = np.asarray([1.0, 0.0, 0.0, 0.0], dtype=np.complex128)
+    operations = (
+        (_ry(math.pi * values[0]), 0), (_rz(math.pi * values[1]), 0),
+        (_ry(math.pi * values[2]), 1), (_rz(math.pi * values[3]), 1),
+    )
+    for gate, qubit in operations:
+        state = _single_qubit(gate, qubit) @ state
+    state = _CZ @ state
+    for gate, qubit in ((_ry(theta[0]), 0), (_rz(theta[1]), 0),
+                        (_ry(theta[2]), 1), (_rz(theta[3]), 1)):
+        state = _single_qubit(gate, qubit) @ state
+    state = _CZ @ state
+    for gate, qubit in ((_ry(theta[4]), 0), (_rz(theta[5]), 0),
+                        (_ry(theta[6]), 1), (_rz(theta[7]), 1)):
+        state = _single_qubit(gate, qubit) @ state
+    probability = float(abs(state[0]) ** 2 + abs(state[3]) ** 2)
+    return float(np.clip(probability, 0.0, 1.0))
+
+
+class QuantumFieldReranker:
+    """Runtime scorer backed by a validated two-qubit field artifact."""
+
+    def __init__(self, artifact: FieldRerankerArtifact):
+        self.artifact = artifact
+        self.artifact_id = artifact.artifact_id
+        self.fusion_weight = float(artifact.fusion_weight)
+
+    def _normalize(self, features: np.ndarray) -> np.ndarray:
+        values = np.asarray(features, dtype=np.float64)
+        if values.ndim != 2 or values.shape[1] != 4:
+            raise ValueError("field feature batch must have shape (n, 4)")
+        if not np.all(np.isfinite(values)):
+            raise ValueError("field feature batch contains non-finite values")
+        lo = np.asarray(self.artifact.feature_min, dtype=np.float64)
+        hi = np.asarray(self.artifact.feature_max, dtype=np.float64)
+        return np.clip((values - lo) / (hi - lo), 0.0, 1.0)
+
+    def score_batch(self, features: np.ndarray) -> np.ndarray:
+        normalized = self._normalize(features)
+        scores = np.asarray([
+            field_circuit_probability(row, self.artifact.weights)
+            for row in normalized
+        ], dtype=np.float64)
+        if self.artifact.score_calibration == "batch_max" and len(scores):
+            scores = scores / max(float(np.max(scores)), 1e-12)
+        return scores
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for block in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def verify_active_deployment(
+        artifact_path: str | Path,
+        deployment_path: str | Path | None = None) -> dict:
+    """Verify the local allow-list record required for active reranking."""
+    artifact = Path(artifact_path)
+    deployment = (Path(deployment_path) if deployment_path is not None
+                  else artifact.with_suffix(".deployment.json"))
+    payload = json.loads(deployment.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("field deployment root must be an object")
+    if int(payload.get("schema_version", -1)) != FIELD_DEPLOYMENT_SCHEMA_VERSION:
+        raise ValueError("unsupported field deployment schema")
+    if payload.get("status") != "active":
+        raise ValueError("field deployment is not active")
+    if payload.get("rollback_mode") != "shadow":
+        raise ValueError("active field deployment must declare shadow rollback")
+    if payload.get("artifact_sha256") != _sha256(artifact):
+        raise ValueError("field deployment artifact hash mismatch")
+    gates = payload.get("activation_gates")
+    if (not isinstance(gates, dict) or not gates
+            or any(value is not True for value in gates.values())):
+        raise ValueError("field deployment activation gates are not all passing")
+    return payload
+
+
+def load_field_reranker(path: str | Path, *, require_active: bool = False,
+                        deployment_path: str | Path | None = None
+                        ) -> QuantumFieldReranker:
+    artifact_path = Path(path)
+    payload = json.loads(artifact_path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("field artifact root must be an object")
+    reranker = QuantumFieldReranker(FieldRerankerArtifact.from_mapping(payload))
+    if require_active:
+        deployment = verify_active_deployment(artifact_path, deployment_path)
+        if deployment.get("artifact_id") != reranker.artifact_id:
+            raise ValueError("field deployment artifact id mismatch")
+        feature_sha = (reranker.artifact.metadata or {}).get("feature_sha256")
+        if deployment.get("feature_sha256") != feature_sha:
+            raise ValueError("field deployment feature hash mismatch")
+    return reranker

runtime/wave_reranker.py

@@ -0,0 +1,300 @@
+"""Classical, quantum-inspired path-field reranker for HSCM.
+
+This module does not claim physical quantum state.  It represents competing
+HSCM paths as normalized complex amplitudes, mixes them through a bounded
+similarity kernel, and measures the resulting intensities.  The construction is
+phase-sensitive, norm-normalized, deterministic, and NumPy-only at runtime.
+"""
+from __future__ import annotations
+
+import json
+import hashlib
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping, Sequence
+
+import numpy as np
+
+
+WAVE_ARTIFACT_SCHEMA_VERSION = 1
+WAVE_DEPLOYMENT_SCHEMA_VERSION = 1
+WAVE_FEATURE_ORDER = (
+    "semantic_support",
+    "lexical_support",
+    "coherence",
+    "path_quality",
+)
+WAVE_AUX_ORDER = (
+    "phase_residual",
+    "holonomy",
+    "relative_weight",
+    "state_amplitude",
+)
+
+
+def _vector(values: Sequence[float], size: int, label: str) -> np.ndarray:
+    result = np.asarray(values, dtype=np.float64)
+    if result.shape != (size,) or not np.all(np.isfinite(result)):
+        raise ValueError(f"{label} must contain {size} finite values")
+    return result
+
+
+def _bounded(value: float, lower: float, upper: float, label: str) -> float:
+    result = float(value)
+    if not math.isfinite(result) or not lower <= result <= upper:
+        raise ValueError(f"{label} must be finite and within [{lower}, {upper}]")
+    return result
+
+
+@dataclass(frozen=True)
+class WaveRerankerArtifact:
+    artifact_id: str
+    mode: str
+    input_weights: tuple[float, ...]
+    logit_scale: float
+    kernel_log_weights: tuple[float, ...]
+    residual_gain: float
+    holonomy_gain: float
+    mixing: float
+    decoherence: float
+    fusion_weight: float = 0.10
+    training_stage: str = "experimental"
+    metadata: Mapping | None = None
+
+    def __post_init__(self) -> None:
+        if not str(self.artifact_id).strip():
+            raise ValueError("wave artifact_id must not be empty")
+        if self.mode not in {"wave", "real-control"}:
+            raise ValueError("wave artifact mode must be wave or real-control")
+        _vector(self.input_weights, 6, "input_weights")
+        _vector(self.kernel_log_weights, 4, "kernel_log_weights")
+        _bounded(self.logit_scale, 0.05, 10.0, "logit_scale")
+        for value, label in ((self.residual_gain, "residual_gain"),
+                             (self.holonomy_gain, "holonomy_gain")):
+            if not math.isfinite(float(value)):
+                raise ValueError(f"{label} must be finite")
+        _bounded(self.mixing, 0.0, 0.75, "mixing")
+        _bounded(self.decoherence, 0.0, 1.0, "decoherence")
+        _bounded(self.fusion_weight, 0.0, 0.25, "fusion_weight")
+        try:
+            json.dumps(dict(self.metadata or {}), allow_nan=False)
+        except (TypeError, ValueError) as exc:
+            raise ValueError("wave metadata must be finite JSON data") from exc
+
+    def to_mapping(self) -> dict:
+        return {
+            "schema_version": WAVE_ARTIFACT_SCHEMA_VERSION,
+            "artifact_id": self.artifact_id,
+            "mode": self.mode,
+            "feature_order": list(WAVE_FEATURE_ORDER),
+            "aux_order": list(WAVE_AUX_ORDER),
+            "input_weights": [float(value) for value in self.input_weights],
+            "logit_scale": float(self.logit_scale),
+            "kernel_log_weights": [
+                float(value) for value in self.kernel_log_weights],
+            "phase_gains": {
+                "residual": float(self.residual_gain),
+                "holonomy": float(self.holonomy_gain),
+            },
+            "mixing": float(self.mixing),
+            "decoherence": float(self.decoherence),
+            "fusion_weight": float(self.fusion_weight),
+            "training_stage": self.training_stage,
+            "metadata": dict(self.metadata or {}),
+        }
+
+    @classmethod
+    def from_mapping(cls, payload: Mapping) -> "WaveRerankerArtifact":
+        if int(payload.get("schema_version", -1)) != WAVE_ARTIFACT_SCHEMA_VERSION:
+            raise ValueError("unsupported wave artifact schema")
+        if tuple(payload.get("feature_order", ())) != WAVE_FEATURE_ORDER:
+            raise ValueError("wave feature order mismatch")
+        if tuple(payload.get("aux_order", ())) != WAVE_AUX_ORDER:
+            raise ValueError("wave auxiliary order mismatch")
+        gains = payload.get("phase_gains") or {}
+        return cls(
+            artifact_id=str(payload.get("artifact_id", "")),
+            mode=str(payload.get("mode", "")),
+            input_weights=tuple(float(value) for value in
+                                payload.get("input_weights", ())),
+            logit_scale=float(payload.get("logit_scale", 1.0)),
+            kernel_log_weights=tuple(float(value) for value in
+                                     payload.get("kernel_log_weights", ())),
+            residual_gain=float(gains.get("residual", 0.0)),
+            holonomy_gain=float(gains.get("holonomy", 0.0)),
+            mixing=float(payload.get("mixing", 0.0)),
+            decoherence=float(payload.get("decoherence", 0.0)),
+            fusion_weight=float(payload.get("fusion_weight", 0.10)),
+            training_stage=str(payload.get("training_stage", "experimental")),
+            metadata=dict(payload.get("metadata") or {}),
+        )
+
+
+class QuantumInspiredWaveReranker:
+    """Measure a normalized phase-sensitive field over one candidate set."""
+
+    def __init__(self, artifact: WaveRerankerArtifact):
+        self.artifact = artifact
+        self.artifact_id = artifact.artifact_id
+        self.fusion_weight = float(artifact.fusion_weight)
+        metadata = dict(artifact.metadata or {})
+        self.nested_wave_alpha = float(
+            metadata.get("nested_wave_alpha", 0.0))
+        self.nested_shortlist = int(metadata.get("nested_shortlist", 0))
+        if not 0.0 <= self.nested_wave_alpha <= 1.0:
+            raise ValueError("nested_wave_alpha must be within [0, 1]")
+        if self.nested_shortlist < 0:
+            raise ValueError("nested_shortlist must be non-negative")
+
+    @staticmethod
+    def _inputs(features: np.ndarray, auxiliary: np.ndarray
+                ) -> tuple[np.ndarray, np.ndarray]:
+        values = np.asarray(features, dtype=np.float64)
+        aux = np.asarray(auxiliary, dtype=np.float64)
+        if values.ndim != 2 or values.shape[1] != 4:
+            raise ValueError("wave feature batch must have shape (n, 4)")
+        if aux.shape != (values.shape[0], 4):
+            raise ValueError("wave auxiliary batch must have shape (n, 4)")
+        if not np.all(np.isfinite(values)) or not np.all(np.isfinite(aux)):
+            raise ValueError("wave inputs contain non-finite values")
+        if np.any(aux[:, 2] < 0.0) or np.any(aux[:, 3] <= 0.0):
+            raise ValueError("relative weights and state amplitudes are invalid")
+        return values, aux
+
+    def score_paths(self, features: np.ndarray, auxiliary: np.ndarray) -> np.ndarray:
+        values, aux = self._inputs(features, auxiliary)
+        count = len(values)
+        if count == 0:
+            return np.zeros(0, dtype=np.float64)
+        relative = aux[:, 2]
+        relative = relative - float(np.mean(relative))
+        depth = np.clip(np.log(np.maximum(aux[:, 3], 0.05) / 0.5), -1.0, 1.0)
+        model_inputs = np.column_stack((values, relative, depth))
+        logits = ((model_inputs @ np.asarray(
+            self.artifact.input_weights, dtype=np.float64))
+                  * float(self.artifact.logit_scale))
+
+        residual_signal = np.sin(aux[:, 0])
+        holonomy_signal = np.sin(aux[:, 1])
+        phase = (float(self.artifact.residual_gain) * residual_signal
+                 + float(self.artifact.holonomy_gain) * holonomy_signal)
+        if self.artifact.mode == "real-control":
+            # Same observations and parameter count, but phase is consumed as an
+            # ordinary real logit rather than through complex interference.
+            logits = logits + phase
+            phase = np.zeros(count, dtype=np.float64)
+
+        logits = logits - float(np.max(logits))
+        base_probability = np.exp(np.clip(logits, -60.0, 0.0))
+        base_probability /= max(float(np.sum(base_probability)), 1e-12)
+        magnitude = np.sqrt(base_probability)
+        state = magnitude * np.exp(1j * phase)
+
+        kernel_scale = np.exp(np.clip(np.asarray(
+            self.artifact.kernel_log_weights, dtype=np.float64), -6.0, 6.0))
+        kernel_values = values * kernel_scale
+        norms = np.linalg.norm(kernel_values, axis=1, keepdims=True)
+        normalized = kernel_values / np.maximum(norms, 1e-12)
+        kernel = np.clip(normalized @ normalized.T, 0.0, 1.0)
+        np.fill_diagonal(kernel, 0.0)
+        row_sums = np.sum(kernel, axis=1, keepdims=True)
+        kernel = np.divide(kernel, row_sums, out=np.zeros_like(kernel),
+                           where=row_sums > 1e-12)
+
+        mixing = float(self.artifact.mixing)
+        evolved = (1.0 - mixing) * state + mixing * (kernel @ state)
+        coherent = np.abs(evolved) ** 2
+        incoherent = ((1.0 - mixing) * base_probability
+                      + mixing * (kernel @ base_probability))
+        measured = ((1.0 - float(self.artifact.decoherence)) * coherent
+                    + float(self.artifact.decoherence) * incoherent)
+        measured = np.maximum(np.asarray(measured, dtype=np.float64), 0.0)
+        measured /= max(float(np.sum(measured)), 1e-12)
+        if not np.all(np.isfinite(measured)):
+            raise ValueError("wave measurement produced non-finite values")
+        return measured
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for block in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def verify_active_wave_deployment(
+        artifact_path: str | Path,
+        deployment_path: str | Path | None = None) -> dict:
+    """Verify the exact allow-list for the protected phase controller.
+
+    Active phase use is intentionally narrower than general wave reranking: it
+    may only reorder an already-ranked scalar shortlist, it may not participate
+    in evidence admission, and the deployment must record the manual override
+    of the statistically inconclusive end-to-end result.
+    """
+    artifact = Path(artifact_path)
+    deployment = (Path(deployment_path) if deployment_path is not None
+                  else artifact.with_suffix(".deployment.json"))
+    payload = json.loads(deployment.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("wave deployment root must be an object")
+    if int(payload.get("schema_version", -1)) != WAVE_DEPLOYMENT_SCHEMA_VERSION:
+        raise ValueError("unsupported wave deployment schema")
+    if payload.get("status") != "active-protected":
+        raise ValueError("wave deployment is not active-protected")
+    if payload.get("rollback_mode") != "shadow-observer":
+        raise ValueError(
+            "active wave deployment must declare shadow-observer rollback")
+    if payload.get("artifact_sha256") != _sha256(artifact):
+        raise ValueError("wave deployment artifact hash mismatch")
+    gates = payload.get("activation_gates")
+    if (not isinstance(gates, dict) or not gates
+            or any(value is not True for value in gates.values())):
+        raise ValueError("wave deployment activation gates are not all passing")
+    override = payload.get("operator_override")
+    if (not isinstance(override, dict)
+            or override.get("authorized") is not True
+            or override.get("statistically_conclusive") is not False):
+        raise ValueError(
+            "active wave deployment must record the inconclusive operator override")
+    safety = payload.get("safety_invariants")
+    required_safety = {
+        "protected_scalar_shortlist": True,
+        "unrestricted_wave_ranker": False,
+        "can_admit_evidence": False,
+        "telemetry_contains_text": False,
+    }
+    if (not isinstance(safety, dict)
+            or any(safety.get(key) is not value
+                   for key, value in required_safety.items())):
+        raise ValueError("wave deployment safety invariants are invalid")
+    return payload
+
+
+def load_wave_reranker(
+        path: str | Path, *, require_active: bool = False,
+        deployment_path: str | Path | None = None
+        ) -> QuantumInspiredWaveReranker:
+    """Load a wave artifact, optionally requiring protected active approval."""
+    artifact_path = Path(path)
+    payload = json.loads(artifact_path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("wave artifact root must be an object")
+    reranker = QuantumInspiredWaveReranker(
+        WaveRerankerArtifact.from_mapping(payload))
+    if require_active:
+        deployment = verify_active_wave_deployment(
+            artifact_path, deployment_path)
+        if deployment.get("artifact_id") != reranker.artifact_id:
+            raise ValueError("wave deployment artifact id mismatch")
+        if float(deployment.get("nested_wave_alpha", -1.0)) != (
+                reranker.nested_wave_alpha):
+            raise ValueError("wave deployment nested alpha mismatch")
+        if int(deployment.get("nested_shortlist", -1)) != (
+                reranker.nested_shortlist):
+            raise ValueError("wave deployment nested shortlist mismatch")
+        if reranker.nested_wave_alpha <= 0.0 or reranker.nested_shortlist <= 0:
+            raise ValueError("active wave artifact has no protected nested controller")
+    return reranker

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4
+size 19989343

tokenizer_config.json

@@ -0,0 +1,31 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

training_summary.json

@@ -0,0 +1,27 @@
+{
+  "baseline_test_loss": 3.591158390045166,
+  "baseline_validation_loss": 3.4935073852539062,
+  "epochs": 1.0,
+  "experimental_unreviewed_candidates": 182,
+  "final_test_loss": 2.7644448280334473,
+  "final_validation_loss": 2.722090244293213,
+  "gpu": "NVIDIA GeForce RTX 4070 Ti",
+  "learning_rate": 8e-05,
+  "method": "LoRA SFT, completion-only loss, language layers only",
+  "precision": "bfloat16",
+  "quantization": null,
+  "rank": 16,
+  "test_examples": 23,
+  "train_examples": 182,
+  "trainable_fraction": 0.004655995554170912,
+  "trainable_parameters": 21233664,
+  "validation_examples": 23,
+  "versions": {
+    "datasets": "4.3.0",
+    "peft": "0.20.0",
+    "torch": "2.11.0+cu130",
+    "transformers": "5.5.0",
+    "trl": "0.24.0",
+    "unsloth": "2026.8.21"
+  }
+}

validation_summary.json

@@ -0,0 +1,20 @@
+{
+  "adapter_sha256": "c317c8cf66815b64af8f440a0c5e99da8c6bcd416fd297a0c57419a1eff96e47",
+  "guarded_checks": {
+    "adapter_denies_physical_quantum_claim": true,
+    "adapter_physics_answer_correct": true,
+    "adapter_refuses_missing_specific": true,
+    "adapter_response_lengths_bounded": true,
+    "all_delivered_outputs_nonempty": true,
+    "all_delivered_outputs_template_clean": true,
+    "fresh_process_system_loaded": true,
+    "missing_specific_delivery_audit_passed": true,
+    "missing_specific_detected_as_unmet": true,
+    "no_rejected_draft_committed": true,
+    "raw_adapter_remains_quarantined": true
+  },
+  "guarded_system_passed": true,
+  "raw_adapter_passed": false,
+  "source_human_approved": false,
+  "status": "guarded-experimental"
+}