Publish Modilify Mk2 Preview

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+assets/01-LOGO.jpg filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,125 @@
+Modilify Open Model License 1.0
+
+Copyright 2026 Modilify
+
+1. Definitions
+
+"Model" means the weights, configuration, inference code, tokenizer, processor,
+and documentation distributed with this license. "Derivative Model" means a
+modified, fine-tuned, distilled, merged, quantized, or otherwise adapted version
+of the Model. "You" means the individual or legal entity exercising permissions
+under this license. "High-Risk Use" means a use that can materially affect a
+person's safety, liberty, access to essential services, employment, housing,
+credit, education, legal rights, or medical care, or that controls critical
+infrastructure, weapons, or large-scale biometric surveillance.
+
+2. Copyright Grant
+
+Subject to this license, Modilify grants You a worldwide, perpetual,
+non-exclusive, royalty-free, irrevocable copyright license to use, reproduce,
+prepare derivative works of, publicly display, publicly perform, sublicense,
+host as a service, and distribute the Model and Derivative Models, including for
+commercial purposes.
+
+3. Patent Grant
+
+Each contributor grants You a worldwide, perpetual, non-exclusive, royalty-free,
+irrevocable patent license, except as stated in this section, to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Model where the
+license applies only to those patent claims licensable by that contributor that
+are necessarily infringed by that contributor's contribution alone or in
+combination with the Model. If You institute patent litigation alleging that the
+Model or a contribution constitutes patent infringement, patent licenses granted
+to You under this license terminate as of the filing date.
+
+4. Conditions on Redistribution
+
+If You distribute the Model or a Derivative Model, You must:
+
+a. provide recipients a copy of this license;
+b. retain copyright, patent, attribution, and NOTICE statements;
+c. state clearly that You modified the Model and identify material modifications;
+d. preserve applicable third-party license and attribution notices; and
+e. publish with the distributed model a reasonably accessible impact statement
+   describing intended uses, material limitations, evaluation scope, known
+   safety risks, and risk mitigations for the Derivative Model.
+
+The impact statement may be maintained in a public model card or equivalent
+document. You are not required to submit it separately to Modilify.
+
+5. Responsible Use and High-Risk Uses
+
+You must not use the Model or a Derivative Model:
+
+a. to develop, operate, or materially facilitate weapons, autonomous targeting,
+   or systems intended to cause physical harm;
+b. for unlawful mass surveillance, biometric identification without lawful
+   authority and appropriate safeguards, or social scoring that determines
+   access to rights or essential services;
+c. to exploit children or vulnerable persons, facilitate human trafficking, or
+   generate non-consensual intimate content;
+d. to impersonate a person or deceptively represent machine output as an
+   authentic human communication where the deception is reasonably likely to
+   cause material harm; or
+e. to make a final decision in a High-Risk Use without meaningful qualified
+   human review, proportionate testing, monitoring, appeal or correction paths,
+   and compliance with applicable law.
+
+Before deploying the Model in a High-Risk Use, You must perform safety and impact
+due diligence proportionate to foreseeable harm. At minimum, document the use
+context, evaluate relevant failure modes and affected groups, apply reasonable
+technical and organizational safeguards, monitor material incidents, and update
+or suspend the deployment when its residual risk is not reasonable. Research,
+testing, auditing, and defensive safety work are permitted when conducted with
+appropriate safeguards.
+
+6. Trademarks
+
+This license does not grant permission to use the trade names, trademarks,
+service marks, or product names of Modilify or any contributor, except as needed
+for reasonable and customary attribution or to describe the origin of the Model.
+
+7. Third-Party Components
+
+The Model includes or derives from third-party components identified in
+NOTICE.md. Those components remain subject to their applicable
+licenses and terms. In particular, rights and obligations associated with the
+Google DiffusionGemma base are not removed, narrowed, or replaced by this
+license. You are responsible for complying with all applicable upstream terms.
+
+8. Termination and Reinstatement
+
+Your rights terminate automatically if You materially violate this license and
+do not cure the violation within 30 days after becoming aware of it. Rights are
+reinstated upon timely cure unless a rights holder provides written notice of a
+substantially similar repeated violation. Sections intended by their nature to
+survive termination remain effective.
+
+9. Disclaimer of Warranty
+
+THE MODEL IS PROVIDED "AS IS," WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, OR SAFETY. YOU ARE
+SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING
+THE MODEL AND ASSUME ALL RISKS ASSOCIATED WITH YOUR EXERCISE OF PERMISSIONS.
+
+10. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR SHALL
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES ARISING FROM THIS LICENSE OR THE USE OR INABILITY TO USE
+THE MODEL, HOWEVER CAUSED AND UNDER ANY THEORY OF LIABILITY, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGES.
+
+11. Governing Law and Venue
+
+This license is governed by the laws of the State of California, excluding its
+conflict-of-law rules. Any dispute arising from this license must be brought in
+the state or federal courts located in Santa Clara County, California, and each
+party consents to their personal jurisdiction and venue.
+
+12. Entire License; Severability
+
+This document states the complete Modilify license for the Model, subject to
+applicable third-party terms. If a provision is unenforceable, it will be limited
+to the minimum extent necessary and the remaining provisions remain effective.

NOTICE.md

@@ -0,0 +1,264 @@
+# Modilify Mk2 — Notices
+
+Copyright 2026 Modilify
+
+This distribution is derived from `google/diffusiongemma-26B-A4B-it`, published
+by Google DeepMind under Apache License 2.0. It retains the upstream multimodal
+encoder, vision tower, vision projection, tokenizer, processor assets, and base
+language-model parameters. Modilify added dual-timescale latent deliberation
+and an excess-entropy confidence-and-entropy commit policy. The inference graph
+restores the Gemma 4 vision tower on the encoder so text, image, and video
+prompts share one rolling-canvas decoder.
+
+The Modilify Open Model License 1.0 applies to Modilify's distribution and
+original contributions. It does not erase, narrow, or replace rights and notices
+applicable to upstream components. Users remain responsible for complying with
+all applicable upstream terms.
+
+- Upstream model: https://huggingface.co/google/diffusiongemma-26B-A4B-it
+- Transformers project: https://github.com/huggingface/transformers
+
+The remote model implementation subclasses public DiffusionGemma interfaces in
+Hugging Face Transformers, which is also distributed under Apache License 2.0.
+
+## Derivative Model Impact Statement Template
+
+When distributing a derivative of Modilify Mk2, include a public impact
+statement covering the following items. No separate submission to Modilify is
+required.
+
+### Identity and modifications
+
+- Model name, version, publisher, and contact.
+- Base version.
+- Material modifications, data sources, merges, quantization, or adaptation.
+
+### Intended and excluded uses
+
+- Intended users and use cases.
+- Explicitly excluded uses.
+- Deployment context and degree of human oversight.
+
+### Evaluation scope
+
+- Evaluated capabilities and datasets.
+- Languages, modalities, populations, or contexts not evaluated.
+- Hardware and software used.
+
+### Known limitations and foreseeable risks
+
+- Reliability limitations.
+- Safety, bias, privacy, security, and misuse risks.
+- High-risk decisions the model must not make autonomously.
+
+### Mitigations and monitoring
+
+- Technical and organizational safeguards.
+- Human review, appeal, and correction mechanisms.
+- Monitoring, incident response, and update policy.
+
+## Apache License 2.0
+
+The complete license text applicable to the upstream components follows.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,238 @@
+---
+license: other
+license_name: modilify-open-model-license-1.0
+license_link: LICENSE
+library_name: transformers
+pipeline_tag: image-text-to-text
+tags:
+  - diffusion
+  - multimodal
+  - image-text-to-text
+  - mixture-of-experts
+  - trust-remote-code
+---
+
+![LOGO](assets/01-LOGO.jpg)
+
+# Modilify Mk2 Preview
+
+A 26B-A4B multimodal block-diffusion model with dual-timescale latent deliberation.
+
+Mk2 does not dump chain-of-thought into extra visible tokens. Each heavy denoise runs a latent Transformer over a packed trajectory history and a denoise-time tape, then writes persistent memory only when the canvas actually commits. Working state is recomputed every step. Persistent slots survive the rolling window. The exclusive excess-entropy commit formula still decides how many tokens lock in; temperature and failure budget are first-class inference knobs.
+
+This repository is the first public Mk2 preview checkpoint: merged BF16 weights, remote code, processor, and tokenizer. The text trunk and dual-timescale latent stack come from schema23 training step 900 (~12.4 million adaptation tokens). The Gemma 4 vision tower is restored from DiffusionGemma so text, image, and video share one decoder. This is not a full benchmark release.
+
+## Architecture
+
+The heavy trunk is DiffusionGemma 26B-A4B. Inside every denoise, a 4-layer latent Transformer reads the noisy 256-token canvas plus:
+
+1. **Packed history** (T=16). Four views of each canvas position's recent deliberation, projected into rank-1024 space. New canvas positions start empty; they do not inherit the previous token's thought.
+2. **Denoise tape**. Row-level probes written on a time ring. They do not shift when tokens commit.
+3. **Persistent slots** (256 × 2816). Updated only at commit by a Transformer writer. Full-attention decoder layers read working and persistent buses.
+
+Visible tokens are the product of that loop, not the workspace. Easy prompts commit a long prefix. Hard prompts keep pondering.
+
+The encoder is the official Gemma 4 multimodal encoder. Image and video tokens condition prefix KV the same way text does; the rolling canvas and latent stack stay text-side.
+
+## Model Summary
+
+| | |
+| --- | ---: |
+| Architecture | Mixture-of-Experts block diffusion + dual-timescale latent Transformer |
+| Total Parameters | 26.139B text trunk + 569.550M vision encoder + latent stack |
+| Text Heavy-Denoise Activated Parameters | 4.159B |
+| Vision Encoder | Gemma 4 Vision, 569.550M |
+| Layers | 30 |
+| Number of Experts | 128 |
+| Selected Experts per Token | 8 |
+| Vocabulary Size | 262,144 |
+| Context Length | 262,144 tokens |
+| Sliding Window | 1024 |
+| Canvas Length | 256 |
+| Latent Width | 2,816 |
+| Latent Memory | 256 slots × 2,816-d, 4 layers |
+| Trajectory History | 16 frames, 4 views, rank 1,024 |
+| Denoise Tape | 16 probes |
+| Modality | Text, Image, Video |
+| Preview checkpoint | schema23 step 900 |
+| Adaptation tokens | ~12.4 million |
+
+## Getting Started
+
+Transformers 5.14.1 is the minimum supported version.
+
+```shell
+pip install -U transformers torch accelerate
+```
+
+### Text generation
+
+```python
+import torch
+from transformers import AutoModelForMultimodalLM, AutoProcessor
+
+model_id = "modilify/Modilify-Mk2-preview"
+processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+model = AutoModelForMultimodalLM.from_pretrained(
+    model_id,
+    trust_remote_code=True,
+    dtype=torch.bfloat16,
+    device_map="auto",
+)
+
+messages = [{"role": "user", "content": "Explain why the sky is blue."}]
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    add_generation_prompt=True,
+    enable_thinking=False,
+    return_dict=True,
+    return_tensors="pt",
+).to(model.device)
+
+output = model.generate(
+    **inputs,
+    max_new_tokens=256,
+    denoise_temperature=0.8,
+    commit_failure_budget=0.2,
+)
+new_tokens = output.sequences[:, inputs["input_ids"].shape[1]:]
+print(processor.batch_decode(new_tokens, skip_special_tokens=False)[0])
+```
+
+### Image input
+
+```python
+from PIL import Image
+
+image = Image.open("example.jpg").convert("RGB")
+messages = [{
+    "role": "user",
+    "content": [
+        {"type": "image", "image": image},
+        {"type": "text", "text": "Describe the image and identify uncertainty."},
+    ],
+}]
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    add_generation_prompt=True,
+    enable_thinking=True,
+    return_dict=True,
+    return_tensors="pt",
+).to(model.device)
+output = model.generate(**inputs, max_new_tokens=256)
+```
+
+### Video-frame input
+
+The processor represents video as a sampled sequence of frames. The following example uses PyAV to decode a short local clip and samples at most 32 RGB frames.
+
+```python
+import av
+from PIL import Image
+
+container = av.open("short_clip.mp4")
+decoded = [Image.fromarray(frame.to_rgb().to_ndarray()) for frame in container.decode(video=0)]
+stride = max(1, len(decoded) // 32)
+frames = decoded[::stride][:32]
+
+messages = [{
+    "role": "user",
+    "content": [
+        {"type": "video", "video": frames},
+        {"type": "text", "text": "Summarize the main visual events in order."},
+    ],
+}]
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    add_generation_prompt=True,
+    enable_thinking=True,
+    return_dict=True,
+    return_tensors="pt",
+).to(model.device)
+output = model.generate(**inputs, max_new_tokens=256)
+```
+
+## Thinking mode
+
+The chat template controls the prompt, not the model's first generated tokens.
+
+- `enable_thinking=True` inserts a system turn that contains `<|think|>` and still ends the prompt at `<|turn>model`.
+- `enable_thinking=False` does **not** inject an empty thought channel. The prompt ends at `<|turn>model`.
+
+The model may still open `<|channel>thought` on its own. That is generation, not a template artifact. Applications should not assume hidden reasoning is complete, correct, or appropriate to expose to end users.
+
+## Configurable inference
+
+The two primary knobs are sampling temperature and the prefix failure budget. Both default to the values used in Mk2 training (`0.8` and `0.2`) and can be changed per call or on the config object.
+
+| Parameter | Default | Meaning |
+| --- | ---: | --- |
+| `denoise_temperature` | 0.8 | Sampling temperature for every canvas step |
+| `commit_failure_budget` | 0.2 | Cumulative prefix risk limit for normal commits |
+| `jump_failure_budget` | 2.0 | Cumulative risk limit for forced jumps |
+| `jump_on_no_progress_after` | 12 | Stagnation steps before a forced jump |
+| `max_ponder_steps` | 64 | Watchdog multiplier per requested token |
+| `min_trajectory_progress` | 0.005 | Minimum fused-risk improvement counted as progress |
+| `canvas_length` | 256 | Rolling diffusion canvas length |
+| `repetition_penalty` | 1.0 | Transformers-style repetition penalty |
+| `turn_end_token_id` | 106 | Gemma turn terminator |
+
+Call-site override:
+
+```python
+output = model.generate(
+    **inputs,
+    max_new_tokens=256,
+    denoise_temperature=0.4,
+    commit_failure_budget=0.05,
+)
+```
+
+Load-time override:
+
+```python
+from transformers import AutoConfig
+
+config = AutoConfig.from_pretrained(model_id, trust_remote_code=True)
+config.denoise_temperature = 0.4
+config.commit_failure_budget = 0.05
+model = AutoModelForMultimodalLM.from_pretrained(
+    model_id,
+    config=config,
+    trust_remote_code=True,
+    dtype=torch.bfloat16,
+    device_map="auto",
+)
+```
+
+Lower temperature and a tighter budget make the model more cautious and usually slower. Higher temperature and a looser budget commit more tokens per denoise. These are compute-control decisions, not guarantees of correctness.
+
+Generation supports left-padded batches with independent stopping. Batch prompts of similar lengths together for the best throughput. Streaming and caller-supplied KV caches remain limited to batch size 1.
+
+## Evaluation status, limitations, and risks
+
+This is a preview. It does not include a complete accuracy, robustness, calibration, fairness, or safety evaluation. Structural export checks and a small graduate-level qualitative probe, if present, do not establish fitness for use.
+
+The model can hallucinate facts, citations, visual details, or temporal relationships; reproduce bias, unsafe content, personal information, or copyrighted material; and consume substantial time and memory during long iterative generation. Confidence-based commits control compute. They do not certify that a prefix is true. Visual performance can degrade with poor resolution, motion, occlusion, unusual aspect ratios, or domain shift.
+
+Evaluate the exact deployment on representative, adversarial, and out-of-distribution inputs. Use layered safeguards, monitoring, incident response, and qualified human review. Never delegate autonomous high-risk medical, legal, financial, employment, housing, education, critical-infrastructure, or safety decisions to the model.
+
+## License
+
+Released under the [Modilify Open Model License 1.0](LICENSE), subject to its responsible-use and derivative-impact terms. Upstream rights, attribution, Apache-2.0 text, and the impact-statement template are retained in [NOTICE.md](NOTICE.md).
+
+## Citation
+
+```bibtex
+@software{modilify_mk2_preview_2026,
+  title = {Modilify Mk2 Preview},
+  author = {Modilify},
+  year = {2026},
+  note = {A multimodal dual-timescale latent-deliberation derivative of DiffusionGemma}
+}
+```
+
+Also cite the upstream DiffusionGemma release as requested by Google DeepMind.

chat_template.jinja

@@ -0,0 +1,387 @@
+{#
+  Template: Modilify Canonical Chat Template
+  Author: Modilify
+  Published: 2026-07-09
+  Context: Fixed tool-calling loops, turn closures, and thinking content-ordering.
+#}
+{%- macro format_parameters(properties, required, filter_keys=false) -%}
+    {%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}
+    {%- set ns = namespace(found_first=false) -%}
+    {%- for key, value in properties | dictsort -%}
+        {%- set add_comma = false -%}
+        {%- if not filter_keys or key not in standard_keys -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {{ key }}:{
+            {%- if value['description'] -%}
+                description:<|"|>{{ value['description'] }}<|"|>
+                {%- set add_comma = true -%}
+            {%- endif -%}
+            {%- if value['type'] | upper == 'STRING' -%}
+                {%- if value['enum'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    enum:{{ format_argument(value['enum']) }}
+                {%- endif -%}
+            {%- elif value['type'] | upper == 'ARRAY' -%}
+                {%- if value['items'] is mapping and value['items'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    items:{
+                    {%- set ns_items = namespace(found_first=false) -%}
+                    {%- for item_key, item_value in value['items'] | dictsort -%}
+                        {%- if item_value is not none -%}
+                            {%- if ns_items.found_first %},{% endif -%}
+                            {%- set ns_items.found_first = true -%}
+                            {%- if item_key == 'properties' -%}
+                                properties:{
+                                {%- if item_value is mapping -%}
+                                    {{- format_parameters(item_value, value['items']['required'] | default([])) -}}
+                                {%- endif -%}
+                                }
+                            {%- elif item_key == 'required' -%}
+                                required:[
+                                {%- for req_item in item_value -%}
+                                    <|"|>{{- req_item -}}<|"|>
+                                    {%- if not loop.last %},{% endif -%}
+                                {%- endfor -%}
+                                ]
+                            {%- elif item_key == 'type' -%}
+                                {%- if item_value is string -%}
+                                    type:{{ format_argument(item_value | upper) }}
+                                {%- else -%}
+                                    type:{{ format_argument(item_value | map('upper') | list) }}
+                                {%- endif -%}
+                            {%- else -%}
+                                {{ item_key }}:{{ format_argument(item_value) }}
+                            {%- endif -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    }
+                {%- endif -%}
+            {%- endif -%}
+            {%- if value['nullable'] %}
+                {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                nullable:true
+            {%- endif -%}
+            {%- if value['type'] | upper == 'OBJECT' -%}
+                {%- if value['properties'] is defined and value['properties'] is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value['properties'], value['required'] | default([])) -}}
+                    }
+                {%- elif value is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value, value['required'] | default([]), filter_keys=true) -}}
+                    }
+                {%- endif -%}
+                {%- if value['required'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    required:[
+                    {%- for item in value['required'] | default([]) -%}
+                        <|"|>{{- item -}}<|"|>
+                        {%- if not loop.last %},{% endif -%}
+                    {%- endfor -%}
+                    ]
+                {%- endif -%}
+            {%- endif -%}
+            {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+            type:<|"|>{{ value['type'] | upper }}<|"|>}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endmacro -%}
+{%- macro format_function_declaration(tool_data) -%}
+    declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>
+    {%- set params = tool_data['function']['parameters'] -%}
+    {%- if params -%}
+        ,parameters:{
+        {%- if params['properties'] -%}
+            properties:{ {{- format_parameters(params['properties'], params['required']) -}} },
+        {%- endif -%}
+        {%- if params['required'] -%}
+            required:[
+            {%- for item in params['required'] -%}
+                <|"|>{{- item -}}<|"|>
+                {{- ',' if not loop.last -}}
+            {%- endfor -%}
+            ],
+        {%- endif -%}
+        {%- if params['type'] -%}
+            type:<|"|>{{- params['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if 'response' in tool_data['function'] -%}
+        {%- set response_declaration = tool_data['function']['response'] -%}
+        ,response:{
+        {%- if response_declaration['description'] -%}
+            description:<|"|>{{- response_declaration['description'] -}}<|"|>,
+        {%- endif -%}
+        {%- if response_declaration['type'] | upper == 'OBJECT' -%}
+            type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    }
+{%- endmacro -%}
+{%- macro format_argument(argument, escape_keys=True) -%}
+    {%- if argument is none -%}
+        {{- 'null' -}}
+    {%- elif argument is string -%}
+        {{- '<|"|>' + argument + '<|"|>' -}}
+    {%- elif argument is boolean -%}
+        {{- 'true' if argument else 'false' -}}
+    {%- elif argument is mapping -%}
+        {{- '{' -}}
+        {%- set ns = namespace(found_first=false) -%}
+        {%- for key, value in argument | dictsort -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {%- if escape_keys -%}
+                {{- '<|"|>' + key + '<|"|>' -}}
+            {%- else -%}
+                {{- key -}}
+            {%- endif -%}
+            :{{- format_argument(value, escape_keys=escape_keys) -}}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- elif argument is sequence -%}
+        {{- '[' -}}
+        {%- for item in argument -%}
+            {{- format_argument(item, escape_keys=escape_keys) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- ']' -}}
+    {%- else -%}
+        {{- argument -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro strip_thinking(text) -%}
+    {%- set ns = namespace(result='') -%}
+    {%- for part in text.split('<channel|>') -%}
+        {%- if '<|channel>' in part -%}
+            {%- set ns.result = ns.result + part.split('<|channel>')[0] -%}
+        {%- else -%}
+            {%- set ns.result = ns.result + part -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- ns.result | trim -}}
+{%- endmacro -%}
+
+{%- macro format_tool_response_block(tool_name, response) -%}
+    {{- '<|tool_response>' -}}
+    {%- if response is mapping -%}
+        {{- 'response:' + tool_name + '{' -}}
+        {%- for key, value in response | dictsort -%}
+            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- else -%}
+        {{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}
+    {%- endif -%}
+    {{- '<tool_response|>' -}}
+{%- endmacro -%}
+
+{#- ===== SETUP ===== -#}
+{%- set ns = namespace(prev_message_type=None, prev_non_tool_role=None) -%}
+{%- set loop_messages = messages -%}
+{%- set enable_thinking = enable_thinking | default(false) -%}
+{%- set preserve_thinking = preserve_thinking | default(false) -%}
+{{- bos_token -}}
+{#- Handle System/Tool Definitions Block -#}
+{%- if enable_thinking or tools or (messages and messages[0]['role'] in ['system', 'developer']) -%}
+    {{- '<|turn>system\n' -}}
+    {#- Inject Thinking token at the very top of the FIRST system turn -#}
+    {%- if enable_thinking -%}
+        {{- '<|think|>\n' -}}
+        {%- set ns.prev_message_type = 'think' -%}
+    {%- endif -%}
+    {%- if messages and messages[0]['role'] in ['system', 'developer'] -%}
+        {%- if messages[0]['content'] is string -%}
+            {{- messages[0]['content'] | trim -}}
+        {%- elif messages[0]['content'] is sequence -%}
+            {%- for item in messages[0]['content'] -%}
+                {{- item['text'] | trim + ' '-}}
+            {%- endfor -%}
+        {%- endif -%}
+        {%- set loop_messages = messages[1:] -%}
+    {%- endif -%}
+    {%- if tools -%}
+        {%- for tool in tools %}
+            {{- '<|tool>' -}}
+            {{- format_function_declaration(tool) | trim -}}
+            {{- '<tool|>' -}}
+        {%- endfor %}
+        {%- set ns.prev_message_type = 'tool' -%}
+    {%- endif -%}
+    {{- '<turn|>\n' -}}
+{%- endif %}
+
+{#- Pre-scan: find last user message index for reasoning guard -#}
+{%- set ns_turn = namespace(last_user_idx=-1) -%}
+{%- for i in range(loop_messages | length) -%}
+    {%- if loop_messages[i]['role'] == 'user' -%}
+        {%- set ns_turn.last_user_idx = i -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Loop through messages -#}
+{%- for message in loop_messages -%}
+    {%- if message['role'] != 'tool' -%}
+    {%- set ns.prev_message_type = None -%}
+    {%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}
+    {#- Detect continuation using tracked state — O(1) instead of O(n) backward scan -#}
+    {%- set continue_same_model_turn = (role == 'model' and ns.prev_non_tool_role == 'assistant') -%}
+    {%- if not continue_same_model_turn -%}
+        {{- '<|turn>' + role + '\n' }}
+        
+    {%- endif -%}
+
+    {#- Render reasoning/reasoning_content as thinking channel -#}
+    {%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}
+    {%- set thinking_gate = (loop.index0 > ns_turn.last_user_idx) or (preserve_thinking and message.get('tool_calls')) -%}
+    {%- if thinking_text and thinking_gate -%}
+        {{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}
+    {%- endif -%}
+
+            {%- if message.get('tool_calls') -%}
+                {%- for tool_call in message.get('tool_calls') -%}
+                    {%- set function = tool_call['function'] -%}
+                    {{- '<|tool_call>call:' + function['name'] + '{' -}}
+                    {%- if function['arguments'] is mapping -%}
+                        {%- set ns_args = namespace(found_first=false) -%}
+                        {%- for key, value in function['arguments'] | dictsort -%}
+                            {%- if ns_args.found_first %},{% endif -%}
+                            {%- set ns_args.found_first = true -%}
+                            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+                        {%- endfor -%}
+                    {%- elif function['arguments'] is none -%}
+                    {%- else -%}
+                      {{- raise_exception(
+                          "chat_template: tool_calls[].function.arguments must be a "
+                          "JSON object (mapping), not a string. Deserialize arguments "
+                          "before passing to the template."
+                      ) -}}
+                    {%- endif -%}
+                    {{- '}<tool_call|>' -}}
+                {%- endfor -%}
+                {%- set ns.prev_message_type = 'tool_call' -%}
+            {%- endif -%}
+
+            {%- set ns_tr_out = namespace(flag=false) -%}
+            {%- if message.get('tool_responses') -%}
+                {#- Legacy: tool_responses embedded on the assistant message -#}
+                {%- for tool_response in message.get('tool_responses') -%}
+                    {{- format_tool_response_block(tool_response['name'] | default('unknown', true), tool_response['response']) -}}
+                    {%- set ns_tr_out.flag = true -%}
+                    {%- set ns.prev_message_type = 'tool_response' -%}
+                {%- endfor -%}
+            {%- elif message.get('tool_calls') -%}
+                {#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}
+                {%- set ns_tool_scan = namespace(stopped=false) -%}
+                {%- for k in range(loop.index0 + 1, loop_messages | length) -%}
+                    {%- if ns_tool_scan.stopped -%}
+                    {%- elif loop_messages[k]['role'] != 'tool' -%}
+                        {%- set ns_tool_scan.stopped = true -%}
+                    {%- else -%}
+                        {%- set follow = loop_messages[k] -%}
+                        {#- Resolve tool_call_id to function name -#}
+                        {%- set ns_tname = namespace(name=follow.get('name') or 'unknown') -%}
+                        {%- for tc in message.get('tool_calls') -%}
+                            {%- if tc.get('id') == follow.get('tool_call_id') -%}
+                                {%- set ns_tname.name = tc['function']['name'] -%}
+                            {%- endif -%}
+                        {%- endfor -%}
+                        {#- Handle content as string or content-parts array -#}
+                        {%- set tool_body = follow.get('content') -%}
+                        {%- if tool_body is string -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- elif tool_body is sequence and tool_body is not string -%}
+                            {%- set ns_txt = namespace(s='') -%}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'text' -%}
+                                    {%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}
+                                {%- endif -%}
+                            {%- endfor -%}
+                            {{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') in ['image', 'image_url'] -%}
+                                    {{- '<|image|>' -}}
+                                {%- elif part.get('type') in ['audio', 'input_audio'] -%}
+                                    {{- '<|audio|>' -}}
+                                {%- elif part.get('type') == 'video' -%}
+                                    {{- '<|video|>' -}}
+                                {%- endif -%}
+                            {%- endfor -%}
+                        {%- else -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- endif -%}
+                        {%- set ns_tr_out.flag = true -%}
+                        {%- set ns.prev_message_type = 'tool_response' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+            {%- set captured_content -%}
+            {%- if message.get('content') is string -%}
+                {%- if role == 'model' -%}
+                    {{- strip_thinking(message['content']) -}}
+                {%- else -%}
+                    {{- message['content'] | trim -}}
+                {%- endif -%}
+            {%- elif message.get('content') is sequence -%}
+                {%- for item in message['content'] -%}
+                    {%- if item.get('type') == 'text' -%}
+                        {%- if role == 'model' -%}
+                            {{- strip_thinking(item['text']) -}}
+                        {%- else -%}
+                            {{- item['text'] | trim -}}
+                        {%- endif -%}
+                    {%- elif item.get('type') in ['image', 'image_url'] -%}
+                        {{- '<|image|>' -}}
+                    {%- elif item.get('type') in ['audio', 'input_audio'] -%}
+                        {{- '<|audio|>' -}}
+                    {%- elif item.get('type') == 'video' -%}
+                        {{- '<|video|>' -}}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+            {%- endset -%}
+
+            {{- captured_content -}}
+            {%- set has_content = captured_content | trim | length > 0 -%}
+
+        {#- Forward-scan: find next non-tool message role for continuation detection -#}
+        {%- set next_nt = namespace(role=None, found=false) -%}
+        {%- for j in range(loop.index0 + 1, loop_messages | length) -%}
+            {%- if not next_nt.found -%}
+                {%- if loop_messages[j]['role'] != 'tool' -%}
+                    {%- set next_nt.role = loop_messages[j]['role'] -%}
+                    {%- set next_nt.found = true -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- endfor -%}
+
+        {%- set continues_into_next = (
+            role == 'model'
+            and next_nt.role == 'assistant'
+            and (not message.get('tool_calls') or ns_tr_out.flag)
+        ) -%}
+        
+        {%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}
+            {{- '<|tool_response>' -}}
+        {%- elif continues_into_next -%}
+        {%- elif not (ns_tr_out.flag and not has_content and not next_nt.found) -%}
+            {{- '<turn|>\n' -}}
+        {%- endif -%}
+    {%- endif -%}
+
+    {#- Track previous non-tool role for next iteration (avoids O(n) backward scan) -#}
+    {%- set ns.prev_non_tool_role = message['role'] -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}
+        {{- '<|turn>model\n' -}}
+    {%- elif ns.prev_message_type == 'tool_response' and enable_thinking -%}
+        {{- '<|channel>thought\n' -}}
+    {%- endif -%}
+{%- endif -%}

commit_policy.py

@@ -0,0 +1,305 @@
+# Copyright 2026 Modilify
+# SPDX-License-Identifier: LicenseRef-Modilify-Open-Model-1.0
+"""Confidence-and-entropy commit policy for inference."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+import math
+
+import torch
+
+from .latent_deliberation import (
+    advance_trajectory_clocks,
+    should_force_trajectory_jump,
+)
+
+JUMP_FAILURE_BUDGET = 2.0
+
+FUSED_EPS = 1e-6
+
+
+def fused_commit_confidence(
+    proposal_confidence: torch.Tensor,
+    token_entropy: torch.Tensor,
+    *,
+    vocab_size: int = 256000,
+    eps: float = FUSED_EPS,
+) -> torch.Tensor:
+    """Fuse proposal confidence with token entropy into effective commit confidence.
+
+    Effective confidence is defined using an excess-entropy sigmoid:
+
+        p   = clamp(proposal_confidence, eps, 1 - eps)
+        h2  = -p * log(p) - (1 - p) * log(1 - p)     # binary entropy of p
+        excess = max(token_entropy - h2, 0)
+        base_fused = sigmoid(logit(p) - excess)
+        fused = base_fused.square()
+
+    When the token entropy equals the binary entropy implied by p, the fused
+    confidence equals p^2. Entropy *above* h2 pulls fused below p^2.
+    """
+
+    p = proposal_confidence.float().nan_to_num(0.5).clamp(min=eps, max=1.0 - eps)
+    H = token_entropy.float().nan_to_num(0.0).clamp(min=0.0)
+
+    # Binary entropy of p, using log1p for the (1-p) term.
+    h2 = -p * torch.log(p) - (1.0 - p) * torch.log1p(-p)
+
+    excess = (H - h2).clamp(min=0.0)
+
+    # logit(p) = log(p / (1-p)) = log(p) - log1p(-p)
+    logit_p = torch.log(p) - torch.log1p(-p)
+
+    base_fused = torch.sigmoid(logit_p - excess)
+    fused = base_fused.square()
+    return fused.clamp(min=eps, max=1.0 - eps)
+
+
+def fused_commit_failure_rate(
+    proposal_confidence: torch.Tensor,
+    token_entropy: torch.Tensor,
+    **kwargs: object,
+) -> torch.Tensor:
+    """Return ``1 - effective_confidence`` from the shared fusion helper."""
+
+    return 1.0 - fused_commit_confidence(
+        proposal_confidence, token_entropy, **kwargs
+    )
+
+
+@dataclass(frozen=True)
+class CommitPolicyDecision:
+    """One inference transition from proposal to committed prefix."""
+
+    normal_lengths: torch.LongTensor
+    commit_lengths: torch.LongTensor
+    commit_token_ids: torch.LongTensor
+    jump_rows: torch.BoolTensor
+    ponder_steps: torch.IntTensor
+    stagnation_steps: torch.IntTensor
+
+
+def prefix_failure_commit_lengths(
+    failure_rate: torch.Tensor,
+    *,
+    failure_budget: float,
+    valid_mask: torch.BoolTensor | None = None,
+) -> torch.LongTensor:
+    """Return the longest valid prefix satisfying ``cumsum(failure_rate) < budget``."""
+
+    if failure_rate.ndim != 2:
+        raise ValueError("Failure rate must have shape [batch, canvas].")
+    if failure_budget <= 0:
+        raise ValueError("Commit failure budget must be positive.")
+    if valid_mask is None:
+        valid_mask = torch.ones_like(failure_rate, dtype=torch.bool)
+    if valid_mask.shape != failure_rate.shape:
+        raise ValueError("Commit validity mask must match failure rate.")
+
+    risk = failure_rate.float().clamp(0.0, 1.0) * valid_mask.to(torch.float32)
+    cumulative_risk = risk.cumsum(dim=-1)
+    contiguous_valid = valid_mask.long().cumprod(dim=-1).bool()
+    allowed = cumulative_risk.lt(float(failure_budget)) & contiguous_valid
+    return allowed.long().cumprod(dim=-1).sum(dim=-1)
+
+
+def first_committed_token_lengths(
+    proposal: torch.LongTensor,
+    commit_lengths: torch.LongTensor,
+    token_id: int | Sequence[int],
+    *,
+    positions: torch.LongTensor | None = None,
+) -> torch.LongTensor:
+    """Clip each committed prefix immediately after its first matching stop token."""
+
+    if proposal.ndim != 2 or commit_lengths.shape != proposal.shape[:1]:
+        raise ValueError("Proposal and commit lengths must share a batch dimension.")
+    if positions is None:
+        positions = torch.arange(proposal.shape[1], device=proposal.device).unsqueeze(0)
+    elif positions.shape != (1, proposal.shape[1]):
+        raise ValueError("Commit positions must have shape [1, canvas].")
+    committed = positions.lt(commit_lengths[:, None])
+    stop_token_ids = (
+        (int(token_id),)
+        if isinstance(token_id, int)
+        else tuple(dict.fromkeys(int(value) for value in token_id))
+    )
+    if not stop_token_ids:
+        raise ValueError("At least one stop token ID is required.")
+    matches = proposal.eq(stop_token_ids[0])
+    for value in stop_token_ids[1:]:
+        matches |= proposal.eq(value)
+    matches &= committed
+    sentinel = torch.full_like(positions, proposal.shape[1])
+    first = torch.where(matches, positions, sentinel).min(dim=-1).values
+    clipped = torch.where(first.lt(proposal.shape[1]), first + 1, commit_lengths)
+    return torch.minimum(clipped, commit_lengths)
+
+
+def bounded_prefix_failure_commit_lengths(
+    committed_token_ids: torch.LongTensor,
+    failure_rate: torch.Tensor,
+    *,
+    failure_budget: float,
+    remaining_lengths: torch.LongTensor,
+    stop_token_id: int | Sequence[int],
+    valid_mask: torch.BoolTensor | None = None,
+    positions: torch.LongTensor | None = None,
+) -> torch.LongTensor:
+    """Apply length and stop-token bounds to the shared failure-rate policy."""
+
+    if committed_token_ids.shape != failure_rate.shape:
+        raise ValueError("Committed token IDs and failure rate must share [batch, canvas].")
+    if remaining_lengths.shape != committed_token_ids.shape[:1]:
+        raise ValueError("Remaining lengths must have shape [batch].")
+    commit_lengths = prefix_failure_commit_lengths(
+        failure_rate,
+        failure_budget=failure_budget,
+        valid_mask=valid_mask,
+    )
+    commit_lengths = torch.minimum(commit_lengths, remaining_lengths.clamp_min(0))
+    return first_committed_token_lengths(
+        committed_token_ids,
+        commit_lengths,
+        stop_token_id,
+        positions=positions,
+    )
+
+
+def select_commit_lengths(
+    sampled_token_ids: torch.LongTensor,
+    normal_failure_rate: torch.Tensor,
+    previous_failure_rate: torch.Tensor,
+    greedy_token_ids: torch.LongTensor,
+    jump_failure_rate: torch.Tensor,
+    *,
+    ponder_steps: torch.Tensor,
+    stagnation_steps: torch.Tensor,
+    active_rows: torch.BoolTensor,
+    remaining_lengths: torch.LongTensor,
+    failure_budget: float,
+    stop_token_id: int | Sequence[int],
+    stagnation_threshold: int,
+    min_progress: float,
+    max_ponder_steps: int | None = None,
+    jump_failure_budget: float | None = None,
+    valid_mask: torch.BoolTensor | None = None,
+) -> CommitPolicyDecision:
+    """Use normal sampled commits and a fixed-budget greedy JUMP.
+
+    Progress is measured from the signed change in fused failure rate over the
+    frontier region (the union of the previous and current commit prefixes plus
+    one blocking position), not from raw confidence/entropy deltas.
+    """
+
+    if not (
+        sampled_token_ids.shape
+        == normal_failure_rate.shape
+        == previous_failure_rate.shape
+        == greedy_token_ids.shape
+        == jump_failure_rate.shape
+    ):
+        raise ValueError("Sampled and greedy statistics must share [batch, canvas].")
+
+    canvas_length = normal_failure_rate.shape[1]
+    positions = torch.arange(canvas_length, device=normal_failure_rate.device)[None, :]
+    normal = bounded_prefix_failure_commit_lengths(
+        sampled_token_ids,
+        normal_failure_rate,
+        failure_budget=failure_budget,
+        remaining_lengths=remaining_lengths,
+        stop_token_id=stop_token_id,
+        valid_mask=valid_mask,
+        positions=positions,
+    )
+    previous_prefix_length = prefix_failure_commit_lengths(
+        previous_failure_rate,
+        failure_budget=failure_budget,
+        valid_mask=valid_mask,
+    )
+    frontier_length = torch.maximum(previous_prefix_length, normal) + 1
+    valid_lengths = (
+        valid_mask.long().sum(dim=-1)
+        if valid_mask is not None
+        else torch.full_like(frontier_length, canvas_length)
+    )
+    frontier_length = torch.minimum(frontier_length, valid_lengths)
+    progress_mask = positions < frontier_length[:, None]
+    if valid_mask is not None:
+        progress_mask &= valid_mask
+    progress_mask &= active_rows[:, None]
+    signed_improvement = (
+        previous_failure_rate.float() - normal_failure_rate.float()
+    )
+    weights = progress_mask.float()
+    progress = (
+        signed_improvement * weights
+    ).sum(dim=-1) / weights.sum(dim=-1).clamp_min(1.0)
+    next_ponder, next_stagnation = advance_trajectory_clocks(
+        ponder_steps,
+        stagnation_steps,
+        commit_lengths=normal,
+        active_rows=active_rows,
+        progress_scores=progress,
+        min_progress=min_progress,
+    )
+    jump_rows = normal.eq(0) & active_rows & should_force_trajectory_jump(
+        next_stagnation,
+        progress_scores=progress,
+        min_progress=min_progress,
+        stagnation_threshold=stagnation_threshold,
+        ponder_steps=next_ponder,
+        max_ponder_steps=max_ponder_steps,
+    )
+    jump_commit = bounded_prefix_failure_commit_lengths(
+        greedy_token_ids,
+        jump_failure_rate,
+        failure_budget=(
+            JUMP_FAILURE_BUDGET if jump_failure_budget is None else float(jump_failure_budget)
+        ),
+        remaining_lengths=remaining_lengths,
+        stop_token_id=stop_token_id,
+        valid_mask=valid_mask,
+        positions=positions,
+    )
+    committed = torch.where(jump_rows, jump_commit, normal)
+    commit_token_ids = torch.where(
+        jump_rows[:, None],
+        greedy_token_ids,
+        sampled_token_ids,
+    )
+    committed = torch.where(active_rows, committed, 0)
+    committed_rows = committed.gt(0)
+    jump_rows &= committed_rows
+    next_ponder = torch.where(
+        committed_rows,
+        0,
+        next_ponder,
+    ).to(torch.int32)
+    next_stagnation = torch.where(
+        committed_rows,
+        0,
+        next_stagnation,
+    ).to(torch.int32)
+    return CommitPolicyDecision(
+        normal_lengths=normal,
+        commit_lengths=committed,
+        commit_token_ids=commit_token_ids,
+        jump_rows=jump_rows,
+        ponder_steps=next_ponder,
+        stagnation_steps=next_stagnation,
+    )
+
+
+__all__ = [
+    "CommitPolicyDecision",
+    "JUMP_FAILURE_BUDGET",
+    "bounded_prefix_failure_commit_lengths",
+    "first_committed_token_lengths",
+    "fused_commit_confidence",
+    "fused_commit_failure_rate",
+    "prefix_failure_commit_lengths",
+    "select_commit_lengths",
+]

config.json

@@ -0,0 +1,177 @@
+{
+  "architectures": [
+    "ModilifyMk2ForBlockDiffusion"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_modilify_mk2.ModilifyMk2Config",
+    "AutoModel": "modeling_modilify_mk2.ModilifyMk2Model",
+    "AutoModelForCausalLM": "modeling_modilify_mk2.ModilifyMk2ForBlockDiffusion",
+    "AutoModelForMultimodalLM": "modeling_modilify_mk2.ModilifyMk2ForBlockDiffusion"
+  },
+  "boi_token_id": 255999,
+  "bos_token_id": 2,
+  "canvas_length": 256,
+  "channel_end_token_id": 101,
+  "commit_failure_budget": 0.2,
+  "commit_sequence_dim": 1024,
+  "commit_sequence_layers": 2,
+  "denoise_temperature": 0.8,
+  "dtype": "bfloat16",
+  "eoi_token_id": 258882,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "experience_roles": 3,
+  "image_token_id": 258880,
+  "initializer_range": 0.02,
+  "jump_failure_budget": 2.0,
+  "jump_on_no_progress_after": 12,
+  "kv_cache_bucket_size": 128,
+  "latent_dim": 2816,
+  "latent_dropout": 0.0,
+  "latent_ffn_dim": 7168,
+  "latent_history_kv_rank": 1024,
+  "latent_history_length": 16,
+  "latent_history_views": 4,
+  "latent_local_attention_window": 128,
+  "latent_memory_slots": 256,
+  "latent_num_heads": 16,
+  "latent_num_layers": 4,
+  "latent_tape_probes": 16,
+  "latent_working_last_block_global": true,
+  "max_ponder_steps": 64,
+  "memory_scheme": "dual_timescale_transformer_trajectory_memory",
+  "min_trajectory_progress": 0.005,
+  "model_type": "modilify_mk2",
+  "pad_token_id": 0,
+  "persistent_memory_bus": true,
+  "persistent_memory_write": "commit_only_transformer",
+  "repetition_penalty": 1.0,
+  "state_schema_version": 23,
+  "terminal_token_ids": [
+    106,
+    50
+  ],
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": 2,
+    "dtype": "bfloat16",
+    "eos_token_id": 1,
+    "final_logit_softcapping": 30.0,
+    "global_head_dim": 512,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 2816,
+    "initializer_range": 0.02,
+    "intermediate_size": 2112,
+    "layer_types": [
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 262144,
+    "model_type": "modilify_mk2_text",
+    "moe_intermediate_size": 704,
+    "num_attention_heads": 16,
+    "num_experts": 128,
+    "num_global_key_value_heads": 2,
+    "num_hidden_layers": 30,
+    "num_key_value_heads": 8,
+    "pad_token_id": 0,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "full_attention": {
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 1000000.0,
+        "rope_type": "proportional"
+      },
+      "sliding_attention": {
+        "rope_theta": 10000.0,
+        "rope_type": "default"
+      }
+    },
+    "sliding_window": 1024,
+    "tie_word_embeddings": true,
+    "top_k_experts": 8,
+    "use_bidirectional_attention": "vision",
+    "vocab_size": 262144
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.14.1",
+  "turn_end_token_id": 106,
+  "vision_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "chunk_size_feed_forward": 0,
+    "default_output_length": 280,
+    "dtype": "bfloat16",
+    "global_head_dim": 72,
+    "head_dim": 72,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 4304,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "max_position_embeddings": 131072,
+    "model_type": "gemma4_vision",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 27,
+    "num_key_value_heads": 16,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "position_embedding_size": 10240,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "rope_theta": 100.0,
+      "rope_type": "default"
+    },
+    "standardize": true,
+    "use_clipped_linears": false
+  },
+  "vocab_chunk_size": 32768,
+  "working_memory_bus": true,
+  "writer_slot_gate": "per_slot"
+}

configuration_modilify_mk2.py

@@ -0,0 +1,323 @@
+# Copyright 2026 Modilify
+# SPDX-License-Identifier: LicenseRef-Modilify-Open-Model-1.0
+"""Inference configuration for Modilify Mk2."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from typing import Any
+
+from transformers.models.diffusion_gemma import (
+    DiffusionGemmaConfig,
+    DiffusionGemmaTextConfig,
+)
+
+
+MEMORY_SCHEME = "dual_timescale_transformer_trajectory_memory"
+HISTORY_VIEWS = 4
+EXPERIENCE_ROLES = 3
+COMMIT_SEQUENCE_LAYERS = 2
+DENOISE_TEMPERATURE = 0.8
+COMMIT_FAILURE_BUDGET = 0.2
+JUMP_FAILURE_BUDGET = 2.0
+VOCAB_CHUNK_SIZE = 32_768
+
+_DROPPED_TRAINING_FIELDS = frozenset(
+    {
+        "training_scheme",
+        "training_bptt_steps",
+        "training_prefix_cache",
+        "token_loss_weight",
+        "jump_token_loss_weight",
+        "confidence_calibration_loss_weight",
+        "denoise_improvement_loss_weight",
+        "commit_throughput_softness",
+        "commit_throughput_target_tpd",
+        "commit_throughput_loss_weight",
+        "terminal_stop_loss_weight",
+        "terminal_stop_target_probability",
+        "latent_working_bus_unfreeze_steps",
+        "latent_persistent_bus_unfreeze_steps",
+        "virtual_commit_chunk_sizes",
+        "virtual_commit_chunk_probs",
+        "decoder_checkpoint_policy",
+        "fused_entropy_weight",
+        "schema_version",
+        "sampler_entropy_bound",
+        "loss_transition_steps",
+        "initial_jump_token_loss_weight",
+        "initial_confidence_calibration_loss_weight",
+        "initial_denoise_improvement_loss_weight",
+        "readiness_loss_weight",
+        "commit_risk_budget",
+        "router_load_balance_weight",
+        "router_z_loss_weight",
+        "latent_refinement_steps",
+        "latent_memory_bus_unfreeze_steps",
+    }
+)
+
+
+class ModilifyMk2TextConfig(DiffusionGemmaTextConfig):
+    """Text configuration for the Modilify Mk2 decoder."""
+
+    model_type = "modilify_mk2_text"
+
+
+class ModilifyMk2Config(DiffusionGemmaConfig):
+    """Multimodal inference configuration for dual-timescale Modilify Mk2.
+
+    Args:
+        text_config: DiffusionGemma text configuration or its serialized form.
+        vision_config: Gemma 4 vision configuration or its serialized form.
+        denoise_temperature: Sampling temperature used at every denoising step.
+        commit_failure_budget: Maximum cumulative failure risk for normal commits.
+        jump_failure_budget: Maximum cumulative failure risk for forced jumps.
+        canvas_length: Rolling diffusion canvas length.
+        latent_dim: Width of the working trajectory state.
+        latent_ffn_dim: Feed-forward width inside the latent Transformer.
+        latent_memory_slots: Number of persistent latent memory slots.
+        latent_num_layers: Number of latent Transformer blocks.
+        latent_num_heads: Number of latent attention heads.
+        latent_local_attention_window: Local token-attention radius.
+        latent_dropout: Latent Transformer dropout probability.
+        latent_history_length: Packed per-token trajectory history length.
+        latent_tape_probes: Denoise-time tape probes per frame.
+        jump_on_no_progress_after: Stagnation steps before a forced jump.
+        max_ponder_steps: Maximum denoising iterations per requested token.
+        min_trajectory_progress: Minimum fused-risk improvement counted as progress.
+        turn_end_token_id: Native Gemma turn terminator.
+        repetition_penalty: Transformers-style repetition penalty. ``1.0`` disables
+            it.
+        kwargs: Standard DiffusionGemma configuration values.
+    """
+
+    model_type = "modilify_mk2"
+    sub_configs = {
+        "text_config": ModilifyMk2TextConfig,
+        **{
+            key: value
+            for key, value in DiffusionGemmaConfig.sub_configs.items()
+            if key != "text_config"
+        },
+    }
+
+    def __init__(
+        self,
+        text_config: (
+            ModilifyMk2TextConfig
+            | DiffusionGemmaTextConfig
+            | dict[str, Any]
+            | None
+        ) = None,
+        vision_config: Any | dict[str, Any] | None = None,
+        *,
+        denoise_temperature: float = DENOISE_TEMPERATURE,
+        commit_failure_budget: float = COMMIT_FAILURE_BUDGET,
+        jump_failure_budget: float = JUMP_FAILURE_BUDGET,
+        canvas_length: int = 256,
+        initializer_range: float = 0.02,
+        memory_scheme: str = MEMORY_SCHEME,
+        latent_dim: int = 2816,
+        latent_ffn_dim: int = 7168,
+        latent_memory_slots: int = 256,
+        latent_num_layers: int = 4,
+        latent_num_heads: int = 16,
+        latent_local_attention_window: int = 128,
+        latent_dropout: float = 0.0,
+        latent_history_length: int = 16,
+        latent_tape_probes: int = 16,
+        latent_history_views: int = HISTORY_VIEWS,
+        latent_history_kv_rank: int | None = None,
+        latent_working_last_block_global: bool = True,
+        working_memory_bus: bool = True,
+        persistent_memory_bus: bool = True,
+        persistent_memory_write: str = "commit_only_transformer",
+        experience_roles: int = EXPERIENCE_ROLES,
+        commit_sequence_layers: int = COMMIT_SEQUENCE_LAYERS,
+        commit_sequence_dim: int | None = None,
+        writer_slot_gate: str = "per_slot",
+        kv_cache_bucket_size: int = 128,
+        turn_end_token_id: int = 106,
+        terminal_token_ids: Sequence[int] | None = None,
+        channel_end_token_id: int = 101,
+        vocab_chunk_size: int = VOCAB_CHUNK_SIZE,
+        jump_on_no_progress_after: int = 12,
+        max_ponder_steps: int = 64,
+        min_trajectory_progress: float = 0.005,
+        repetition_penalty: float = 1.0,
+        state_schema_version: int = 23,
+        **kwargs: Any,
+    ) -> None:
+        kwargs.pop("model_type", None)
+        for name in _DROPPED_TRAINING_FIELDS:
+            kwargs.pop(name, None)
+        if isinstance(text_config, DiffusionGemmaTextConfig):
+            text_payload = text_config.to_dict()
+            text_payload.pop("model_type", None)
+            if text_payload.get("use_bidirectional_attention") in (None, False):
+                text_payload["use_bidirectional_attention"] = "vision"
+            text_config = ModilifyMk2TextConfig(**text_payload)
+        elif isinstance(text_config, dict):
+            text_payload = dict(text_config)
+            text_payload.pop("model_type", None)
+            if text_payload.get("use_bidirectional_attention") in (None, False):
+                text_payload["use_bidirectional_attention"] = "vision"
+            text_config = ModilifyMk2TextConfig(**text_payload)
+        elif text_config is None:
+            text_config = ModilifyMk2TextConfig(use_bidirectional_attention="vision")
+
+        self.denoise_temperature = float(denoise_temperature)
+        self.commit_failure_budget = float(commit_failure_budget)
+        self.jump_failure_budget = float(jump_failure_budget)
+        self.canvas_length = int(canvas_length)
+        self.memory_scheme = str(memory_scheme)
+        self.latent_dim = int(latent_dim)
+        self.latent_ffn_dim = int(latent_ffn_dim)
+        self.latent_memory_slots = int(latent_memory_slots)
+        self.latent_num_layers = int(latent_num_layers)
+        self.latent_num_heads = int(latent_num_heads)
+        self.latent_local_attention_window = int(latent_local_attention_window)
+        self.latent_dropout = float(latent_dropout)
+        self.latent_history_length = int(latent_history_length)
+        self.latent_tape_probes = int(latent_tape_probes)
+        self.latent_history_views = int(latent_history_views)
+        if latent_history_kv_rank is None:
+            rank = min(1024, self.latent_dim)
+            rank -= rank % max(self.latent_num_heads, 1)
+            if rank <= 0:
+                rank = self.latent_num_heads
+            self.latent_history_kv_rank = rank
+        else:
+            self.latent_history_kv_rank = int(latent_history_kv_rank)
+        self.latent_working_last_block_global = bool(latent_working_last_block_global)
+        self.working_memory_bus = bool(working_memory_bus)
+        self.persistent_memory_bus = bool(persistent_memory_bus)
+        self.persistent_memory_write = str(persistent_memory_write)
+        self.experience_roles = int(experience_roles)
+        self.commit_sequence_layers = int(commit_sequence_layers)
+        if commit_sequence_dim is None:
+            self.commit_sequence_dim = self.latent_history_kv_rank
+        else:
+            self.commit_sequence_dim = int(commit_sequence_dim)
+        self.writer_slot_gate = str(writer_slot_gate)
+        self.kv_cache_bucket_size = int(kv_cache_bucket_size)
+        self.turn_end_token_id = int(turn_end_token_id)
+        if terminal_token_ids is None:
+            self.terminal_token_ids = (int(self.turn_end_token_id),)
+        else:
+            self.terminal_token_ids = tuple(int(token_id) for token_id in terminal_token_ids)
+        self.channel_end_token_id = int(channel_end_token_id)
+        self.vocab_chunk_size = int(vocab_chunk_size)
+        self.jump_on_no_progress_after = int(jump_on_no_progress_after)
+        self.max_ponder_steps = int(max_ponder_steps)
+        self.min_trajectory_progress = float(min_trajectory_progress)
+        self.repetition_penalty = float(repetition_penalty)
+        self.state_schema_version = int(state_schema_version)
+        super().__init__(
+            text_config=text_config,
+            vision_config=vision_config,
+            initializer_range=initializer_range,
+            **kwargs,
+        )
+        self.model_type = type(self).model_type
+        if not hasattr(self, "eos_token_id"):
+            self.eos_token_id = self.text_config.eos_token_id
+        if not hasattr(self, "pad_token_id"):
+            self.pad_token_id = self.text_config.pad_token_id
+        if not hasattr(self, "bos_token_id"):
+            self.bos_token_id = self.text_config.bos_token_id
+        self._validate_modilify()
+
+    def _validate_modilify(self) -> None:
+        """Validate inference architecture and policy values."""
+
+        if self.memory_scheme != MEMORY_SCHEME:
+            raise ValueError(
+                f"`memory_scheme` must be {MEMORY_SCHEME!r}."
+            )
+        policy_values = (
+            self.denoise_temperature,
+            self.commit_failure_budget,
+            self.jump_failure_budget,
+            self.min_trajectory_progress,
+            self.repetition_penalty,
+        )
+        if any(not math.isfinite(value) for value in policy_values):
+            raise ValueError("Modilify Mk2 policy values must be finite.")
+        positive = (
+            self.denoise_temperature,
+            self.commit_failure_budget,
+            self.jump_failure_budget,
+            self.canvas_length,
+            self.latent_dim,
+            self.latent_ffn_dim,
+            self.latent_memory_slots,
+            self.latent_num_layers,
+            self.latent_num_heads,
+            self.latent_local_attention_window,
+            self.latent_history_length,
+            self.latent_tape_probes,
+            self.latent_history_kv_rank,
+            self.commit_sequence_layers,
+            self.commit_sequence_dim,
+            self.kv_cache_bucket_size,
+            self.vocab_chunk_size,
+            self.jump_on_no_progress_after,
+            self.max_ponder_steps,
+            self.repetition_penalty,
+        )
+        if any(value <= 0 for value in positive):
+            raise ValueError(
+                "Modilify Mk2 dimensions, budgets, intervals, and "
+                "`repetition_penalty` must be positive."
+            )
+        if self.latent_history_views != HISTORY_VIEWS:
+            raise ValueError(f"`latent_history_views` must be {HISTORY_VIEWS}.")
+        if self.experience_roles != EXPERIENCE_ROLES:
+            raise ValueError(f"`experience_roles` must be {EXPERIENCE_ROLES}.")
+        if self.commit_sequence_dim % self.latent_num_heads:
+            raise ValueError("`commit_sequence_dim` must be divisible by `latent_num_heads`.")
+        if self.commit_sequence_dim != self.latent_history_kv_rank:
+            raise ValueError("`commit_sequence_dim` must equal `latent_history_kv_rank`.")
+        if self.persistent_memory_write != "commit_only_transformer":
+            raise ValueError("`persistent_memory_write` must be commit_only_transformer.")
+        if self.writer_slot_gate != "per_slot":
+            raise ValueError("`writer_slot_gate` must be per_slot.")
+        if self.latent_history_kv_rank > self.latent_dim:
+            raise ValueError("`latent_history_kv_rank` must not exceed `latent_dim`.")
+        if self.latent_history_kv_rank % self.latent_num_heads:
+            raise ValueError("`latent_history_kv_rank` must be divisible by `latent_num_heads`.")
+        if not isinstance(self.channel_end_token_id, int) or self.channel_end_token_id < 0:
+            raise ValueError("`channel_end_token_id` must be a non-negative integer.")
+        if not self.terminal_token_ids:
+            raise ValueError("`terminal_token_ids` must not be empty.")
+        if any(
+            not isinstance(token_id, int) or token_id < 0
+            for token_id in self.terminal_token_ids
+        ):
+            raise ValueError("`terminal_token_ids` must be non-negative integers.")
+        if self.latent_dim % self.latent_num_heads:
+            raise ValueError("`latent_dim` must be divisible by `latent_num_heads`.")
+        if not 0.0 <= self.latent_dropout < 1.0:
+            raise ValueError("`latent_dropout` must be in [0, 1).")
+        if self.min_trajectory_progress < 0:
+            raise ValueError("`min_trajectory_progress` must be non-negative.")
+
+
+ModilifyMk2Config.register_for_auto_class()
+
+
+__all__ = [
+    "COMMIT_FAILURE_BUDGET",
+    "COMMIT_SEQUENCE_LAYERS",
+    "DENOISE_TEMPERATURE",
+    "EXPERIENCE_ROLES",
+    "HISTORY_VIEWS",
+    "JUMP_FAILURE_BUDGET",
+    "MEMORY_SCHEME",
+    "ModilifyMk2Config",
+    "ModilifyMk2TextConfig",
+    "VOCAB_CHUNK_SIZE",
+]

continuous_batching.py

@@ -0,0 +1,1726 @@
+# Copyright 2026 Modilify
+# SPDX-License-Identifier: LicenseRef-Modilify-Open-Model-1.0
+"""Continuous batching for Modilify Mk2 behind the Transformers public API shape.
+
+The upstream continuous runner is autoregressive: it persists every query in a
+paged cache and emits exactly one token per request and step.  ModilifyMk2 instead
+denoises a transient bidirectional canvas and may accept a ragged token chunk.
+This module consequently owns the request runner while preserving the public
+manager lifecycle and ``GenerationOutput`` contract.
+
+Accepted prefix K/V is stored per request without padding.  Every heavy denoise
+step creates a temporary, left-padded batched cache view.  The decoder only
+reads that view, so padding can never become persistent or evict real tokens
+from a sliding-window cache.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import hashlib
+import math
+import os
+import queue
+import threading
+import time
+import uuid
+import warnings
+from collections import defaultdict, deque
+from collections.abc import Callable, Generator, Sequence
+from dataclasses import asdict, dataclass, field, is_dataclass, replace
+from typing import Any
+
+import torch
+from transformers.cache_utils import Cache, DynamicCache
+from transformers.generation.configuration_utils import ContinuousBatchingConfig
+from transformers.generation.continuous_batching.requests import (
+    GenerationOutput,
+    RequestStatus,
+)
+
+from .commit_policy import fused_commit_failure_rate, select_commit_lengths
+from .generation_modilify_mk2 import (
+    ModilifyMk2GenerationConfig,
+    ModilifyMk2GenerationOutput,
+    ModilifyMk2RollingState,
+    NoiseCanvasSampler,
+    _add_repetition_history,
+    _flatten_token_ids,
+    build_denoise_trace_event,
+    deterministic_episode_iteration_bound,
+)
+from .latent_deliberation import (
+    LatentDeliberationState,
+    TrajectoryHistory,
+    cat_latent_states,
+    cat_trajectory_history,
+    cat_trajectory_tape,
+    empty_trajectory_tape,
+    infer_commit_reason,
+    slice_latent_state,
+    slice_trajectory_history,
+    slice_trajectory_tape,
+)
+
+
+_TERMINAL_REASONS = frozenset(
+    {
+        "turn_end",
+        "eos",
+        "max_new_tokens",
+        "max_denoising_steps",
+        "episode_watchdog",
+        "cancelled",
+        "error",
+    }
+)
+
+
+def continuous_config_fingerprint(
+    generation_config: Any,
+    continuous_batching_config: ContinuousBatchingConfig | None,
+) -> str:
+    """Return a stable-enough in-process fingerprint for persistent reuse."""
+
+    generation_payload = (
+        generation_config.to_dict()
+        if hasattr(generation_config, "to_dict")
+        else vars(generation_config)
+    )
+    batching = continuous_batching_config or ContinuousBatchingConfig()
+    batching_payload = asdict(batching) if is_dataclass(batching) else vars(batching)
+    return repr(
+        (
+            sorted(generation_payload.items(), key=lambda item: item[0]),
+            sorted(batching_payload.items(), key=lambda item: item[0]),
+        )
+    )
+
+
+@dataclass
+class ModilifyMk2ContinuousGenerationOutput(GenerationOutput):
+    """Official ``GenerationOutput`` plus ModilifyMk2 request-local diagnostics."""
+
+    stop_reason: str | None = None
+    committed_tokens: int = 0
+    denoise_steps: int = 0
+    no_progress_steps: int = 0
+    jump_count: int = 0
+    forced_jump_bad_count: int = 0
+    heavy_forward_count: int = 0
+    latent_context_update_count: int = 0
+    average_commit_len: float = 0.0
+    tokens_per_forward: float = 0.0
+    seed: int | None = None
+    scheduler_run_id: str | None = None
+    queue_seconds: float = 0.0
+    inference_seconds: float = 0.0
+    total_seconds: float = 0.0
+    last_step_batch_size: int = 0
+    is_stream_update: bool = False
+    delta_tokens: list[int] = field(default_factory=list)
+    state_shift_count: int = 0
+    latent_memory_norm: float = 0.0
+    state_retention_score: float = 0.0
+
+    def is_finished(self) -> bool:
+        """Treat failed/cancelled requests as terminal for every consumer API."""
+
+        return self.status in {RequestStatus.FINISHED, RequestStatus.FAILED}
+
+
+@dataclass
+class ModilifyMk2RequestState:
+    """All mutable state required to suspend and re-batch one request."""
+
+    request_id: str
+    prompt_ids: list[int]
+    max_new_tokens: int
+    eos_token_ids: tuple[int, ...]
+    streaming: bool
+    record_timestamps: bool
+    seed: int
+    max_denoising_steps: int | None
+    trace_callback: Callable[[dict[str, object]], None] | None = None
+    created_time: float = field(default_factory=time.perf_counter)
+    status: RequestStatus = RequestStatus.PENDING
+    started_time: float = -1.0
+    finished_time: float = -1.0
+    generated_tokens: list[int] = field(default_factory=list)
+    logprobs: list[float] = field(default_factory=list)
+    timestamps: list[float] = field(default_factory=list)
+    cache: Cache | None = None
+    rolling_state: ModilifyMk2RollingState | None = None
+    repetition_history: torch.BoolTensor | None = None
+    generator: torch.Generator | None = None
+    logical_length: int = 0
+    max_iterations: int = 0
+    reserved_blocks: int = 0
+    denoise_steps: int = 0
+    jumps: int = 0
+    forced_jump_tokens: int = 0
+    shifts: int = 0
+    stop_reason: str | None = None
+    error: str | None = None
+    terminal_emitted: bool = False
+    last_step_batch_size: int = 0
+    last_delta_tokens: list[int] = field(default_factory=list)
+
+
+def _clone_tensor_row(value: torch.Tensor, row: int) -> torch.Tensor:
+    return value[row : row + 1].clone()
+
+
+def _slice_rolling_state(state: ModilifyMk2RollingState, row: int) -> ModilifyMk2RollingState:
+    selected = slice(row, row + 1)
+    return ModilifyMk2RollingState(
+        canvas=_clone_tensor_row(state.canvas, row),
+        confidence=_clone_tensor_row(state.confidence, row),
+        entropy=_clone_tensor_row(state.entropy, row),
+        age=_clone_tensor_row(state.age, row),
+        latent_state=slice_latent_state(state.latent_state, selected),
+        history=slice_trajectory_history(state.history, selected),
+        tape=slice_trajectory_tape(state.tape, selected),
+    )
+
+
+def _pack_rolling_states(states: Sequence[ModilifyMk2RollingState]) -> ModilifyMk2RollingState:
+    return ModilifyMk2RollingState(
+        canvas=torch.cat([state.canvas for state in states], dim=0),
+        confidence=torch.cat([state.confidence for state in states], dim=0),
+        entropy=torch.cat([state.entropy for state in states], dim=0),
+        age=torch.cat([state.age for state in states], dim=0),
+        latent_state=cat_latent_states([state.latent_state for state in states]),
+        history=cat_trajectory_history([state.history for state in states]),
+        tape=cat_trajectory_tape([state.tape for state in states]),
+    )
+
+
+class ModilifyMk2LogicalCachePool:
+    """Per-request hole-free cache storage with ephemeral batched read views."""
+
+    def __init__(self, model: Any, *, max_batch_tokens: int | None = None) -> None:
+        self.model = model
+        self.text_config = model.config.get_text_config(decoder=True)
+        self.device = model.model.decoder.embed_tokens.weight.device
+        self.max_batch_tokens = max_batch_tokens
+
+    def new_cache(self) -> DynamicCache:
+        return DynamicCache(config=self.text_config)
+
+    @torch.inference_mode()
+    def prefill(self, prompt_ids: Sequence[int]) -> Cache:
+        cache = self.new_cache()
+        chunk_size = self.max_batch_tokens or len(prompt_ids)
+        for start in range(0, len(prompt_ids), chunk_size):
+            stop = min(start + chunk_size, len(prompt_ids))
+            tokens = torch.tensor(
+                [list(prompt_ids[start:stop])], device=self.device, dtype=torch.long
+            )
+            mask = torch.ones(1, stop, device=self.device, dtype=torch.bool)
+            positions = torch.arange(
+                start, stop, device=self.device, dtype=torch.int32
+            ).unsqueeze(0)
+            cache = self.model.model.encoder(
+                input_ids=tokens,
+                attention_mask=mask,
+                past_key_values=cache,
+                position_ids=positions,
+            ).past_key_values
+        return cache
+
+    @torch.inference_mode()
+    def append(self, state: ModilifyMk2RequestState, token_ids: Sequence[int]) -> None:
+        if not token_ids:
+            return
+        if state.cache is None:
+            raise RuntimeError("Cannot append tokens before request prefill.")
+        tokens = torch.tensor([list(token_ids)], device=self.device, dtype=torch.long)
+        positions = torch.arange(
+            state.logical_length,
+            state.logical_length + tokens.shape[1],
+            device=self.device,
+            dtype=torch.int32,
+        ).unsqueeze(0)
+        mask = torch.ones(
+            1,
+            state.logical_length + tokens.shape[1],
+            device=self.device,
+            dtype=torch.bool,
+        )
+        state.cache = self.model.model.encoder(
+            input_ids=tokens,
+            attention_mask=mask,
+            past_key_values=state.cache,
+            position_ids=positions,
+        ).past_key_values
+
+    def pack(
+        self, states: Sequence[ModilifyMk2RequestState]
+    ) -> tuple[DynamicCache, torch.BoolTensor, torch.LongTensor]:
+        if not states or any(state.cache is None for state in states):
+            raise ValueError("Every packed request must have an initialized cache.")
+        logical_lengths = torch.tensor(
+            [state.logical_length for state in states],
+            device=self.device,
+            dtype=torch.long,
+        )
+        maximum_length = int(logical_lengths.max())
+        attention_mask = torch.arange(
+            maximum_length, device=self.device
+        )[None, :].ge(maximum_length - logical_lengths[:, None])
+
+        packed = self.new_cache()
+        source_caches = [state.cache for state in states]
+        assert all(cache is not None for cache in source_caches)
+        if any(len(cache.layers) != len(packed.layers) for cache in source_caches):
+            raise RuntimeError("Request cache layer structures differ.")
+
+        for layer_index, packed_layer in enumerate(packed.layers):
+            source_layers = [cache.layers[layer_index] for cache in source_caches]
+            if any(not layer.is_initialized for layer in source_layers):
+                raise RuntimeError("Request cache contains an uninitialized layer.")
+            stored_lengths = [int(layer.keys.shape[-2]) for layer in source_layers]
+            maximum_stored = max(stored_lengths)
+
+            def padded(name: str) -> torch.Tensor:
+                values = []
+                for layer, stored_length in zip(source_layers, stored_lengths, strict=True):
+                    value = getattr(layer, name)
+                    if stored_length < maximum_stored:
+                        padding = value.new_zeros(
+                            value.shape[0],
+                            value.shape[1],
+                            maximum_stored - stored_length,
+                            value.shape[3],
+                        )
+                        value = torch.cat((padding, value), dim=-2)
+                    values.append(value)
+                return torch.cat(values, dim=0)
+
+            keys = padded("keys")
+            values = padded("values")
+            packed_layer.lazy_initialization(keys, values)
+            packed_layer.keys = keys
+            packed_layer.values = values
+            if hasattr(packed_layer, "cumulative_length"):
+                packed_layer.cumulative_length = maximum_length
+        return packed, attention_mask, logical_lengths
+
+
+class ModilifyMk2ContinuousBatchingManager:
+    """FIFO/prefill-first continuous manager compatible with Transformers APIs."""
+
+    def __init__(
+        self,
+        model: Any,
+        generation_config: ModilifyMk2GenerationConfig | None,
+        continuous_batching_config: ContinuousBatchingConfig | None,
+        workload_hints: Any = None,
+    ) -> None:
+        del workload_hints
+        # Generation must not silently mutate the caller's train/eval mode.
+        # Inference mode below disables autograd without changing module-local
+        # dropout or other training flags.
+        self.model = model
+        self.generation_config = copy.deepcopy(
+            generation_config or getattr(model, "generation_config", None)
+            or ModilifyMk2GenerationConfig.from_model_config(model.config)
+        )
+        if not isinstance(self.generation_config, ModilifyMk2GenerationConfig):
+            payload = self.generation_config.to_dict()
+            self.generation_config = ModilifyMk2GenerationConfig(**payload)
+        self.continuous_batching_config = copy.deepcopy(
+            continuous_batching_config or ContinuousBatchingConfig()
+        )
+        self.config_fingerprint = continuous_config_fingerprint(
+            self.generation_config, self.continuous_batching_config
+        )
+        self._validate_config()
+
+        self.device = model.model.decoder.embed_tokens.weight.device
+        self.dtype = model.model.decoder.embed_tokens.weight.dtype
+        self.cache_pool = ModilifyMk2LogicalCachePool(
+            model,
+            max_batch_tokens=self.continuous_batching_config.max_batch_tokens,
+        )
+        self.sampler: NoiseCanvasSampler = model._prepare_sampler(
+            self.generation_config, model.config.canvas_length
+        )
+        self.run_id = uuid.uuid4().hex
+        self.warmed_up = False
+        self.destroyed = False
+
+        configured_requests = self.continuous_batching_config.max_requests_per_batch
+        self.max_requests_per_batch = int(configured_requests or 8)
+        max_batch_tokens = self.continuous_batching_config.max_batch_tokens
+        if max_batch_tokens is not None:
+            token_capacity = int(max_batch_tokens) // int(model.config.canvas_length)
+            if token_capacity < 1:
+                raise ValueError(
+                    "`max_batch_tokens` must fit at least one ModilifyMk2 canvas."
+                )
+            self.max_requests_per_batch = min(
+                self.max_requests_per_batch, token_capacity
+            )
+        self.block_size = int(self.continuous_batching_config.block_size)
+        self.block_capacity = self._resolve_block_capacity()
+        self._base_seed = (
+            int(self.continuous_batching_config.seed)
+            if self.continuous_batching_config.seed is not None
+            else int(torch.initial_seed())
+        )
+
+        self._condition = threading.Condition(threading.RLock())
+        self._pending: deque[ModilifyMk2RequestState] = deque()
+        self._active: dict[str, ModilifyMk2RequestState] = {}
+        self._known_request_ids: set[str] = set()
+        self._cancelled: set[str] = set()
+        self._output_queue: queue.Queue[ModilifyMk2ContinuousGenerationOutput] = queue.Queue()
+        self._stashed_outputs: dict[
+            str, deque[ModilifyMk2ContinuousGenerationOutput]
+        ] = defaultdict(deque)
+        self._result_handlers: dict[str, tuple[Callable, asyncio.AbstractEventLoop]] = {}
+        self._thread: threading.Thread | None = None
+        self._finished = threading.Event()
+        self.fatal_error: BaseException | None = None
+        self._input_closed = False
+        self._hard_stop = False
+        self._keep_for_next_session = False
+        self._request_counter = 0
+        self._active_reserved_blocks = 0
+        self._stats = {
+            "submitted": 0,
+            "admitted": 0,
+            "completed": 0,
+            "failed": 0,
+            "cancelled": 0,
+            "model_steps": 0,
+            "generated_tokens": 0,
+            "max_observed_batch_size": 0,
+            "peak_reserved_blocks": 0,
+            "peak_cache_blocks": 0,
+            "active_slot_steps": 0,
+            "slot_capacity_steps": 0,
+        }
+
+        turn_end = self.generation_config.turn_end_token_id
+        self.turn_end_token_id = int(
+            model.config.turn_end_token_id if turn_end is None else turn_end
+        )
+        self.repetition_penalty = float(self.generation_config.repetition_penalty)
+        self.excluded_repetition_token_ids = _flatten_token_ids(
+            self.generation_config.repetition_penalty_exclude_token_ids,
+            self.generation_config.pad_token_id,
+            self.generation_config.bos_token_id,
+            self.generation_config.eos_token_id,
+            self.generation_config.turn_end_token_id,
+            getattr(model.config, "image_token_id", None),
+        )
+
+    def _validate_config(self) -> None:
+        config = self.continuous_batching_config
+        positive_optional = (
+            "num_blocks",
+            "max_batch_tokens",
+            "max_requests_per_batch",
+        )
+        if not isinstance(config.block_size, int) or config.block_size < 4:
+            raise ValueError("`block_size` must be an integer greater than or equal to 4.")
+        for name in positive_optional:
+            value = getattr(config, name)
+            if value is not None and (not isinstance(value, int) or value <= 0):
+                raise ValueError(f"`{name}` must be a positive integer when set.")
+        if config.max_blocks_per_request is not None and (
+            not isinstance(config.max_blocks_per_request, int)
+            or config.max_blocks_per_request < 0
+        ):
+            raise ValueError("`max_blocks_per_request` must be a non-negative integer.")
+        if not isinstance(config.max_queue_size, int) or config.max_queue_size < 0:
+            raise ValueError("`max_queue_size` must be a non-negative integer.")
+        if config.scheduler_type not in {"fifo", "prefill_first"}:
+            raise ValueError("ModilifyMk2 continuous batching supports `fifo` and `prefill_first`.")
+        if config.max_memory_percent is not None and not (
+            0.0 < float(config.max_memory_percent) <= 1.0
+        ):
+            raise ValueError("`max_memory_percent` must be in (0, 1].")
+        if config.use_async_batching is True:
+            raise ValueError("ModilifyMk2 continuous batching currently uses synchronous model steps.")
+        requested_graphs = config.use_cuda_graph
+        if requested_graphs is True or (
+            isinstance(requested_graphs, tuple) and any(requested_graphs)
+        ):
+            raise ValueError("CUDA graphs are not supported by the ragged ModilifyMk2 runner.")
+        if config.cpu_offload_space is not None and config.cpu_offload_space > 0:
+            raise ValueError("CPU cache offload is not supported by the ModilifyMk2 runner.")
+        if int(config.default_compile_level or 0) > 0:
+            raise ValueError("Continuous ModilifyMk2 compilation is not supported yet.")
+        if config.varlen_compile_config is not None or config.decode_compile_config is not None:
+            raise ValueError("Continuous ModilifyMk2 compilation is not supported yet.")
+        if config.use_default_compile_configs is True:
+            raise ValueError("Continuous ModilifyMk2 compilation is not supported yet.")
+        if int(config.q_padding_interval_size or 0) > 0 or int(
+            config.kv_padding_interval_size or 0
+        ) > 0:
+            raise ValueError("Compiled continuous padding intervals are not supported.")
+        if config.max_cached_graphs is not None:
+            raise ValueError("Cached continuous graphs are not supported.")
+        if torch.distributed.is_available() and torch.distributed.is_initialized():
+            if torch.distributed.get_world_size() > 1:
+                raise ValueError(
+                    "Tensor/distributed parallel continuous batching is not supported."
+                )
+        if getattr(self.model, "device_mesh", None) is not None or getattr(
+            self.model, "_device_mesh", None
+        ) is not None:
+            raise ValueError("Tensor-parallel continuous batching is not supported.")
+        # Prefix sharing would make request ownership and row-local RNG/state
+        # ambiguous.  Normalize this optimization off rather than silently use it.
+        config.allow_block_sharing = False
+
+    def _available_memory_bytes(self) -> int | None:
+        if self.device.type == "cuda" and torch.cuda.is_available():
+            free, _ = torch.cuda.mem_get_info(self.device)
+            return int(free)
+        if self.device.type == "mps" and torch.backends.mps.is_available():
+            return max(
+                0,
+                int(torch.mps.recommended_max_memory())
+                - int(torch.mps.driver_allocated_memory()),
+            )
+        if self.device.type == "cpu":
+            try:
+                import psutil
+
+                return int(psutil.virtual_memory().available)
+            except (ImportError, OSError, ValueError):
+                pass
+            try:
+                return int(os.sysconf("SC_AVPHYS_PAGES")) * int(
+                    os.sysconf("SC_PAGE_SIZE")
+                )
+            except (OSError, TypeError, ValueError):
+                return None
+        return None
+
+    def _estimated_block_bytes(self) -> int:
+        config = self.model.config.text_config
+        layer_types = list(config.layer_types)
+        local_heads = int(config.num_key_value_heads)
+        local_dim = int(config.head_dim)
+        global_heads = int(
+            getattr(config, "num_global_key_value_heads", None) or local_heads
+        )
+        global_dim = int(getattr(config, "global_head_dim", None) or local_dim)
+        per_token = 0
+        for layer_type in layer_types:
+            if layer_type == "full_attention":
+                heads, dimension = global_heads, global_dim
+            else:
+                heads, dimension = local_heads, local_dim
+            per_token += 2 * heads * dimension * torch.empty((), dtype=self.dtype).element_size()
+        return max(1, per_token * int(self.continuous_batching_config.block_size))
+
+    def _resolve_block_capacity(self) -> int | None:
+        capacity = self.continuous_batching_config.num_blocks
+        percent = self.continuous_batching_config.max_memory_percent
+        available = self._available_memory_bytes()
+        if percent is None and capacity is None:
+            # Never make the default cache silently unbounded. This fraction is
+            # applied to currently available device/host memory after model load.
+            percent = 0.8
+        if percent is not None and available is None:
+            raise RuntimeError(
+                "Cannot infer available cache memory on this device; set `num_blocks` "
+                "explicitly instead of `max_memory_percent`."
+            )
+        if percent is not None and available is not None:
+            memory_blocks = int(
+                available * float(percent) / self._estimated_block_bytes()
+            )
+            capacity = memory_blocks if capacity is None else min(int(capacity), memory_blocks)
+        return None if capacity is None else max(0, int(capacity))
+
+    @staticmethod
+    def _block_footprint(reservations: Sequence[int]) -> int:
+        """Return persistent plus temporary packed-cache block equivalents."""
+
+        if not reservations:
+            return 0
+        return sum(reservations) + len(reservations) * max(reservations)
+
+    def _current_block_footprint(self) -> int:
+        return self._block_footprint(
+            [state.reserved_blocks for state in self._active.values()]
+        )
+
+    def _derive_seed(self, request_id: str) -> int:
+        digest = hashlib.sha256(
+            str(self._base_seed).encode("ascii")
+            + b"\0"
+            + request_id.encode("utf-8")
+        ).digest()
+        return int.from_bytes(digest[:8], "big") & ((1 << 63) - 1)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        with self._condition:
+            capacity_steps = int(self._stats["slot_capacity_steps"])
+            return {
+                "scheduler_run_id": self.run_id,
+                **self._stats,
+                "slot_utilization": (
+                    float(self._stats["active_slot_steps"]) / capacity_steps
+                    if capacity_steps
+                    else 0.0
+                ),
+                "active_requests": len(self._active),
+                "pending_requests": len(self._pending),
+                "max_requests_per_batch": self.max_requests_per_batch,
+                "block_capacity": -1 if self.block_capacity is None else self.block_capacity,
+                "reserved_blocks": self._active_reserved_blocks,
+                "cache_blocks": self._current_block_footprint(),
+            }
+
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def warmup(self) -> None:
+        if self.destroyed:
+            raise RuntimeError("Cannot warm up a destroyed manager.")
+        # CUDA graphs and static-shape compilation are intentionally unsupported;
+        # normal eager kernels warm naturally on the first real batch.
+        self.warmed_up = True
+
+    def start(self) -> None:
+        if self._keep_for_next_session:
+            self._prepare_for_next_session()
+        with self._condition:
+            if self.destroyed:
+                raise RuntimeError("Cannot start a destroyed manager.")
+            if self.is_running():
+                return
+            self._finished.clear()
+            self.fatal_error = None
+            self._hard_stop = False
+            self._thread = threading.Thread(
+                target=self._run_generation_loop,
+                name=f"modilify_mk2-continuous-{self.run_id[:8]}",
+                daemon=True,
+            )
+            self._thread.start()
+
+    def join(
+        self,
+        stop_trigger_time: float | None = None,
+        timeout: float | None = None,
+    ) -> None:
+        """Wait for the current worker, matching the official manager lifecycle."""
+
+        del stop_trigger_time
+        with self._condition:
+            thread = self._thread
+        if thread is None or thread is threading.current_thread():
+            return
+        thread.join(timeout=timeout)
+        if thread.is_alive():
+            raise TimeoutError("Timed out waiting for continuous generation to stop.")
+
+    def _prepare_for_next_session(self) -> None:
+        """Finish an asynchronous prior stop and reopen a cached manager safely."""
+
+        with self._condition:
+            if not self._keep_for_next_session:
+                return
+            thread = self._thread
+        if thread is not None and thread.is_alive():
+            thread.join()
+        with self._condition:
+            if self.destroyed:
+                raise RuntimeError("Cannot reuse a destroyed manager.")
+            if self._pending or self._active:
+                raise RuntimeError("Cannot reuse a manager with unfinished requests.")
+            self._input_closed = False
+            self._hard_stop = False
+            self._keep_for_next_session = False
+            self.fatal_error = None
+            self._cancelled.clear()
+            self._condition.notify_all()
+
+    def close_input(self) -> None:
+        """Stop accepting requests and let the iterator drain all submitted work."""
+
+        with self._condition:
+            self._input_closed = True
+            self._condition.notify_all()
+
+    def stop(
+        self,
+        block: bool = True,
+        timeout: float | None = None,
+        keep_for_next_session: bool = False,
+        hard_stop: bool = False,
+    ) -> None:
+        with self._condition:
+            self._input_closed = True
+            self._hard_stop = bool(hard_stop)
+            self._keep_for_next_session = bool(keep_for_next_session)
+            if hard_stop:
+                self._cancelled.update(self._known_request_ids)
+            self._condition.notify_all()
+            thread = self._thread
+        if hard_stop and (thread is None or not thread.is_alive()):
+            self._apply_cancellations()
+        if block and thread is not None:
+            self.join(timeout=timeout)
+        if keep_for_next_session and not self.is_running():
+            with self._condition:
+                self._input_closed = False
+                self._hard_stop = False
+                self._keep_for_next_session = False
+                self.fatal_error = None
+
+    def destroy(self) -> None:
+        if self.destroyed:
+            return
+        self.stop(block=True, hard_stop=True)
+        self.destroyed = True
+        with self._condition:
+            self._pending.clear()
+            self._active.clear()
+            self._condition.notify_all()
+
+    def add_request(
+        self,
+        input_ids: list[int],
+        request_id: str | None = None,
+        max_new_tokens: int | None = None,
+        streaming: bool = False,
+        record_timestamps: bool = False,
+        eos_token_id: int | list[int] | None = None,
+        **request_kwargs: Any,
+    ) -> str:
+        if not input_ids or any(
+            not isinstance(token_id, int) or isinstance(token_id, bool)
+            for token_id in input_ids
+        ):
+            raise ValueError("`input_ids` must be a non-empty list of integer token IDs.")
+        seed = request_kwargs.pop("seed", None)
+        trace_callback = request_kwargs.pop("denoise_trace_callback", None)
+        max_denoising_steps = request_kwargs.pop(
+            "max_denoising_steps", self.generation_config.max_denoising_steps
+        )
+        if request_kwargs:
+            unsupported = ", ".join(sorted(request_kwargs))
+            raise ValueError(f"Unsupported per-request generation options: {unsupported}")
+        if trace_callback is not None and not callable(trace_callback):
+            raise TypeError("`denoise_trace_callback` must be callable.")
+        if trace_callback is not None and self.max_requests_per_batch > 1:
+            raise ValueError(
+                "ModilifyMk2 denoise tracing remains a batch-size-1 interface; "
+                "set `max_requests_per_batch=1`."
+            )
+        limit = self.generation_config.max_new_tokens if max_new_tokens is None else max_new_tokens
+        if not isinstance(limit, int) or limit <= 0:
+            raise ValueError("`max_new_tokens` must be a positive integer.")
+        if max_denoising_steps is not None and (
+            not isinstance(max_denoising_steps, int) or max_denoising_steps <= 0
+        ):
+            raise ValueError("`max_denoising_steps` must be a positive integer when set.")
+
+        with self._condition:
+            if self.destroyed or self._input_closed:
+                raise RuntimeError("Continuous batching manager is not accepting requests.")
+            if self.fatal_error is not None:
+                raise RuntimeError("Continuous batching manager has failed.") from self.fatal_error
+            if request_id is None:
+                request_id = f"req_{self._request_counter}"
+                self._request_counter += 1
+            if request_id in self._known_request_ids:
+                raise ValueError(f"Duplicate continuous request ID: {request_id}")
+            queue_limit = int(self.continuous_batching_config.max_queue_size)
+            deadline = time.monotonic() + 10.0
+            while queue_limit and len(self._pending) >= queue_limit:
+                if not self.is_running():
+                    raise queue.Full(
+                        "Continuous request queue is full; start the manager before "
+                        "submitting more requests."
+                    )
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise queue.Full("Continuous request queue remained full for 10 seconds.")
+                self._condition.wait(timeout=remaining)
+                if self.destroyed or self._input_closed:
+                    raise RuntimeError(
+                        "Continuous batching manager stopped while waiting for queue space."
+                    )
+                if self.fatal_error is not None:
+                    raise RuntimeError("Continuous batching manager has failed.") from self.fatal_error
+            # The worker can close/fail the manager while this producer is
+            # asleep. Recheck under the same lock immediately before append.
+            if self.destroyed or self._input_closed:
+                raise RuntimeError("Continuous batching manager is not accepting requests.")
+            if self.fatal_error is not None:
+                raise RuntimeError("Continuous batching manager has failed.") from self.fatal_error
+            if request_id in self._known_request_ids:
+                raise ValueError(f"Duplicate continuous request ID: {request_id}")
+            configured_eos = self.generation_config.eos_token_id if eos_token_id is None else eos_token_id
+            if configured_eos is None:
+                configured_eos = self.model.config.eos_token_id
+            eos_values = (
+                [configured_eos]
+                if isinstance(configured_eos, int)
+                else list(configured_eos or [])
+            )
+            stop_ids = tuple(
+                dict.fromkeys(
+                    [self.turn_end_token_id, *(int(value) for value in eos_values if int(value) >= 0)]
+                )
+            )
+            resolved_seed = self._derive_seed(request_id) if seed is None else int(seed)
+            state = ModilifyMk2RequestState(
+                request_id=request_id,
+                prompt_ids=list(input_ids),
+                max_new_tokens=int(limit),
+                eos_token_ids=stop_ids,
+                streaming=bool(streaming),
+                record_timestamps=bool(record_timestamps),
+                seed=resolved_seed & ((1 << 63) - 1),
+                max_denoising_steps=max_denoising_steps,
+                trace_callback=trace_callback,
+            )
+            state.reserved_blocks = math.ceil(
+                (len(state.prompt_ids) + state.max_new_tokens) / self.block_size
+            )
+            self._pending.append(state)
+            self._known_request_ids.add(request_id)
+            self._stats["submitted"] += 1
+            self._condition.notify_all()
+            return request_id
+
+    def add_requests(
+        self,
+        inputs: list[list[int]],
+        max_new_tokens: int | None = None,
+        streaming: bool = False,
+        record_timestamps: bool = False,
+        **request_kwargs: Any,
+    ) -> list[str]:
+        request_ids = request_kwargs.pop("request_ids", None)
+        seeds = request_kwargs.pop("seeds", None)
+        if request_ids is not None and len(request_ids) != len(inputs):
+            raise ValueError("`request_ids` must contain one ID per request.")
+        if seeds is not None and len(seeds) != len(inputs):
+            raise ValueError("`seeds` must contain one seed per request.")
+        result = []
+        for index, input_ids in enumerate(inputs):
+            per_request = dict(request_kwargs)
+            if seeds is not None:
+                per_request["seed"] = seeds[index]
+            result.append(
+                self.add_request(
+                    input_ids=input_ids,
+                    request_id=None if request_ids is None else request_ids[index],
+                    max_new_tokens=max_new_tokens,
+                    streaming=streaming,
+                    record_timestamps=record_timestamps,
+                    **per_request,
+                )
+            )
+        return result
+
+    def cancel_request(self, request_id: str) -> None:
+        with self._condition:
+            if request_id in self._known_request_ids:
+                self._cancelled.add(request_id)
+                self._condition.notify_all()
+
+    def register_result_handler(self, request_id: str, callback: Callable) -> None:
+        loop = asyncio.get_running_loop()
+        with self._condition:
+            self._result_handlers[request_id] = (callback, loop)
+
+    def _pop_stashed(self, request_id: str | None):
+        with self._condition:
+            if request_id is not None:
+                values = self._stashed_outputs.get(request_id)
+                if values:
+                    return values.popleft()
+                return None
+            for values in self._stashed_outputs.values():
+                if values:
+                    return values.popleft()
+        return None
+
+    def _has_stashed_outputs(self) -> bool:
+        with self._condition:
+            return any(values for values in self._stashed_outputs.values())
+
+    def get_result(
+        self, request_id: str | None = None, timeout: float | None = None
+    ) -> ModilifyMk2ContinuousGenerationOutput | None:
+        stashed = self._pop_stashed(request_id)
+        if stashed is not None:
+            return stashed
+        if not self.is_running() and self._output_queue.empty():
+            return None
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while True:
+            remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
+            if remaining == 0.0:
+                return None
+            try:
+                output = self._output_queue.get(timeout=remaining)
+            except queue.Empty:
+                return None
+            if request_id is None or output.request_id == request_id:
+                return output
+            with self._condition:
+                self._stashed_outputs[output.request_id].append(output)
+
+    def __iter__(self) -> Generator[ModilifyMk2ContinuousGenerationOutput, None, None]:
+        while True:
+            output = self.get_result(timeout=0.05)
+            if output is not None:
+                yield output
+                continue
+            if self._finished.is_set() and self._output_queue.empty():
+                if not self._has_stashed_outputs():
+                    return
+
+    def request_id_iter(
+        self, request_id: str
+    ) -> Generator[ModilifyMk2ContinuousGenerationOutput, None, None]:
+        while True:
+            output = self.get_result(request_id=request_id, timeout=0.05)
+            if output is not None:
+                yield output
+                if output.is_finished():
+                    return
+            elif self._finished.is_set():
+                return
+
+    def _deliver(self, output: ModilifyMk2ContinuousGenerationOutput) -> None:
+        handler = None
+        with self._condition:
+            handler = self._result_handlers.get(output.request_id)
+            if output.is_finished():
+                self._result_handlers.pop(output.request_id, None)
+        if handler is None:
+            self._output_queue.put(output)
+        else:
+            callback, loop = handler
+            try:
+                loop.call_soon_threadsafe(callback, output)
+            except RuntimeError as error:
+                # A callback owner may close its event loop while a terminal
+                # event is in flight. Preserve the result for pull consumers
+                # instead of turning that client race into a worker fatality.
+                warnings.warn(
+                    f"Result callback loop closed for {output.request_id}: {error!r}",
+                    stacklevel=2,
+                )
+                self._output_queue.put(output)
+
+    def _output_for(
+        self,
+        state: ModilifyMk2RequestState,
+        *,
+        stream_update: bool = False,
+        delta_tokens: Sequence[int] | None = None,
+    ) -> ModilifyMk2ContinuousGenerationOutput:
+        now = time.perf_counter()
+        finished = state.status in {RequestStatus.FINISHED, RequestStatus.FAILED}
+        end = state.finished_time if finished else -1.0
+        shifts = max(1, state.shifts)
+        steps = max(1, state.denoise_steps)
+        return ModilifyMk2ContinuousGenerationOutput(
+            request_id=state.request_id,
+            prompt_ids=list(state.prompt_ids),
+            generated_tokens=list(state.generated_tokens),
+            logprobs=list(state.logprobs),
+            error=state.error,
+            status=state.status,
+            created_time=state.created_time,
+            lifespan=(state.started_time, end),
+            timestamps=(list(state.timestamps) if state.record_timestamps else None),
+            stop_reason=state.stop_reason,
+            committed_tokens=len(state.generated_tokens),
+            denoise_steps=state.denoise_steps,
+            no_progress_steps=(
+                0
+                if state.rolling_state is None
+                else int(state.rolling_state.latent_state.stagnation_steps[0])
+            ),
+            jump_count=state.jumps,
+            forced_jump_bad_count=state.forced_jump_tokens,
+            heavy_forward_count=state.denoise_steps,
+            latent_context_update_count=state.denoise_steps,
+            average_commit_len=len(state.generated_tokens) / shifts,
+            tokens_per_forward=len(state.generated_tokens) / steps,
+            seed=state.seed,
+            scheduler_run_id=self.run_id,
+            queue_seconds=max(0.0, state.started_time - state.created_time),
+            inference_seconds=(
+                max(0.0, (end if finished else now) - state.started_time)
+                if state.started_time >= 0
+                else 0.0
+            ),
+            total_seconds=max(0.0, (end if finished else now) - state.created_time),
+            last_step_batch_size=state.last_step_batch_size,
+            is_stream_update=stream_update,
+            delta_tokens=list(
+                state.last_delta_tokens if delta_tokens is None else delta_tokens
+            ),
+            state_shift_count=state.shifts,
+            latent_memory_norm=(
+                0.0
+                if state.rolling_state is None
+                else float(
+                    state.rolling_state.latent_state.memory_slots.float()
+                    .norm(dim=-1)
+                    .mean()
+                )
+            ),
+            state_retention_score=1.0 if state.shifts else 0.0,
+        )
+
+    def _finish(
+        self,
+        state: ModilifyMk2RequestState,
+        reason: str,
+        error: BaseException | str | None = None,
+    ) -> None:
+        if state.terminal_emitted:
+            return
+        if reason not in _TERMINAL_REASONS:
+            raise ValueError(f"Unknown continuous stop reason: {reason}")
+        state.stop_reason = reason
+        state.error = None if error is None else (str(error) if isinstance(error, str) else repr(error))
+        state.status = (
+            RequestStatus.FAILED
+            if reason in {"cancelled", "error"} or error is not None
+            else RequestStatus.FINISHED
+        )
+        state.finished_time = time.perf_counter()
+        state.terminal_emitted = True
+        self._stats["completed"] += 1
+        if reason == "cancelled":
+            self._stats["cancelled"] += 1
+        elif error is not None:
+            self._stats["failed"] += 1
+        self._deliver(self._output_for(state))
+
+    def _fail_all_requests(self, error: BaseException) -> None:
+        """Convert an unexpected worker failure into one terminal result per request."""
+
+        self.fatal_error = error
+        with self._condition:
+            pending = list(self._pending)
+            active = list(self._active.values())
+            self._pending.clear()
+            self._active.clear()
+            self._active_reserved_blocks = 0
+            self._input_closed = True
+            for state in [*active, *pending]:
+                self._finish(state, "error", error)
+            self._condition.notify_all()
+
+    def _request_fits(self, state: ModilifyMk2RequestState) -> bool:
+        per_request_limit = self.continuous_batching_config.max_blocks_per_request
+        if per_request_limit not in (None, 0) and state.reserved_blocks > per_request_limit:
+            return False
+        if self.block_capacity is None:
+            return True
+        reservations = [
+            *(active.reserved_blocks for active in self._active.values()),
+            state.reserved_blocks,
+        ]
+        return self._block_footprint(reservations) <= self.block_capacity
+
+    def _request_can_ever_fit(self, state: ModilifyMk2RequestState) -> bool:
+        per_request_limit = self.continuous_batching_config.max_blocks_per_request
+        if per_request_limit not in (None, 0) and state.reserved_blocks > per_request_limit:
+            return False
+        return (
+            self.block_capacity is None
+            or self._block_footprint([state.reserved_blocks]) <= self.block_capacity
+        )
+
+    def _initialize_request(self, state: ModilifyMk2RequestState) -> None:
+        generator = torch.Generator(device=self.device)
+        generator.manual_seed(state.seed)
+        state.generator = generator
+        try:
+            canvas = self.sampler.initialize_canvas(
+                1, self.device, generators=[generator]
+            )
+        except TypeError:
+            canvas = self.sampler.initialize_canvas(1, self.device)
+        dtype = self.model.model.decoder.embed_tokens.weight.dtype
+        canvas_length = int(self.model.config.canvas_length)
+        latent = LatentDeliberationState.empty(
+            batch_size=1,
+            canvas_length=canvas_length,
+            latent_dim=self.model.config.latent_dim,
+            memory_slots=self.model.config.latent_memory_slots,
+            device=self.device,
+            dtype=dtype,
+        )
+        state.rolling_state = ModilifyMk2RollingState(
+            canvas=canvas,
+            confidence=torch.zeros(1, canvas_length, device=self.device, dtype=torch.float32),
+            entropy=torch.full(
+                (1, canvas_length),
+                math.log(self.model.config.text_config.vocab_size),
+                device=self.device,
+                dtype=torch.float32,
+            ),
+            age=torch.zeros(1, canvas_length, device=self.device, dtype=torch.int32),
+            latent_state=latent,
+            history=TrajectoryHistory.empty(
+                batch_size=1,
+                canvas_length=canvas_length,
+                hidden_size=self.model.config.text_config.hidden_size,
+                history_length=self.model.config.latent_history_length,
+                device=self.device,
+                dtype=dtype,
+            ),
+            tape=empty_trajectory_tape(
+                batch_size=1,
+                config=self.model.config,
+                device=self.device,
+                dtype=dtype,
+            ),
+        )
+        state.cache = self.cache_pool.prefill(state.prompt_ids)
+        state.logical_length = len(state.prompt_ids)
+        if self.repetition_penalty != 1.0:
+            state.repetition_history = torch.zeros(
+                self.model.config.text_config.vocab_size,
+                device=self.device,
+                dtype=torch.bool,
+            )
+            prompt = torch.tensor([state.prompt_ids], device=self.device, dtype=torch.long)
+            _add_repetition_history(
+                state.repetition_history.unsqueeze(0),
+                prompt,
+                torch.ones_like(prompt, dtype=torch.bool),
+                self.excluded_repetition_token_ids,
+            )
+        state.max_iterations = deterministic_episode_iteration_bound(
+            torch.tensor([state.max_new_tokens]),
+            max_ponder_steps=self.generation_config.max_ponder_steps,
+        )
+        state.started_time = time.perf_counter()
+        state.status = RequestStatus.DECODING
+
+    def _apply_cancellations(self) -> None:
+        with self._condition:
+            cancelled = set(self._cancelled)
+            self._cancelled.clear()
+            if not cancelled:
+                return
+            retained = deque()
+            while self._pending:
+                state = self._pending.popleft()
+                if state.request_id in cancelled:
+                    self._finish(state, "cancelled", "request cancelled")
+                else:
+                    retained.append(state)
+            self._pending = retained
+            for request_id in cancelled:
+                state = self._active.pop(request_id, None)
+                if state is not None:
+                    self._active_reserved_blocks -= state.reserved_blocks
+                    self._finish(state, "cancelled", "request cancelled")
+            self._condition.notify_all()
+
+    def _admit_requests(self) -> None:
+        while True:
+            with self._condition:
+                if len(self._active) >= self.max_requests_per_batch or not self._pending:
+                    return
+                state = self._pending[0]
+                if not self._request_can_ever_fit(state):
+                    self._pending.popleft()
+                    self._finish(
+                        state,
+                        "error",
+                        "request exceeds continuous cache block limits",
+                    )
+                    self._condition.notify_all()
+                    continue
+                if not self._request_fits(state):
+                    return
+                self._pending.popleft()
+                self._condition.notify_all()
+            try:
+                self._initialize_request(state)
+            except Exception as error:
+                self._finish(state, "error", error)
+                continue
+            with self._condition:
+                if state.request_id in self._cancelled:
+                    self._cancelled.remove(state.request_id)
+                    self._finish(state, "cancelled", "request cancelled")
+                    continue
+                self._active[state.request_id] = state
+                self._active_reserved_blocks += state.reserved_blocks
+                self._stats["admitted"] += 1
+                self._stats["peak_reserved_blocks"] = max(
+                    self._stats["peak_reserved_blocks"],
+                    self._active_reserved_blocks,
+                )
+                self._stats["peak_cache_blocks"] = max(
+                    self._stats["peak_cache_blocks"],
+                    self._current_block_footprint(),
+                )
+                self._condition.notify_all()
+
+    def _select_rowwise_policy(
+        self,
+        states: Sequence[ModilifyMk2RequestState],
+        proposal: torch.LongTensor,
+        normal_failure_rate: torch.Tensor,
+        previous_failure_rate: torch.Tensor,
+        greedy_proposal: torch.LongTensor,
+        jump_failure_rate: torch.Tensor,
+        rolling: ModilifyMk2RollingState,
+    ):
+        decisions = []
+        for row, state in enumerate(states):
+            remaining = state.max_new_tokens - len(state.generated_tokens)
+            decisions.append(
+                select_commit_lengths(
+                    sampled_token_ids=proposal[row : row + 1],
+                    normal_failure_rate=normal_failure_rate[row : row + 1],
+                    previous_failure_rate=previous_failure_rate[row : row + 1],
+                    greedy_token_ids=greedy_proposal[row : row + 1],
+                    jump_failure_rate=jump_failure_rate[row : row + 1],
+                    ponder_steps=rolling.latent_state.ponder_steps[row : row + 1],
+                    stagnation_steps=rolling.latent_state.stagnation_steps[row : row + 1],
+                    active_rows=torch.ones(1, device=self.device, dtype=torch.bool),
+                    remaining_lengths=torch.tensor([remaining], device=self.device),
+                    failure_budget=self.generation_config.commit_failure_budget,
+                    jump_failure_budget=self.generation_config.jump_failure_budget,
+                    stop_token_id=state.eos_token_ids,
+                    max_ponder_steps=self.generation_config.max_ponder_steps,
+                    stagnation_threshold=self.generation_config.jump_on_no_progress_after,
+                    min_progress=self.generation_config.min_trajectory_progress,
+                )
+            )
+        return (
+            torch.cat([decision.normal_lengths for decision in decisions]),
+            torch.cat([decision.commit_lengths for decision in decisions]),
+            torch.cat([decision.commit_token_ids for decision in decisions]),
+            torch.cat([decision.jump_rows for decision in decisions]),
+            torch.cat([decision.ponder_steps for decision in decisions]),
+            torch.cat([decision.stagnation_steps for decision in decisions]),
+        )
+
+    @torch.inference_mode()
+    def _run_batch_step(self, states: Sequence[ModilifyMk2RequestState]) -> list[str]:
+        started = time.perf_counter()
+        rolling_states = [state.rolling_state for state in states]
+        if any(state is None for state in rolling_states):
+            raise RuntimeError("Active request has no rolling state.")
+        rolling = _pack_rolling_states(rolling_states)  # type: ignore[arg-type]
+        packed_cache, cache_mask, logical_lengths = self.cache_pool.pack(states)
+        batch_size = len(states)
+        canvas_length = int(self.model.config.canvas_length)
+        decoder_positions = (
+            logical_lengths[:, None]
+            + torch.arange(canvas_length, device=self.device)[None, :]
+        ).to(torch.int32)
+        decoder_mask = torch.cat(
+            (
+                cache_mask,
+                torch.ones(
+                    batch_size,
+                    canvas_length,
+                    device=self.device,
+                    dtype=torch.bool,
+                ),
+            ),
+            dim=-1,
+        )
+        repetition_history = None
+        if self.repetition_penalty != 1.0:
+            repetition_history = torch.stack(
+                [state.repetition_history for state in states], dim=0  # type: ignore[list-item]
+            )
+        generators = [state.generator for state in states]
+        if any(generator is None for generator in generators):
+            raise RuntimeError("Active request has no sampling generator.")
+
+        output = self.model(
+            input_ids=None,
+            past_key_values=packed_cache,
+            decoder_input_ids=rolling.canvas,
+            previous_confidence=rolling.confidence,
+            previous_entropy=rolling.entropy,
+            token_age=rolling.age,
+            latent_state=rolling.latent_state,
+            history=rolling.history,
+            tape=rolling.tape,
+            decoder_position_ids=decoder_positions,
+            decoder_read_cache=True,
+            decoder_attention_mask=decoder_mask,
+            compact_vocab=True,
+            denoise_temperature=self.generation_config.denoise_temperature,
+            repetition_token_mask=repetition_history,
+            repetition_penalty=self.repetition_penalty,
+            sampling_generators=generators,
+        )
+        required = (
+            output.proposal,
+            output.proposal_confidence,
+            output.token_entropy,
+            output.greedy_proposal,
+            output.greedy_confidence,
+            output.next_latent_state,
+        )
+        if any(value is None for value in required):
+            raise RuntimeError("Compact ModilifyMk2 forward did not return proposal state.")
+        proposal = output.proposal
+        proposal_confidence = output.proposal_confidence
+        token_entropy = output.token_entropy
+        greedy_proposal = output.greedy_proposal
+        greedy_confidence = output.greedy_confidence
+        next_canvas = proposal.clone()
+        next_confidence = proposal_confidence.float()
+        next_latent = replace(
+            output.next_latent_state,
+            confidence=next_confidence.detach().float(),
+            entropy=token_entropy.detach().float(),
+            age=rolling.age + 1,
+            token_changed=next_canvas.ne(rolling.canvas).detach().float(),
+            confidence_delta=next_confidence.detach().float() - rolling.confidence,
+            entropy_delta=token_entropy.detach().float() - rolling.entropy,
+        )
+        live_mask = torch.ones(
+            rolling.canvas.shape, device=rolling.canvas.device, dtype=torch.bool
+        )
+        tape_probes, tape_valid = self.model.latent_deliberation.encode_tape_frame(
+            output.heavy_hidden_state, live_mask
+        )
+        next_state = ModilifyMk2RollingState(
+            canvas=next_canvas,
+            confidence=next_confidence,
+            entropy=token_entropy,
+            age=rolling.age + 1,
+            latent_state=next_latent,
+            history=rolling.history.append(
+                output.heavy_hidden_state,
+                next_confidence,
+                token_entropy,
+                next_canvas.ne(rolling.canvas).detach().float(),
+                live_mask=live_mask,
+            ),
+            tape=rolling.tape.append(tape_probes, tape_valid),
+        )
+        normal_failure_rate = fused_commit_failure_rate(
+            proposal_confidence,
+            token_entropy,
+            vocab_size=self.model.config.text_config.vocab_size,
+        )
+        jump_failure_rate = fused_commit_failure_rate(
+            greedy_confidence,
+            token_entropy,
+            vocab_size=self.model.config.text_config.vocab_size,
+        )
+        previous_failure_rate = fused_commit_failure_rate(
+            rolling.confidence,
+            rolling.entropy,
+            vocab_size=self.model.config.text_config.vocab_size,
+        )
+        (
+            normal_commit,
+            commit_lengths,
+            commit_token_ids,
+            jump_rows,
+            next_ponder,
+            next_stagnation,
+        ) = self._select_rowwise_policy(
+            states,
+            proposal,
+            normal_failure_rate,
+            previous_failure_rate,
+            greedy_proposal,
+            jump_failure_rate,
+            rolling,
+        )
+        positions = torch.arange(canvas_length, device=self.device)[None, :]
+        commit_positions = positions.lt(commit_lengths[:, None])
+        policy_prefix_mask = positions.lt(normal_commit[:, None])
+        if bool(jump_rows.any()):
+            next_state = replace(
+                next_state,
+                canvas=torch.where(
+                    commit_positions & jump_rows[:, None],
+                    commit_token_ids,
+                    next_state.canvas,
+                ),
+            )
+        next_state = replace(
+            next_state,
+            latent_state=replace(
+                next_state.latent_state,
+                ponder_steps=next_ponder,
+                stagnation_steps=next_stagnation,
+            ),
+        )
+        unshifted_trace_states = [
+            _slice_rolling_state(next_state, row) for row in range(batch_size)
+        ]
+        if output.history_projected is None or output.working_state is None:
+            raise RuntimeError("Forward did not return working trajectory features.")
+        next_state = self.model._write_committed_memory(
+            previous_history=rolling.history,
+            next_state=next_state,
+            working_state=output.working_state,
+            history_projected=output.history_projected,
+            heavy_hidden=output.heavy_hidden_state,
+            commit_lengths=commit_lengths,
+            prefix_lengths=logical_lengths,
+            commit_reason=infer_commit_reason(
+                commit_lengths,
+                jump_rows=jump_rows,
+                commit_token_ids=commit_token_ids,
+                terminal_token_ids=getattr(
+                    self.model.config, "terminal_token_ids", ()
+                ),
+            ),
+        )
+        shifted = self.model._shift_state_rows(
+            next_state,
+            commit_lengths,
+            self.sampler,
+            generators=generators,
+        )
+        shifted_states = [
+            _slice_rolling_state(shifted, row) for row in range(batch_size)
+        ]
+        selected_confidence = torch.where(
+            jump_rows[:, None], greedy_confidence, proposal_confidence
+        ).float()
+
+        finished_ids = []
+        for row, state in enumerate(states):
+            state.last_step_batch_size = batch_size
+            state.denoise_steps += 1
+            commit_length = int(commit_lengths[row])
+            chunk = commit_token_ids[row, :commit_length].detach().cpu().tolist()
+            state.last_delta_tokens = [int(token_id) for token_id in chunk]
+            before = len(state.generated_tokens)
+            try:
+                self.cache_pool.append(state, chunk)
+            except Exception as error:
+                self._finish(state, "error", error)
+                finished_ids.append(state.request_id)
+                continue
+            state.logical_length += commit_length
+            state.generated_tokens.extend(int(token_id) for token_id in chunk)
+            if self.continuous_batching_config.return_logprobs and commit_length:
+                probabilities = selected_confidence[row, :commit_length].clamp_min(
+                    torch.finfo(torch.float32).tiny
+                )
+                state.logprobs.extend(probabilities.log().detach().cpu().tolist())
+            if state.record_timestamps and commit_length:
+                state.timestamps.extend([time.perf_counter()] * commit_length)
+            if state.repetition_history is not None and commit_length:
+                tokens = commit_token_ids[row : row + 1]
+                eligible = commit_positions[row : row + 1]
+                _add_repetition_history(
+                    state.repetition_history.unsqueeze(0),
+                    tokens,
+                    eligible,
+                    self.excluded_repetition_token_ids,
+                )
+            state.jumps += int(jump_rows[row])
+            if bool(jump_rows[row]):
+                state.forced_jump_tokens += commit_length
+            if commit_length:
+                state.shifts += 1
+            state.rolling_state = shifted_states[row]
+
+            reason = None
+            if self.turn_end_token_id in chunk:
+                reason = "turn_end"
+            elif any(token_id in state.eos_token_ids for token_id in chunk):
+                reason = "eos"
+            elif len(state.generated_tokens) >= state.max_new_tokens:
+                reason = "max_new_tokens"
+            elif (
+                state.max_denoising_steps is not None
+                and state.denoise_steps >= state.max_denoising_steps
+            ):
+                reason = "max_denoising_steps"
+            elif state.denoise_steps >= state.max_iterations:
+                reason = "episode_watchdog"
+
+            elapsed = time.perf_counter() - started
+            if state.trace_callback is not None:
+                trace = build_denoise_trace_event(
+                    denoise_step=state.denoise_steps,
+                    prefix_length=state.logical_length - commit_length,
+                    committed_before=before,
+                    committed_after=len(state.generated_tokens),
+                    no_progress_steps=int(next_stagnation[row]),
+                    policy_prefix_mask=policy_prefix_mask[row : row + 1],
+                    commit_length=commit_length,
+                    ponder_fallback=bool(jump_rows[row]),
+                    state=unshifted_trace_states[row],
+                    proposal=proposal[row : row + 1],
+                    committed_token_ids=commit_token_ids[row : row + 1, :commit_length],
+                    step_elapsed_seconds=elapsed,
+                    latent_residual_diagnostics=None,
+                )
+                trace["request_id"] = state.request_id
+                trace["batch_size"] = batch_size
+                try:
+                    state.trace_callback(trace)
+                except Exception as error:
+                    warnings.warn(
+                        f"Denoise trace callback failed for {state.request_id}: {error!r}",
+                        stacklevel=2,
+                    )
+
+            if reason is not None:
+                self._finish(state, reason)
+                finished_ids.append(state.request_id)
+            elif state.streaming and commit_length:
+                self._deliver(
+                    self._output_for(
+                        state,
+                        stream_update=True,
+                        delta_tokens=state.last_delta_tokens,
+                    )
+                )
+
+        self._stats["model_steps"] += 1
+        self._stats["generated_tokens"] += int(commit_lengths.sum())
+        self._stats["max_observed_batch_size"] = max(
+            self._stats["max_observed_batch_size"], batch_size
+        )
+        self._stats["active_slot_steps"] += batch_size
+        self._stats["slot_capacity_steps"] += self.max_requests_per_batch
+        return finished_ids
+
+    def _run_step_with_isolation(self, states: Sequence[ModilifyMk2RequestState]) -> None:
+        generator_states = {
+            state.request_id: state.generator.get_state()
+            for state in states
+            if state.generator is not None
+        }
+        try:
+            finished_ids = self._run_batch_step(states)
+        except Exception as batch_error:
+            for state in states:
+                if state.generator is not None:
+                    state.generator.set_state(generator_states[state.request_id])
+            if len(states) == 1:
+                self._finish(states[0], "error", batch_error)
+                finished_ids = [states[0].request_id]
+            else:
+                finished_ids = []
+                for state in states:
+                    if state.terminal_emitted:
+                        finished_ids.append(state.request_id)
+                        continue
+                    try:
+                        finished_ids.extend(self._run_batch_step([state]))
+                    except Exception as request_error:
+                        self._finish(state, "error", request_error)
+                        finished_ids.append(state.request_id)
+        with self._condition:
+            for request_id in dict.fromkeys(finished_ids):
+                state = self._active.pop(request_id, None)
+                if state is not None:
+                    self._active_reserved_blocks -= state.reserved_blocks
+            self._condition.notify_all()
+
+    @torch.inference_mode()
+    def _run_generation_loop(self) -> None:
+        try:
+            while True:
+                self._apply_cancellations()
+                if self._hard_stop:
+                    self._apply_cancellations()
+                with self._condition:
+                    has_active = bool(self._active)
+                # ``prefill_first`` fills every available slot before the next
+                # denoise step.  FIFO lets the already-active cohort take its
+                # next step first, then fills slots released by that step.
+                if (
+                    self.continuous_batching_config.scheduler_type == "prefill_first"
+                    or not has_active
+                ):
+                    self._admit_requests()
+                with self._condition:
+                    active = list(self._active.values())
+                    should_finish = (
+                        self._input_closed and not self._pending and not active
+                    )
+                    if should_finish:
+                        return
+                    if not active:
+                        self._condition.wait(timeout=0.05)
+                        continue
+                self._run_step_with_isolation(active)
+                if self.continuous_batching_config.scheduler_type == "fifo":
+                    self._admit_requests()
+        except BaseException as error:
+            self._fail_all_requests(error)
+        finally:
+            self._finished.set()
+            with self._condition:
+                self._condition.notify_all()
+
+
+@torch.inference_mode()
+def generate_static_batch_with_logical_cache(
+    model: Any,
+    input_ids: torch.LongTensor,
+    attention_mask: torch.BoolTensor | None,
+    generation_config: ModilifyMk2GenerationConfig,
+    *,
+    seeds: Sequence[int] | None = None,
+    max_new_tokens: Sequence[int] | None = None,
+) -> ModilifyMk2GenerationOutput:
+    """Run one fixed cohort through the same hole-free continuous engine."""
+
+    batch_size, input_width = input_ids.shape
+    if attention_mask is None:
+        attention_mask = torch.ones_like(input_ids, dtype=torch.bool)
+    else:
+        attention_mask = attention_mask.to(device=input_ids.device, dtype=torch.bool)
+    if attention_mask.shape != input_ids.shape:
+        raise ValueError("`attention_mask` must have the same shape as `input_ids`.")
+    prompts = [
+        input_ids[row, attention_mask[row]].detach().cpu().tolist()
+        for row in range(batch_size)
+    ]
+    if any(not prompt for prompt in prompts):
+        raise ValueError("Every batched ModilifyMk2 prompt must contain at least one token.")
+    if seeds is not None and len(seeds) != batch_size:
+        raise ValueError("`seeds` must contain one seed per batch row.")
+    if max_new_tokens is None:
+        max_new_tokens = [int(generation_config.max_new_tokens)] * batch_size
+    if len(max_new_tokens) != batch_size or any(
+        not isinstance(limit, int) or isinstance(limit, bool) or limit <= 0
+        for limit in max_new_tokens
+    ):
+        raise ValueError("`max_new_tokens` must contain one positive limit per batch row.")
+
+    batching_config = ContinuousBatchingConfig(
+        block_size=max(4, int(getattr(model.config, "kv_cache_bucket_size", 128))),
+        max_batch_tokens=batch_size * int(model.config.canvas_length),
+        max_requests_per_batch=batch_size,
+        allow_block_sharing=False,
+        scheduler_type="prefill_first",
+    )
+    manager = ModilifyMk2ContinuousBatchingManager(
+        model=model,
+        generation_config=generation_config,
+        continuous_batching_config=batching_config,
+    )
+    try:
+        request_ids = []
+        for row, prompt in enumerate(prompts):
+            request_kwargs = {}
+            if seeds is not None:
+                request_kwargs["seed"] = int(seeds[row])
+            request_ids.append(
+                manager.add_request(
+                    prompt,
+                    request_id=f"static_{row}",
+                    max_new_tokens=int(max_new_tokens[row]),
+                    streaming=False,
+                    max_denoising_steps=generation_config.max_denoising_steps,
+                    eos_token_id=generation_config.eos_token_id,
+                    **request_kwargs,
+                )
+            )
+        manager.close_input()
+        # A static batch is one fixed cohort: queue every row before the worker
+        # starts so its first heavy forward necessarily contains the full batch.
+        manager.start()
+        final = {}
+        for output in manager:
+            if output.is_finished():
+                final[output.request_id] = output
+        ordered = [final[request_id] for request_id in request_ids]
+    finally:
+        manager.stop(block=True, hard_stop=True)
+        manager.destroy()
+    failures = [output for output in ordered if output.error is not None]
+    if failures:
+        details = "; ".join(
+            f"{output.request_id}: {output.error}" for output in failures
+        )
+        raise RuntimeError(f"Static ModilifyMk2 batch generation failed: {details}")
+
+    lengths = torch.tensor(
+        [len(output.generated_tokens) for output in ordered],
+        device=input_ids.device,
+        dtype=torch.long,
+    )
+    output_width = int(lengths.max()) if lengths.numel() else 0
+    pad_token_id = generation_config.pad_token_id
+    if isinstance(pad_token_id, (list, tuple)):
+        pad_token_id = pad_token_id[0]
+    pad_token_id = int(0 if pad_token_id is None else pad_token_id)
+    generated = torch.full(
+        (batch_size, output_width),
+        pad_token_id,
+        device=input_ids.device,
+        dtype=input_ids.dtype,
+    )
+    for row, output in enumerate(ordered):
+        if output.generated_tokens:
+            generated[row, : len(output.generated_tokens)] = torch.tensor(
+                output.generated_tokens,
+                device=input_ids.device,
+                dtype=input_ids.dtype,
+            )
+
+    def tensor(name: str, *, dtype: torch.dtype) -> torch.Tensor:
+        return torch.tensor(
+            [getattr(output, name) for output in ordered],
+            device=input_ids.device,
+            dtype=dtype,
+        )
+
+    return ModilifyMk2GenerationOutput(
+        sequences=torch.cat((input_ids, generated), dim=-1),
+        generated_lengths=lengths,
+        tokens_per_forward=tensor("tokens_per_forward", dtype=torch.float32),
+        past_key_values=None,
+        stop_reason=tuple(output.stop_reason for output in ordered),
+        committed_tokens=lengths.clone(),
+        denoise_steps=tensor("denoise_steps", dtype=torch.long),
+        no_progress_steps=tensor("no_progress_steps", dtype=torch.long),
+        jump_count=tensor("jump_count", dtype=torch.long),
+        forced_jump_bad_count=tensor("forced_jump_bad_count", dtype=torch.long),
+        heavy_forward_count=tensor("heavy_forward_count", dtype=torch.long),
+        latent_context_update_count=tensor(
+            "latent_context_update_count", dtype=torch.long
+        ),
+        average_commit_len=tensor("average_commit_len", dtype=torch.float32),
+        state_shift_count=tensor("state_shift_count", dtype=torch.long),
+        latent_memory_norm=tensor("latent_memory_norm", dtype=torch.float32),
+        state_retention_score=tensor("state_retention_score", dtype=torch.float32),
+    )
+
+
+__all__ = [
+    "ModilifyMk2ContinuousBatchingManager",
+    "ModilifyMk2ContinuousGenerationOutput",
+    "ModilifyMk2LogicalCachePool",
+    "ModilifyMk2RequestState",
+    "continuous_config_fingerprint",
+    "generate_static_batch_with_logical_cache",
+]

generation_config.json

@@ -0,0 +1,24 @@
+{
+  "commit_failure_budget": 0.2,
+  "confidence_threshold": null,
+  "denoise_temperature": 0.8,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "jump_failure_budget": 2.0,
+  "jump_on_no_progress_after": 12,
+  "max_denoising_steps": null,
+  "max_new_tokens": 256,
+  "max_ponder_steps": 64,
+  "min_trajectory_progress": 0.005,
+  "repetition_penalty": 1.0,
+  "repetition_penalty_exclude_token_ids": [],
+  "return_dict_in_generate": true,
+  "sampler_config": null,
+  "stability_threshold": null,
+  "t_max": 0.8,
+  "t_min": 0.8,
+  "transformers_version": "5.14.1",
+  "turn_end_token_id": 106
+}

generation_modilify_mk2.py

@@ -0,0 +1,1455 @@
+# Copyright 2026 Modilify
+# SPDX-License-Identifier: LicenseRef-Modilify-Open-Model-1.0
+"""Rolling generation for latent-memory Modilify Mk2."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass, replace
+import math
+import time
+from typing import Any
+
+import torch
+from transformers.cache_utils import Cache
+from transformers.generation import LogitsProcessorList
+from transformers.generation.streamers import BaseStreamer
+from transformers.modeling_outputs import ModelOutput
+
+from transformers.models.diffusion_gemma import (
+    DiffusionGemmaGenerationConfig,
+    DiffusionGemmaGenerationMixin,
+)
+from .commit_policy import (
+    first_committed_token_lengths,
+    fused_commit_failure_rate,
+    select_commit_lengths,
+)
+from .configuration_modilify_mk2 import (
+    COMMIT_FAILURE_BUDGET,
+    DENOISE_TEMPERATURE,
+    JUMP_FAILURE_BUDGET,
+)
+from .latent_deliberation import (
+    LatentDeliberationState,
+    TrajectoryHistory,
+    TrajectoryTape,
+    choose_trajectory_history,
+    choose_trajectory_tape,
+    empty_trajectory_tape,
+    infer_commit_reason,
+)
+
+
+_PARENT_GENERATION_KEYS = frozenset({
+    "max_new_tokens",
+    "max_length",
+    "return_dict_in_generate",
+    "max_denoising_steps",
+    "sampler_config",
+    "t_min",
+    "t_max",
+    "stability_threshold",
+    "confidence_threshold",
+    "cache_implementation",
+    "cache_config",
+    "disable_compile",
+    "bos_token_id",
+    "pad_token_id",
+    "eos_token_id",
+    "_commit_hash",
+    "_from_model_config",
+    "transformers_version",
+})
+_IGNORED_GENERATION_KEYS = frozenset({
+    "compile_generation",
+    "sliding_denoise",
+    "one_token_per_denoise_step",
+    "adaptive_ponder_budget",
+    "force_commit_on_max_steps",
+    "ponder_budget_id",
+})
+_FORBIDDEN_COMMIT_FIELDS = (
+    "sampler_config",
+    "stability_threshold",
+    "confidence_threshold",
+    "one_token_per_denoise_step",
+)
+
+
+def _reject_legacy_commit_fields(fields: dict[str, object]) -> None:
+    configured = {
+        name: value
+        for name, value in fields.items()
+        if value not in (None, False)
+    }
+    if configured:
+        raise ValueError(
+            "ModilifyMk2 accepts only the confidence-prefix commit policy; "
+            f"unsupported generation fields: {sorted(configured)}"
+        )
+
+
+def _flatten_token_ids(*values: object) -> set[int]:
+    """Normalize scalar and sequence token-ID configuration values."""
+
+    token_ids: set[int] = set()
+    for value in values:
+        if value is None:
+            continue
+        if isinstance(value, int):
+            token_ids.add(int(value))
+            continue
+        if isinstance(value, (list, tuple, set)):
+            token_ids.update(int(token_id) for token_id in value if token_id is not None)
+    return token_ids
+
+
+def _add_repetition_history(
+    history: torch.BoolTensor,
+    token_ids: torch.LongTensor,
+    eligible: torch.BoolTensor,
+    excluded_token_ids: set[int],
+) -> None:
+    """Add eligible row-local token IDs to a compact [batch, vocab] history."""
+
+    if token_ids.shape != eligible.shape or token_ids.shape[0] != history.shape[0]:
+        raise ValueError("Repetition history token and eligibility shapes must match.")
+    eligible = eligible.clone()
+    for token_id in excluded_token_ids:
+        eligible &= token_ids.ne(token_id)
+    if not bool(eligible.any()):
+        return
+    rows = torch.arange(history.shape[0], device=history.device)[:, None]
+    rows = rows.expand_as(token_ids)
+    history[rows[eligible], token_ids[eligible]] = True
+
+
+class ModilifyMk2GenerationConfig(DiffusionGemmaGenerationConfig):
+    def __init__(self, **kwargs):
+        _reject_legacy_commit_fields({
+            name: kwargs.pop(name)
+            for name in _FORBIDDEN_COMMIT_FIELDS
+            if name in kwargs
+        })
+        self.turn_end_token_id: int | None = kwargs.pop("turn_end_token_id", None)
+        self.denoise_temperature: float = float(
+            kwargs.pop("denoise_temperature", DENOISE_TEMPERATURE)
+        )
+        self.commit_failure_budget: float = float(
+            kwargs.pop("commit_failure_budget", COMMIT_FAILURE_BUDGET)
+        )
+        self.jump_failure_budget: float = float(
+            kwargs.pop("jump_failure_budget", JUMP_FAILURE_BUDGET)
+        )
+        self.max_ponder_steps: int = kwargs.pop("max_ponder_steps", 64)
+        self.jump_on_no_progress_after: int = kwargs.pop("jump_on_no_progress_after", 12)
+        self.min_trajectory_progress: float = float(kwargs.pop("min_trajectory_progress", 0.005))
+        self.repetition_penalty: float = float(kwargs.pop("repetition_penalty", 1.0))
+        excluded_token_ids = kwargs.pop("repetition_penalty_exclude_token_ids", ())
+        self.repetition_penalty_exclude_token_ids: list[int] = list(
+            dict.fromkeys(int(token_id) for token_id in excluded_token_ids or ())
+        )
+        for name in _IGNORED_GENERATION_KEYS:
+            kwargs.pop(name, None)
+        kwargs.pop("t_min", None)
+        kwargs.pop("t_max", None)
+        parent_kwargs = {
+            name: kwargs.pop(name)
+            for name in tuple(kwargs)
+            if name in _PARENT_GENERATION_KEYS
+        }
+        super().__init__(
+            sampler_config=None,
+            stability_threshold=None,
+            confidence_threshold=None,
+            **parent_kwargs,
+        )
+        self.t_min = self.denoise_temperature
+        self.t_max = self.denoise_temperature
+        self.validate()
+
+    def update(self, defaults_only=False, allow_custom_entries=False, **kwargs):
+        """Apply supported overrides, including temperature and failure budget."""
+
+        _reject_legacy_commit_fields({
+            name: kwargs.pop(name)
+            for name in _FORBIDDEN_COMMIT_FIELDS
+            if name in kwargs
+        })
+        if "turn_end_token_id" in kwargs:
+            self.turn_end_token_id = kwargs.pop("turn_end_token_id")
+        if "denoise_temperature" in kwargs:
+            self.denoise_temperature = float(kwargs.pop("denoise_temperature"))
+        if "commit_failure_budget" in kwargs:
+            self.commit_failure_budget = float(kwargs.pop("commit_failure_budget"))
+        if "jump_failure_budget" in kwargs:
+            self.jump_failure_budget = float(kwargs.pop("jump_failure_budget"))
+        if "max_ponder_steps" in kwargs:
+            self.max_ponder_steps = kwargs.pop("max_ponder_steps")
+        if "jump_on_no_progress_after" in kwargs:
+            self.jump_on_no_progress_after = kwargs.pop("jump_on_no_progress_after")
+        if "min_trajectory_progress" in kwargs:
+            self.min_trajectory_progress = float(kwargs.pop("min_trajectory_progress"))
+        if "repetition_penalty" in kwargs:
+            self.repetition_penalty = float(kwargs.pop("repetition_penalty"))
+        if "repetition_penalty_exclude_token_ids" in kwargs:
+            excluded_token_ids = kwargs.pop("repetition_penalty_exclude_token_ids")
+            self.repetition_penalty_exclude_token_ids = list(
+                dict.fromkeys(int(token_id) for token_id in excluded_token_ids or ())
+            )
+        for name in _IGNORED_GENERATION_KEYS:
+            kwargs.pop(name, None)
+        kwargs.pop("t_min", None)
+        kwargs.pop("t_max", None)
+        unused = super().update(
+            defaults_only=defaults_only,
+            allow_custom_entries=allow_custom_entries,
+            **kwargs,
+        )
+        self.sampler_config = None
+        self.stability_threshold = None
+        self.confidence_threshold = None
+        self.t_min = self.denoise_temperature
+        self.t_max = self.denoise_temperature
+        return unused
+
+    def validate(self, **kwargs):
+        if self.max_new_tokens is not None and (
+            not isinstance(self.max_new_tokens, int) or self.max_new_tokens <= 0
+        ):
+            raise ValueError(f"`max_new_tokens` must be a positive integer, but got {self.max_new_tokens}")
+        if self.max_length is not None and (
+            not isinstance(self.max_length, int) or self.max_length <= 0
+        ):
+            raise ValueError(f"`max_length` must be a positive integer, but got {self.max_length}")
+        if self.turn_end_token_id is not None and (
+            not isinstance(self.turn_end_token_id, int) or self.turn_end_token_id < 0
+        ):
+            raise ValueError("`turn_end_token_id` must be a non-negative integer.")
+        if not isinstance(self.max_ponder_steps, int) or self.max_ponder_steps <= 0:
+            raise ValueError("`max_ponder_steps` must be a positive integer.")
+        if not isinstance(self.jump_on_no_progress_after, int) or self.jump_on_no_progress_after <= 0:
+            raise ValueError("`jump_on_no_progress_after` must be a positive integer.")
+        if not isinstance(self.min_trajectory_progress, (int, float)) or self.min_trajectory_progress < 0:
+            raise ValueError("`min_trajectory_progress` must be a non-negative number.")
+        if not math.isfinite(self.denoise_temperature) or self.denoise_temperature <= 0:
+            raise ValueError("`denoise_temperature` must be positive.")
+        if not math.isfinite(self.commit_failure_budget) or self.commit_failure_budget <= 0:
+            raise ValueError("`commit_failure_budget` must be positive.")
+        if not math.isfinite(self.jump_failure_budget) or self.jump_failure_budget <= 0:
+            raise ValueError("`jump_failure_budget` must be positive.")
+        if not math.isfinite(self.repetition_penalty) or self.repetition_penalty <= 0:
+            raise ValueError("`repetition_penalty` must be a finite positive number.")
+        if any(
+            not isinstance(token_id, int) or isinstance(token_id, bool) or token_id < 0
+            for token_id in self.repetition_penalty_exclude_token_ids
+        ):
+            raise ValueError(
+                "`repetition_penalty_exclude_token_ids` must contain non-negative integers."
+            )
+
+    @classmethod
+    def from_model_config(cls, model_config):
+        """Build generation defaults from a model configuration."""
+
+        return cls(
+            turn_end_token_id=model_config.turn_end_token_id,
+            denoise_temperature=getattr(
+                model_config, "denoise_temperature", DENOISE_TEMPERATURE
+            ),
+            commit_failure_budget=getattr(
+                model_config, "commit_failure_budget", COMMIT_FAILURE_BUDGET
+            ),
+            jump_failure_budget=getattr(
+                model_config, "jump_failure_budget", JUMP_FAILURE_BUDGET
+            ),
+            max_ponder_steps=getattr(model_config, "max_ponder_steps", 64),
+            jump_on_no_progress_after=getattr(
+                model_config, "jump_on_no_progress_after", 12
+            ),
+            min_trajectory_progress=getattr(
+                model_config, "min_trajectory_progress", 0.005
+            ),
+            repetition_penalty=getattr(model_config, "repetition_penalty", 1.0),
+            eos_token_id=getattr(
+                model_config,
+                "eos_token_id",
+                model_config.text_config.eos_token_id,
+            ),
+        )
+
+    @staticmethod
+    def _get_default_generation_params() -> dict[str, object]:
+        """Return defaults with no inherited entropy/readiness commit controls."""
+
+        return {
+            "max_new_tokens": 256,
+            "max_denoising_steps": 48,
+            "t_min": DENOISE_TEMPERATURE,
+            "t_max": DENOISE_TEMPERATURE,
+        }
+
+
+def deterministic_episode_iteration_bound(
+    response_lengths: torch.LongTensor,
+    *,
+    max_ponder_steps: int,
+) -> int:
+    """Return a safe watchdog bound without assuming canvas-sized jumps."""
+
+    if response_lengths.numel() == 0:
+        raise ValueError("`response_lengths` must be non-empty.")
+    if max_ponder_steps <= 0:
+        raise ValueError("`max_ponder_steps` must be positive.")
+    return max(1, int(response_lengths.max()) * max_ponder_steps)
+
+
+@dataclass
+class ModilifyMk2GenerationOutput(ModelOutput):
+    sequences: torch.LongTensor
+    generated_lengths: torch.LongTensor | None = None
+    tokens_per_forward: torch.FloatTensor | None = None
+    past_key_values: Cache | None = None
+    stop_reason: str | tuple[str, ...] | None = None
+    committed_tokens: int | torch.LongTensor | None = None
+    denoise_steps: int | torch.LongTensor | None = None
+    no_progress_steps: int | torch.LongTensor | None = None
+    jump_count: int | torch.LongTensor | None = None
+    forced_jump_bad_count: int | torch.LongTensor | None = None
+    heavy_forward_count: int | torch.LongTensor | None = None
+    latent_context_update_count: int | torch.LongTensor | None = None
+    average_commit_len: float | torch.FloatTensor | None = None
+    state_shift_count: int | torch.LongTensor | None = None
+    latent_memory_norm: float | torch.FloatTensor | None = None
+    state_retention_score: float | torch.FloatTensor | None = None
+    logits: None = None
+    scores: None = None
+    hidden_states: None = None
+
+
+@dataclass
+class ModilifyMk2RollingState:
+    """All real iterative state; no vocabulary-sized tensor is retained."""
+
+    canvas: torch.LongTensor
+    confidence: torch.FloatTensor
+    entropy: torch.FloatTensor
+    age: torch.IntTensor
+    latent_state: LatentDeliberationState
+    history: TrajectoryHistory
+    tape: TrajectoryTape
+
+
+def qualified_single_turn_end_lengths(
+    token_ids: torch.LongTensor,
+    qualified_mask: torch.BoolTensor,
+    turn_end_token_id: int,
+) -> torch.LongTensor:
+    if token_ids.ndim != 2 or token_ids.shape != qualified_mask.shape:
+        raise ValueError("Token IDs and qualification mask must share shape [batch, canvas].")
+    qualified_prefix = qualified_mask.long().cumprod(dim=1).sum(dim=-1)
+    clipped = first_committed_token_lengths(
+        token_ids,
+        qualified_prefix,
+        turn_end_token_id,
+    )
+    found = clipped.lt(qualified_prefix)
+    boundary_is_turn = token_ids.gather(
+        1,
+        clipped.clamp_min(1).sub(1)[:, None],
+    ).squeeze(1).eq(turn_end_token_id)
+    return torch.where(
+        found | boundary_is_turn,
+        clipped,
+        torch.zeros_like(clipped),
+    )
+
+
+def _prefix_length(prefix_mask: torch.BoolTensor) -> int:
+    common = prefix_mask.all(dim=0)
+    rejected = (~common).nonzero(as_tuple=False)
+    return common.shape[0] if rejected.numel() == 0 else int(rejected[0, 0])
+
+
+def _tensor_stats(value: torch.Tensor) -> dict[str, float]:
+    data = value.detach().float()
+    return {
+        "min": float(data.min()), "max": float(data.max()),
+        "mean": float(data.mean()), "norm": float(data.norm()),
+    }
+
+
+def _memory_diversity_stats(memory_slots: torch.Tensor) -> dict[str, float]:
+    """Trace-only collapse diagnostics; the pairwise term is tiny (32 slots)."""
+
+    memory = memory_slots.detach().float()
+    centered = memory - memory.mean(dim=1, keepdim=True)
+    maximum_difference = (
+        (memory[:, 1:] - memory[:, :-1]).abs().amax()
+        if memory.shape[1] > 1 else memory.new_zeros(())
+    )
+    normalized = torch.nn.functional.normalize(memory, dim=-1, eps=1.0e-6)
+    pairwise = normalized @ normalized.transpose(-1, -2)
+    off_diagonal = ~torch.eye(memory.shape[1], device=memory.device, dtype=torch.bool)
+    return {
+        "memory_slot_std": float(centered.square().mean().sqrt()),
+        "memory_slot_max_difference": float(maximum_difference),
+        "memory_slot_pairwise_cosine_mean": float(pairwise[:, off_diagonal].mean()),
+    }
+
+
+def build_denoise_trace_event(
+    *,
+    denoise_step: int,
+    prefix_length: int,
+    committed_before: int,
+    committed_after: int,
+    no_progress_steps: int,
+    policy_prefix_mask: torch.BoolTensor,
+    commit_length: int,
+    ponder_fallback: bool,
+    state: ModilifyMk2RollingState,
+    proposal: torch.LongTensor,
+    committed_token_ids: torch.LongTensor,
+    step_elapsed_seconds: float,
+    latent_residual_diagnostics: dict[str, torch.Tensor] | None = None,
+) -> dict[str, object]:
+    return {
+        "event": "denoise_step",
+        "denoise_step": denoise_step,
+        "prefix_length": prefix_length,
+        "committed_before": committed_before,
+        "committed_after": committed_after,
+        "no_progress_steps": no_progress_steps,
+        "policy_prefix_count": int(policy_prefix_mask.sum()),
+        "policy_prefix_length": _prefix_length(policy_prefix_mask),
+        "commit_length": commit_length,
+        "ponder_fallback": bool(ponder_fallback),
+        "confidence": _tensor_stats(state.confidence),
+        "entropy": _tensor_stats(state.entropy),
+        "age": _tensor_stats(state.age),
+        "token_changed": _tensor_stats(state.latent_state.token_changed),
+        "confidence_delta": _tensor_stats(state.latent_state.confidence_delta),
+        "entropy_delta": _tensor_stats(state.latent_state.entropy_delta),
+        "ponder_steps": int(state.latent_state.ponder_steps[0]),
+        "stagnation_steps": int(state.latent_state.stagnation_steps[0]),
+        "history_fill": float(state.history.valid[0].float().mean()),
+        "memory_slots": _tensor_stats(state.latent_state.memory_slots),
+        "memory_diversity": _memory_diversity_stats(state.latent_state.memory_slots),
+        "latent_residual": {
+            name: float(value.detach().float())
+            for name, value in (latent_residual_diagnostics or {}).items()
+        },
+        "proposal_token_ids": proposal[0].detach().cpu().tolist(),
+        "draft_token_ids": state.canvas[0].detach().cpu().tolist(),
+        "committed_token_ids": committed_token_ids[0].detach().cpu().tolist(),
+        "step_elapsed_seconds": step_elapsed_seconds,
+    }
+
+
+class NoiseCanvasSampler:
+    """Uniform diffusion noise source with no commit-policy responsibilities."""
+
+    def __init__(self, *, canvas_length: int, vocab_size: int) -> None:
+        self.canvas_length = int(canvas_length)
+        self.vocab_size = int(vocab_size)
+        self.initial_entropy = math.log(self.vocab_size)
+
+    def initialize_canvas(
+        self,
+        batch_size: int,
+        device: torch.device,
+        generators: Sequence[torch.Generator] | None = None,
+    ) -> torch.LongTensor:
+        if generators is not None:
+            if len(generators) != batch_size:
+                raise ValueError("Canvas sampling requires one generator per batch row.")
+            return torch.cat(
+                [
+                    torch.randint(
+                        self.vocab_size,
+                        (1, self.canvas_length),
+                        device=device,
+                        generator=generator,
+                    )
+                    for generator in generators
+                ],
+                dim=0,
+            )
+        return torch.randint(
+            self.vocab_size,
+            (batch_size, self.canvas_length),
+            device=device,
+        )
+
+
+class ModilifyMk2GenerationMixin(DiffusionGemmaGenerationMixin):
+    def init_continuous_batching(
+        self,
+        generation_config=None,
+        continuous_batching_config=None,
+        workload_hints=None,
+    ):
+        """Create the ModilifyMk2 continuous manager behind the official API surface."""
+
+        from .continuous_batching import (
+            ModilifyMk2ContinuousBatchingManager,
+            continuous_config_fingerprint,
+        )
+
+        cached = getattr(self, "_cached_continuous_batching_manager", None)
+        if isinstance(cached, ModilifyMk2ContinuousBatchingManager) and not cached.destroyed:
+            requested_generation = generation_config or getattr(
+                self, "generation_config", None
+            )
+            requested_fingerprint = continuous_config_fingerprint(
+                requested_generation,
+                continuous_batching_config,
+            )
+            if cached.config_fingerprint == requested_fingerprint:
+                cached._prepare_for_next_session()
+                return cached
+            cached.destroy()
+            delattr(self, "_cached_continuous_batching_manager")
+        return ModilifyMk2ContinuousBatchingManager(
+            model=self,
+            generation_config=generation_config or getattr(self, "generation_config", None),
+            continuous_batching_config=continuous_batching_config,
+            workload_hints=workload_hints,
+        )
+
+    def destroy_cached_continuous_batching_manager(self) -> None:
+        manager = getattr(self, "_cached_continuous_batching_manager", None)
+        if manager is not None:
+            manager.destroy()
+            delattr(self, "_cached_continuous_batching_manager")
+
+    @contextmanager
+    @torch.no_grad()
+    def continuous_batching_context_manager(
+        self,
+        generation_config=None,
+        block: bool = True,
+        timeout: float | None = None,
+        continuous_batching_config=None,
+        persistent_manager: bool = False,
+        warmup: bool = True,
+        workload_hints=None,
+    ):
+        manager = self.init_continuous_batching(
+            generation_config=generation_config,
+            continuous_batching_config=continuous_batching_config,
+            workload_hints=workload_hints,
+        )
+        if persistent_manager:
+            self._cached_continuous_batching_manager = manager
+        if warmup and not manager.warmed_up:
+            manager.warmup()
+        manager.start()
+        try:
+            yield manager
+        finally:
+            manager.stop(
+                block=block,
+                timeout=timeout,
+                keep_for_next_session=persistent_manager,
+            )
+            if not persistent_manager:
+                manager.destroy()
+
+    @torch.no_grad()
+    def generate_batch(
+        self,
+        inputs: list[list[int]],
+        generation_config=None,
+        continuous_batching_config=None,
+        record_timestamps: bool = False,
+        progress_bar: bool = True,
+        persistent_manager: bool = False,
+        warmup: bool = True,
+        **kwargs: Any,
+    ) -> dict[str, object]:
+        """Official-compatible convenience wrapper over the continuous manager."""
+
+        del progress_bar
+        if any(
+            not isinstance(input_ids, list)
+            or not input_ids
+            or any(
+                not isinstance(token_id, int) or isinstance(token_id, bool)
+                for token_id in input_ids
+            )
+            for input_ids in inputs
+        ):
+            raise ValueError("Every `inputs` row must be a non-empty list of integer token IDs.")
+        seeds = kwargs.pop("seeds", None)
+        if seeds is not None and len(seeds) != len(inputs):
+            raise ValueError("`seeds` must contain one seed per request.")
+        if seeds is not None:
+            seeds = [int(seed) for seed in seeds]
+        if not inputs:
+            return {}
+        manager = self.init_continuous_batching(
+            generation_config=generation_config,
+            continuous_batching_config=continuous_batching_config,
+        )
+        if persistent_manager:
+            self._cached_continuous_batching_manager = manager
+        if warmup and not manager.warmed_up:
+            manager.warmup()
+        completed = False
+        try:
+            request_ids = []
+            queue_limit = int(
+                manager.continuous_batching_config.max_queue_size or 0
+            )
+            preload_count = (
+                len(inputs) if queue_limit == 0 else min(len(inputs), queue_limit)
+            )
+            for index, input_ids in enumerate(inputs):
+                if index == preload_count and not manager.is_running():
+                    manager.start()
+                request_kwargs = dict(kwargs)
+                if seeds is not None:
+                    request_kwargs["seed"] = int(seeds[index])
+                request_ids.append(
+                    manager.add_request(
+                        input_ids=input_ids,
+                        record_timestamps=record_timestamps,
+                        **request_kwargs,
+                    )
+                )
+            manager.close_input()
+            # Unlike the open-ended manager API, generate_batch has its whole
+            # initial workload. Queue it before starting so the first cohort is
+            # filled deterministically up to scheduler/queue capacity.
+            if not manager.is_running():
+                manager.start()
+            final_outputs = {}
+            for output in manager:
+                if output.status in {
+                    getattr(output.status.__class__, "FINISHED", output.status),
+                    getattr(output.status.__class__, "FAILED", output.status),
+                }:
+                    final_outputs[output.request_id] = output
+            result = {
+                request_id: final_outputs[request_id]
+                for request_id in request_ids
+                if request_id is not None
+            }
+            completed = True
+        finally:
+            manager.stop(
+                block=True,
+                keep_for_next_session=persistent_manager,
+                hard_stop=not completed,
+            )
+            if not persistent_manager:
+                manager.destroy()
+        return result
+
+    def _prepare_sampler(
+        self, generation_config: ModilifyMk2GenerationConfig, canvas_length: int | None = None
+    ) -> NoiseCanvasSampler:
+        del generation_config
+        return NoiseCanvasSampler(
+            canvas_length=canvas_length or self.config.canvas_length,
+            vocab_size=self.config.text_config.vocab_size,
+        )
+
+    @staticmethod
+    def _shift_state(
+        state: ModilifyMk2RollingState,
+        commit_length: int,
+        sampler: NoiseCanvasSampler,
+        **_: object,
+    ) -> ModilifyMk2RollingState:
+        if commit_length == 0:
+            return state
+        canvas_length = state.canvas.shape[1]
+        if not 0 < commit_length <= canvas_length:
+            raise ValueError(f"`commit_length` must be in [1, {canvas_length}].")
+        tail = sampler.initialize_canvas(state.canvas.shape[0], state.canvas.device)[:, :commit_length]
+        canvas = torch.cat((state.canvas[:, commit_length:], tail), dim=1)
+
+        def shift(value: torch.Tensor | None, fill_value: float | int = 0) -> torch.Tensor | None:
+            if value is None:
+                return None
+            tail_state = torch.full(
+                (value.shape[0], commit_length, *value.shape[2:]),
+                fill_value, device=value.device, dtype=value.dtype,
+            )
+            return torch.cat((value[:, commit_length:], tail_state), dim=1)
+
+        if hasattr(sampler, "initial_entropy"):
+            unknown_entropy = float(sampler.initial_entropy)
+        elif hasattr(sampler, "vocab_size"):
+            unknown_entropy = math.log(sampler.vocab_size)
+        else:
+            unknown_entropy = float(state.entropy.max())
+
+        return ModilifyMk2RollingState(
+            canvas=canvas,
+            confidence=shift(state.confidence),
+            entropy=shift(state.entropy, unknown_entropy),
+            age=shift(state.age),
+            latent_state=state.latent_state.shift(
+                commit_length, entropy_fill_value=unknown_entropy
+            ),
+            history=state.history.shift(commit_length, entropy_fill_value=unknown_entropy),
+            tape=state.tape,
+        )
+
+    @staticmethod
+    def _merge_state_rows(
+        previous: ModilifyMk2RollingState,
+        updated: ModilifyMk2RollingState,
+        update_mask: torch.BoolTensor,
+    ) -> ModilifyMk2RollingState:
+        """Keep inactive batch rows bit-identical while active rows advance."""
+
+        def choose(old: torch.Tensor, new: torch.Tensor) -> torch.Tensor:
+            mask = update_mask.view(update_mask.shape[0], *([1] * (old.ndim - 1)))
+            return torch.where(mask, new, old)
+
+        old_latent = previous.latent_state
+        new_latent = updated.latent_state
+        latent = LatentDeliberationState(
+            memory_slots=choose(old_latent.memory_slots, new_latent.memory_slots),
+            confidence=choose(old_latent.confidence, new_latent.confidence),
+            entropy=choose(old_latent.entropy, new_latent.entropy),
+            age=choose(old_latent.age, new_latent.age),
+            token_changed=choose(old_latent.token_changed, new_latent.token_changed),
+            confidence_delta=choose(old_latent.confidence_delta, new_latent.confidence_delta),
+            entropy_delta=choose(old_latent.entropy_delta, new_latent.entropy_delta),
+            ponder_steps=choose(old_latent.ponder_steps, new_latent.ponder_steps),
+            stagnation_steps=choose(old_latent.stagnation_steps, new_latent.stagnation_steps),
+        )
+        return ModilifyMk2RollingState(
+            canvas=choose(previous.canvas, updated.canvas),
+            confidence=choose(previous.confidence, updated.confidence),
+            entropy=choose(previous.entropy, updated.entropy),
+            age=choose(previous.age, updated.age),
+            latent_state=latent,
+            history=choose_trajectory_history(
+                previous.history, updated.history, update_mask
+            ),
+            tape=choose_trajectory_tape(previous.tape, updated.tape, update_mask),
+        )
+
+    def _write_committed_memory(
+        self,
+        *,
+        previous_history: TrajectoryHistory,
+        next_state: ModilifyMk2RollingState,
+        working_state: torch.Tensor,
+        history_projected: torch.Tensor,
+        heavy_hidden: torch.Tensor,
+        commit_lengths: torch.Tensor,
+        prefix_lengths: torch.Tensor,
+        commit_reason: torch.Tensor,
+        **kwargs: Any,
+    ) -> ModilifyMk2RollingState:
+        if not bool(commit_lengths.gt(0).any()):
+            return next_state
+        memory, _diagnostics = self.latent_deliberation.commit_write(
+            memory=next_state.latent_state.memory_slots,
+            working_state=working_state,
+            history=previous_history,
+            history_projected=history_projected,
+            heavy_hidden=heavy_hidden,
+            commit_lengths=commit_lengths,
+            prefix_lengths=prefix_lengths,
+            commit_reason=commit_reason,
+        )
+        return replace(
+            next_state,
+            latent_state=replace(next_state.latent_state, memory_slots=memory),
+        )
+
+    @staticmethod
+    def _shift_state_rows(
+        state: ModilifyMk2RollingState,
+        commit_lengths: torch.LongTensor,
+        sampler: NoiseCanvasSampler,
+        generators: Sequence[torch.Generator] | None = None,
+    ) -> ModilifyMk2RollingState:
+        """Shift every rolling row by its own committed prefix length."""
+
+        batch_size, canvas_length = state.canvas.shape
+        if commit_lengths.shape != (batch_size,):
+            raise ValueError("Commit lengths must have shape [batch].")
+        if not bool(commit_lengths.gt(0).any()):
+            if generators is not None:
+                if len(generators) != batch_size:
+                    raise ValueError("State shifting requires one generator per batch row.")
+                # Seeded generation deliberately advances every active request
+                # once per denoise step, independent of the other active rows.
+                for generator in generators:
+                    try:
+                        sampler.initialize_canvas(
+                            1, state.canvas.device, generators=[generator]
+                        )
+                    except TypeError:
+                        sampler.initialize_canvas(1, state.canvas.device)
+            return state
+        positions = torch.arange(canvas_length, device=state.canvas.device)[None, :]
+        source = positions + commit_lengths[:, None]
+        retained = source.lt(canvas_length)
+
+        def shift(value: torch.Tensor, fill_value: float | int = 0) -> torch.Tensor:
+            index = source.clamp_max(canvas_length - 1)
+            index = index.view(
+                batch_size, canvas_length, *([1] * (value.ndim - 2))
+            ).expand_as(value)
+            gathered = value.gather(1, index)
+            mask = retained.view(
+                batch_size, canvas_length, *([1] * (value.ndim - 2))
+            )
+            fill = torch.as_tensor(fill_value, device=value.device, dtype=value.dtype)
+            return torch.where(mask, gathered, fill)
+
+        if generators is None:
+            tail = sampler.initialize_canvas(batch_size, state.canvas.device)
+        else:
+            if len(generators) != batch_size:
+                raise ValueError("State shifting requires one generator per batch row.")
+            tail = torch.zeros_like(state.canvas)
+            for row, (commit_length, generator) in enumerate(
+                zip(commit_lengths.detach().cpu().tolist(), generators, strict=True)
+            ):
+                try:
+                    sampled = sampler.initialize_canvas(
+                        1,
+                        state.canvas.device,
+                        generators=[generator],
+                    )
+                except TypeError:
+                    # Preserve compatibility with deterministic test/custom
+                    # samplers written before per-request RNG was introduced.
+                    sampled = sampler.initialize_canvas(1, state.canvas.device)
+                tail[row] = sampled[0]
+        canvas = torch.cat((state.canvas, tail), dim=1).gather(1, source)
+        unknown_entropy = float(sampler.initial_entropy)
+        latent = state.latent_state
+        committed = commit_lengths.gt(0)
+        shifted_latent = LatentDeliberationState(
+            memory_slots=latent.memory_slots.clone(),
+            confidence=shift(latent.confidence),
+            entropy=shift(latent.entropy, unknown_entropy),
+            age=shift(latent.age),
+            token_changed=shift(latent.token_changed),
+            confidence_delta=shift(latent.confidence_delta),
+            entropy_delta=shift(latent.entropy_delta),
+            ponder_steps=torch.where(
+                committed, torch.zeros_like(latent.ponder_steps), latent.ponder_steps
+            ),
+            stagnation_steps=torch.where(
+                committed, torch.zeros_like(latent.stagnation_steps), latent.stagnation_steps
+            ),
+        )
+        return ModilifyMk2RollingState(
+            canvas=canvas,
+            confidence=shift(state.confidence),
+            entropy=shift(state.entropy, unknown_entropy),
+            age=shift(state.age),
+            latent_state=shifted_latent,
+            history=state.history.shift(commit_lengths, entropy_fill_value=unknown_entropy),
+            tape=state.tape,
+        )
+
+    @torch.inference_mode()
+    def generate(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        streamer: BaseStreamer | None = None,
+        generation_config: ModilifyMk2GenerationConfig | None = None,
+        logits_processor: LogitsProcessorList | None = None,
+        denoise_trace_callback: Callable[[dict[str, object]], None] | None = None,
+        **kwargs,
+    ) -> ModilifyMk2GenerationOutput:
+        request_seeds = kwargs.pop("seeds", None)
+        scalar_seed = kwargs.pop("seed", None)
+        if request_seeds is not None and scalar_seed is not None:
+            raise ValueError("Pass either `seed` or `seeds`, not both.")
+        generation_config, model_kwargs = self._prepare_generation_config(generation_config, **kwargs)
+        if input_ids is None or input_ids.ndim != 2 or input_ids.shape[0] < 1:
+            raise ValueError("ModilifyMk2 generation requires `input_ids` with shape [batch, sequence].")
+        if logits_processor:
+            raise ValueError(
+                "ModilifyMk2 uses its built-in exact sampler and does not accept "
+                "custom logits processors."
+            )
+        batch_size, input_width = input_ids.shape
+        if scalar_seed is not None:
+            request_seeds = [int(scalar_seed) + row for row in range(batch_size)]
+        elif batch_size > 1 and request_seeds is None:
+            # Static B>1 still uses independent row generators, but its default
+            # path must advance the caller's global device RNG just like normal
+            # generation instead of repeating torch.initial_seed() forever.
+            seed_parts = torch.randint(
+                0,
+                (1 << 31) - 1,
+                (batch_size, 2),
+                device=input_ids.device,
+                dtype=torch.int64,
+            ).detach().cpu().tolist()
+            request_seeds = [
+                (int(high) << 31) | int(low) for high, low in seed_parts
+            ]
+        if request_seeds is not None:
+            if len(request_seeds) != batch_size:
+                raise ValueError("`seeds` must contain one seed per batch row.")
+            sampling_generators = []
+            for seed_value in request_seeds:
+                generator = torch.Generator(device=input_ids.device)
+                generator.manual_seed(int(seed_value) & ((1 << 63) - 1))
+                sampling_generators.append(generator)
+        else:
+            sampling_generators = None
+        if batch_size > 1 and streamer is not None:
+            raise ValueError("ModilifyMk2 streamers currently support batch size 1 only.")
+        if batch_size > 1 and denoise_trace_callback is not None:
+            raise ValueError("ModilifyMk2 denoise tracing currently supports batch size 1 only.")
+        if batch_size > 1 and past_key_values is not None:
+            raise ValueError("Batched ModilifyMk2 generation requires a fresh KV cache.")
+        if batch_size > 1:
+            from .continuous_batching import generate_static_batch_with_logical_cache
+
+            attention_mask = model_kwargs.pop("attention_mask", None)
+            canonical_mask = (
+                torch.ones_like(input_ids, dtype=torch.bool)
+                if attention_mask is None
+                else attention_mask.to(device=input_ids.device, dtype=torch.bool)
+            )
+            if canonical_mask.shape != input_ids.shape:
+                raise ValueError(
+                    "`attention_mask` must have the same shape as `input_ids`."
+                )
+            row_limits = []
+            for prompt_length in canonical_mask.long().sum(dim=-1).tolist():
+                _, resolved_max_new_tokens = self._prepare_generated_length(
+                    generation_config, int(prompt_length)
+                )
+                if resolved_max_new_tokens <= 0:
+                    raise ValueError(
+                        "The requested maximum length leaves no room to generate "
+                        "for every batch row."
+                    )
+                row_limits.append(int(resolved_max_new_tokens))
+            provided_positions = model_kwargs.pop("position_ids", None)
+            if provided_positions is not None:
+                canonical_positions = (
+                    canonical_mask.long().cumsum(dim=-1).sub(1).clamp_min(0)
+                ).to(provided_positions)
+                if not torch.equal(provided_positions, canonical_positions):
+                    raise ValueError(
+                        "Continuous static batches require canonical row-local `position_ids`."
+                    )
+            if model_kwargs:
+                unsupported = ", ".join(sorted(model_kwargs))
+                raise ValueError(
+                    f"Unsupported batched ModilifyMk2 generation arguments: {unsupported}"
+                )
+            return generate_static_batch_with_logical_cache(
+                self,
+                input_ids,
+                canonical_mask,
+                generation_config,
+                seeds=request_seeds,
+                max_new_tokens=row_limits,
+            )
+        device = input_ids.device
+        dtype = self.model.decoder.embed_tokens.weight.dtype
+        canvas_length = self.config.canvas_length
+        cached_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+        repetition_penalty = float(generation_config.repetition_penalty)
+        repetition_enabled = repetition_penalty != 1.0
+        if repetition_enabled and cached_length:
+            raise ValueError(
+                "Repetition penalty requires a fresh KV cache so the complete prompt "
+                "token history is available."
+            )
+        _, max_new_tokens = self._prepare_generated_length(
+            generation_config, cached_length + input_width
+        )
+        max_iterations = deterministic_episode_iteration_bound(
+            torch.tensor([max_new_tokens]),
+            max_ponder_steps=generation_config.max_ponder_steps,
+        )
+        if past_key_values is None:
+            past_key_values = self._prepare_cache_for_generation(
+                generation_config,
+                batch_size=batch_size,
+                # Ragged batches append dense, masked cache blocks. In the
+                # worst case only one row advances in each block.
+                max_length=input_width + batch_size * max_new_tokens,
+            )
+        expected_mask_width = cached_length + input_width
+        cache_attention_mask = model_kwargs.pop(
+            "attention_mask",
+            torch.ones(
+                batch_size, expected_mask_width, dtype=torch.bool, device=device
+            ),
+        ).bool()
+        if cache_attention_mask.shape != (batch_size, expected_mask_width):
+            raise ValueError(
+                "`attention_mask` must have shape [batch, cached_length + sequence]."
+            )
+        provided_position_ids = model_kwargs.pop("position_ids", None)
+        if provided_position_ids is not None:
+            if provided_position_ids.shape != input_ids.shape:
+                raise ValueError("`position_ids` must have the same shape as `input_ids`.")
+            prompt_positions = provided_position_ids.to(device=device, dtype=torch.int32)
+        elif cached_length:
+            prompt_positions = torch.arange(
+                cached_length,
+                cached_length + input_width,
+                device=device,
+                dtype=torch.int32,
+            ).unsqueeze(0)
+        else:
+            input_mask = cache_attention_mask[:, -input_width:]
+            prompt_positions = input_mask.long().cumsum(dim=-1).sub(1).clamp_min(0).to(torch.int32)
+        logical_lengths = cache_attention_mask.long().sum(dim=-1)
+        if input_width:
+            encoder_keys = ("pixel_values", "mm_token_type_ids", "image_position_ids")
+            encoder_kwargs = {
+                key: model_kwargs.pop(key)
+                for key in encoder_keys
+                if key in model_kwargs
+            }
+            past_key_values = self.model.encoder(
+                input_ids=input_ids,
+                attention_mask=cache_attention_mask,
+                past_key_values=past_key_values,
+                position_ids=prompt_positions,
+                **encoder_kwargs,
+            ).past_key_values
+
+        sampler = self._prepare_sampler(generation_config, canvas_length)
+        latent = LatentDeliberationState.empty(
+            batch_size=batch_size, canvas_length=canvas_length,
+            latent_dim=self.config.latent_dim, memory_slots=self.config.latent_memory_slots,
+            device=device, dtype=dtype,
+        )
+        history = TrajectoryHistory.empty(
+            batch_size=batch_size,
+            canvas_length=canvas_length,
+            hidden_size=self.config.text_config.hidden_size,
+            history_length=self.config.latent_history_length,
+            device=device,
+            dtype=dtype,
+        )
+        try:
+            initial_canvas = sampler.initialize_canvas(
+                batch_size, device, generators=sampling_generators
+            )
+        except TypeError:
+            initial_canvas = sampler.initialize_canvas(batch_size, device)
+        state = ModilifyMk2RollingState(
+            canvas=initial_canvas,
+            confidence=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            entropy=torch.full(
+                (batch_size, canvas_length), math.log(self.config.text_config.vocab_size),
+                device=device, dtype=torch.float32,
+            ),
+            age=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.int32
+            ),
+            latent_state=latent,
+            history=history,
+            tape=empty_trajectory_tape(
+                batch_size=batch_size,
+                config=self.config,
+                device=device,
+                dtype=dtype,
+            ),
+        )
+        turn_end = (
+            self.config.turn_end_token_id
+            if generation_config.turn_end_token_id is None
+            else generation_config.turn_end_token_id
+        )
+        configured_eos = generation_config.eos_token_id
+        if configured_eos is None:
+            configured_eos = self.config.eos_token_id
+        if isinstance(configured_eos, int):
+            configured_eos = [configured_eos]
+        stop_token_ids = tuple(
+            dict.fromkeys((int(turn_end), *(int(value) for value in configured_eos or ())))
+        )
+        pad_token_id = generation_config.pad_token_id
+        if pad_token_id is None:
+            pad_token_id = getattr(self.config, "pad_token_id", None)
+        if isinstance(pad_token_id, (list, tuple)):
+            pad_token_id = pad_token_id[0]
+        pad_token_id = int(0 if pad_token_id is None else pad_token_id)
+        excluded_repetition_token_ids = _flatten_token_ids(
+            generation_config.repetition_penalty_exclude_token_ids,
+            generation_config.pad_token_id,
+            generation_config.bos_token_id,
+            generation_config.eos_token_id,
+            generation_config.turn_end_token_id,
+            getattr(self.config, "image_token_id", None),
+        )
+        repetition_history = None
+        if repetition_enabled:
+            repetition_history = torch.zeros(
+                (batch_size, self.config.text_config.vocab_size),
+                dtype=torch.bool,
+                device=device,
+            )
+            _add_repetition_history(
+                repetition_history,
+                input_ids,
+                cache_attention_mask[:, -input_width:],
+                excluded_repetition_token_ids,
+            )
+        generated = torch.full(
+            (batch_size, max_new_tokens),
+            pad_token_id,
+            dtype=input_ids.dtype,
+            device=device,
+        )
+        committed = torch.zeros(batch_size, dtype=torch.long, device=device)
+        denoise_steps = torch.zeros_like(committed)
+        jumps = torch.zeros_like(committed)
+        forced_jump_tokens = torch.zeros_like(committed)
+        shifts = torch.zeros_like(committed)
+        retention_scores = torch.zeros(batch_size, dtype=torch.float32, device=device)
+        stop_codes = torch.zeros_like(committed)
+        active_rows = torch.ones(batch_size, dtype=torch.bool, device=device)
+        canvas_positions = torch.arange(canvas_length, device=device)[None, :]
+        if streamer is not None:
+            streamer.put(input_ids.cpu())
+
+        while bool(active_rows.any()):
+            started = time.perf_counter()
+            prefix_length = past_key_values.get_seq_length()
+            decoder_positions = (
+                logical_lengths[:, None]
+                + torch.arange(canvas_length, device=device)[None, :]
+            ).to(torch.int32)
+            denoise_steps += active_rows.long()
+            decoder_attention_mask = torch.cat(
+                (
+                    cache_attention_mask,
+                    torch.ones(
+                        batch_size,
+                        canvas_length,
+                        dtype=torch.bool,
+                        device=device,
+                    ),
+                ),
+                dim=-1,
+            )
+            output = self(
+                input_ids=None, past_key_values=past_key_values,
+                decoder_input_ids=state.canvas,
+                previous_confidence=state.confidence, previous_entropy=state.entropy,
+                token_age=state.age, latent_state=state.latent_state,
+                history=state.history,
+                tape=state.tape,
+                decoder_position_ids=decoder_positions, decoder_read_cache=True,
+                decoder_attention_mask=decoder_attention_mask,
+                compact_vocab=True,
+                denoise_temperature=generation_config.denoise_temperature,
+                repetition_token_mask=repetition_history,
+                repetition_penalty=repetition_penalty,
+                sampling_generators=sampling_generators,
+                **model_kwargs,
+            )
+            if (
+                output.proposal is None
+                or output.proposal_confidence is None
+                or output.token_entropy is None
+                or output.greedy_proposal is None
+                or output.greedy_confidence is None
+            ):
+                raise RuntimeError(
+                    "Compact vocabulary forward did not return proposal statistics."
+                )
+            proposal = output.proposal
+            proposal_confidence = output.proposal_confidence
+            token_entropy = output.token_entropy
+            greedy_proposal = output.greedy_proposal
+            greedy_confidence = output.greedy_confidence
+            next_canvas = proposal.clone()
+            next_confidence = proposal_confidence.float()
+            next_latent = replace(
+                output.next_latent_state,
+                confidence=next_confidence.detach().float(),
+                entropy=token_entropy.detach().float(),
+                age=state.age + 1,
+                token_changed=next_canvas.ne(state.canvas).detach().float(),
+                confidence_delta=next_confidence.detach().float() - state.confidence,
+                entropy_delta=token_entropy.detach().float() - state.entropy,
+            )
+            remaining = torch.tensor(
+                max_new_tokens, device=device, dtype=torch.long
+            ).sub(committed)
+            remaining_canvas = remaining[:, None].gt(canvas_positions)
+            tape_probes, tape_valid = self.latent_deliberation.encode_tape_frame(
+                output.heavy_hidden_state, remaining_canvas
+            )
+            next_state = ModilifyMk2RollingState(
+                canvas=next_canvas, confidence=next_confidence,
+                entropy=token_entropy, age=state.age + 1,
+                latent_state=next_latent,
+                history=state.history.append(
+                    output.heavy_hidden_state,
+                    next_confidence,
+                    token_entropy,
+                    next_canvas.ne(state.canvas).detach().float(),
+                    live_mask=remaining_canvas,
+                ),
+                tape=state.tape.append(tape_probes, tape_valid),
+            )
+            next_state = self._merge_state_rows(state, next_state, active_rows)
+            normal_failure_rate = fused_commit_failure_rate(
+                proposal_confidence, token_entropy,
+                vocab_size=self.config.text_config.vocab_size,
+            )
+            jump_failure_rate = fused_commit_failure_rate(
+                greedy_confidence, token_entropy,
+                vocab_size=self.config.text_config.vocab_size,
+            )
+            previous_failure_rate = fused_commit_failure_rate(
+                state.confidence, state.entropy,
+                vocab_size=self.config.text_config.vocab_size,
+            )
+            policy_decision = select_commit_lengths(
+                sampled_token_ids=proposal,
+                normal_failure_rate=normal_failure_rate,
+                previous_failure_rate=previous_failure_rate,
+                greedy_token_ids=greedy_proposal,
+                jump_failure_rate=jump_failure_rate,
+                ponder_steps=state.latent_state.ponder_steps,
+                stagnation_steps=state.latent_state.stagnation_steps,
+                active_rows=active_rows,
+                remaining_lengths=remaining,
+                failure_budget=generation_config.commit_failure_budget,
+                jump_failure_budget=generation_config.jump_failure_budget,
+                stop_token_id=stop_token_ids,
+                max_ponder_steps=generation_config.max_ponder_steps,
+                stagnation_threshold=generation_config.jump_on_no_progress_after,
+                min_progress=generation_config.min_trajectory_progress,
+            )
+            normal_commit = policy_decision.normal_lengths
+            policy_prefix_mask = canvas_positions.lt(normal_commit[:, None])
+            next_ponder = policy_decision.ponder_steps
+            next_stagnation = policy_decision.stagnation_steps
+            commit_lengths = policy_decision.commit_lengths
+            jump_rows = policy_decision.jump_rows
+            jumps += jump_rows.long()
+            forced_jump_tokens += torch.where(
+                jump_rows, commit_lengths, torch.zeros_like(commit_lengths)
+            )
+            commit_positions = canvas_positions.lt(commit_lengths[:, None])
+            if bool(jump_rows.any()):
+                next_state = replace(
+                    next_state,
+                    canvas=torch.where(
+                        commit_positions & jump_rows[:, None],
+                        policy_decision.commit_token_ids,
+                        next_state.canvas,
+                    ),
+                )
+            next_state = replace(
+                next_state,
+                latent_state=replace(
+                    next_state.latent_state,
+                    ponder_steps=next_ponder,
+                    stagnation_steps=next_stagnation,
+                ),
+            )
+            commit_token_ids = policy_decision.commit_token_ids
+            before = committed.clone()
+            write_rows = torch.arange(batch_size, device=device)[:, None].expand_as(
+                commit_token_ids
+            )
+            write_positions = before[:, None] + canvas_positions
+            generated[
+                write_rows[commit_positions], write_positions[commit_positions]
+            ] = commit_token_ids[commit_positions]
+            if repetition_history is not None:
+                _add_repetition_history(
+                    repetition_history,
+                    commit_token_ids,
+                    commit_positions,
+                    excluded_repetition_token_ids,
+                )
+
+            commit_width = int(commit_lengths.max())
+            if commit_width:
+                block_mask = torch.arange(commit_width, device=device)[None, :].lt(
+                    commit_lengths[:, None]
+                )
+                committed_block = torch.where(
+                    block_mask,
+                    commit_token_ids[:, :commit_width],
+                    torch.full(
+                        (batch_size, commit_width),
+                        pad_token_id,
+                        device=device,
+                        dtype=input_ids.dtype,
+                    ),
+                )
+                block_positions = (
+                    logical_lengths[:, None]
+                    + torch.arange(commit_width, device=device)[None, :]
+                ).to(torch.int32)
+                block_positions = torch.where(
+                    block_mask, block_positions, torch.zeros_like(block_positions)
+                )
+                cache_attention_mask = torch.cat(
+                    (cache_attention_mask, block_mask), dim=-1
+                )
+                past_key_values = self.model.encoder(
+                    input_ids=committed_block,
+                    attention_mask=cache_attention_mask,
+                    past_key_values=past_key_values,
+                    position_ids=block_positions,
+                ).past_key_values
+                if streamer is not None:
+                    streamer.put(committed_block.cpu())
+            committed += commit_lengths
+            logical_lengths += commit_lengths
+            committed_rows = commit_lengths.gt(0)
+            shifts += committed_rows.long()
+            if (
+                output.history_projected is None
+                or output.working_state is None
+            ):
+                raise RuntimeError("Forward did not return working trajectory features.")
+            next_state = self._write_committed_memory(
+                previous_history=state.history,
+                next_state=next_state,
+                working_state=output.working_state,
+                history_projected=output.history_projected,
+                heavy_hidden=output.heavy_hidden_state,
+                commit_lengths=commit_lengths,
+                prefix_lengths=logical_lengths,
+                commit_reason=infer_commit_reason(
+                    commit_lengths,
+                    jump_rows=jump_rows,
+                    commit_token_ids=commit_token_ids,
+                    terminal_token_ids=stop_token_ids,
+                ),
+            )
+            shifted = self._shift_state_rows(
+                next_state,
+                commit_lengths,
+                sampler,
+                generators=sampling_generators,
+            )
+            retention_scores += committed_rows.float()
+            state = shifted
+
+            turn_hits = (
+                commit_token_ids.eq(turn_end) & commit_positions
+            ).any(dim=-1)
+            eos_hits = torch.zeros_like(turn_hits)
+            for token_id in stop_token_ids:
+                if token_id != turn_end:
+                    eos_hits |= (
+                        commit_token_ids.eq(token_id) & commit_positions
+                    ).any(dim=-1)
+            stop_codes = torch.where(
+                stop_codes.eq(0) & turn_hits,
+                torch.ones_like(stop_codes),
+                stop_codes,
+            )
+            stop_codes = torch.where(
+                stop_codes.eq(0) & eos_hits,
+                torch.full_like(stop_codes, 2),
+                stop_codes,
+            )
+            stop_codes = torch.where(
+                stop_codes.eq(0) & committed.ge(max_new_tokens),
+                torch.full_like(stop_codes, 3),
+                stop_codes,
+            )
+            if generation_config.max_denoising_steps is not None:
+                stop_codes = torch.where(
+                    stop_codes.eq(0)
+                    & denoise_steps.ge(generation_config.max_denoising_steps),
+                    torch.full_like(stop_codes, 4),
+                    stop_codes,
+                )
+            stop_codes = torch.where(
+                stop_codes.eq(0) & denoise_steps.ge(max_iterations),
+                torch.full_like(stop_codes, 5),
+                stop_codes,
+            )
+            if denoise_trace_callback is not None:
+                denoise_trace_callback(build_denoise_trace_event(
+                    denoise_step=int(denoise_steps[0]),
+                    prefix_length=prefix_length, committed_before=int(before[0]),
+                    committed_after=int(committed[0]),
+                    no_progress_steps=int(next_stagnation[0]),
+                    policy_prefix_mask=policy_prefix_mask,
+                    commit_length=int(commit_lengths[0]),
+                    ponder_fallback=bool(jump_rows[0]), state=next_state, proposal=proposal,
+                    committed_token_ids=commit_token_ids[:, :commit_width],
+                    step_elapsed_seconds=time.perf_counter() - started,
+                    latent_residual_diagnostics=output.latent_residual_diagnostics,
+                ))
+            active_rows = stop_codes.eq(0)
+
+        output_width = int(committed.max())
+        sequences = torch.cat((input_ids, generated[:, :output_width]), dim=-1)
+        if streamer is not None:
+            streamer.end()
+        reason_names = {
+            1: "turn_end",
+            2: "eos",
+            3: "max_new_tokens",
+            4: "max_denoising_steps",
+            5: "episode_watchdog",
+        }
+        stop_reasons = tuple(
+            reason_names.get(code, "unknown") for code in stop_codes.detach().cpu().tolist()
+        )
+        tokens_per_forward = committed.float() / denoise_steps.clamp_min(1).float()
+        average_commit_len = committed.float() / shifts.clamp_min(1).float()
+        latent_memory_norm = state.latent_state.memory_slots.float().norm(dim=-1).mean(dim=-1)
+        state_retention_score = retention_scores / shifts.clamp_min(1).float()
+
+        def scalar_or_tensor(value: torch.Tensor, *, floating: bool = False):
+            if batch_size > 1:
+                return value
+            item = value[0].item()
+            return float(item) if floating else int(item)
+
+        return ModilifyMk2GenerationOutput(
+            sequences=sequences,
+            generated_lengths=committed.clone(),
+            tokens_per_forward=tokens_per_forward,
+            past_key_values=past_key_values,
+            stop_reason=stop_reasons[0] if batch_size == 1 else stop_reasons,
+            committed_tokens=scalar_or_tensor(committed),
+            denoise_steps=scalar_or_tensor(denoise_steps),
+            no_progress_steps=scalar_or_tensor(state.latent_state.stagnation_steps),
+            jump_count=scalar_or_tensor(jumps),
+            forced_jump_bad_count=scalar_or_tensor(forced_jump_tokens),
+            heavy_forward_count=scalar_or_tensor(denoise_steps),
+            latent_context_update_count=scalar_or_tensor(denoise_steps),
+            average_commit_len=scalar_or_tensor(average_commit_len, floating=True),
+            state_shift_count=scalar_or_tensor(shifts),
+            latent_memory_norm=scalar_or_tensor(latent_memory_norm, floating=True),
+            state_retention_score=scalar_or_tensor(state_retention_score, floating=True),
+        )
+
+
+__all__ = [
+    "ModilifyMk2GenerationConfig", "ModilifyMk2GenerationMixin", "ModilifyMk2GenerationOutput",
+    "ModilifyMk2RollingState", "NoiseCanvasSampler",
+    "build_denoise_trace_event", "qualified_single_turn_end_lengths",
+]

latent_deliberation.py

@@ -0,0 +1,2134 @@
+# Copyright 2026 Modilify
+# SPDX-License-Identifier: LicenseRef-Modilify-Open-Model-1.0
+"""Dual-timescale Transformer memory for Modilify Mk2 inference.
+
+Working trajectory state is recomputed every denoise step from the packed
+personal history. Persistent slots are commit-invariant and mutate only in
+TransformerCommitWriter.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+_AGE_MAX = 4096
+_PONDER_MAX = 1024
+_STAGNATION_MAX = 1024
+_METADATA_HIDDEN = 64
+_FILM_RANK = 64
+_FOURIER_WAVES = 4
+_RETIREMENT_FRAMES = 4
+_KEY_META_DIM = 13
+_QUERY_META_DIM = 8 + 6
+_ROW_META_DIM = 2
+_HISTORY_VIEWS = 4
+_EXPERIENCE_ROLES = 3
+_EXPERIENCE_CANVAS_STRIPE = 8
+_GATE_BIAS = -3.0
+
+COMMIT_REASON_NONE = 0
+COMMIT_REASON_NORMAL = 1
+COMMIT_REASON_FORCED_JUMP = 2
+COMMIT_REASON_TERMINAL = 3
+COMMIT_REASON_FALLBACK = 4
+COMMIT_REASON_TRAINING_RANDOM = 5
+COMMIT_REASON_COUNT = 6
+
+
+def _fp32_scaled_dot_product_attention(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    *,
+    attn_mask: torch.Tensor | None = None,
+) -> torch.Tensor:
+    """Run latent-memory attention reductions in FP32, then restore dtype.
+
+    These attention maps are small compared with the frozen decoder, while
+    their outputs feed recurrent trajectory and persistent-memory paths.  A
+    BF16 reduction error therefore compounds across denoise/commit steps and
+    is much more expensive than the modest FP32 workspace.
+    """
+
+    output_dtype = query.dtype
+    stable_mask = attn_mask
+    if stable_mask is not None and stable_mask.is_floating_point():
+        stable_mask = stable_mask.float()
+    query_fp32 = query.float()
+    key_fp32 = key.float()
+    use_batched_mm = query.ndim == 4 and key.ndim == 4 and value.ndim == 4
+    if use_batched_mm:
+        query_length = int(query.shape[-2])
+        key_length = int(key.shape[-2])
+        scores = torch.bmm(
+            query_fp32.reshape(-1, query_length, query.shape[-1]),
+            key_fp32.reshape(-1, key_length, key.shape[-1]).transpose(1, 2),
+        ).reshape(*query.shape[:-2], query_length, key_length)
+    else:
+        scores = torch.matmul(query_fp32, key_fp32.transpose(-2, -1))
+    scores = scores / math.sqrt(max(query.shape[-1], 1))
+    if stable_mask is not None:
+        if stable_mask.dtype == torch.bool:
+            scores = scores.masked_fill(~stable_mask, _sdpa_mask_value(torch.float32))
+        else:
+            scores = scores + stable_mask
+    probabilities = torch.softmax(scores, dim=-1)
+    # All-masked rows are uniform under a finite mask, but keep a NaN
+    # barrier for any remaining -inf path that MPS softmax cannot invert.
+    probabilities = torch.nan_to_num(probabilities, nan=0.0)
+    if use_batched_mm:
+        output = torch.bmm(
+            probabilities.reshape(-1, query.shape[-2], key.shape[-2]),
+            value.float().reshape(-1, key.shape[-2], value.shape[-1]),
+        ).reshape(*query.shape[:-2], query.shape[-2], value.shape[-1])
+    else:
+        output = torch.matmul(probabilities, value.float())
+    return output.to(dtype=output_dtype)
+
+
+@dataclass
+class TrajectoryHistory:
+    """Detached ring of recent canvas heavies. Canvas is dimension 2."""
+
+    hidden: torch.Tensor
+    confidence: torch.Tensor
+    entropy: torch.Tensor
+    token_changed: torch.Tensor
+    valid: torch.Tensor
+
+    @classmethod
+    def empty(
+        cls,
+        *,
+        batch_size: int,
+        canvas_length: int,
+        hidden_size: int,
+        history_length: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> "TrajectoryHistory":
+        return cls(
+            hidden=torch.zeros(
+                batch_size, history_length, canvas_length, hidden_size,
+                device=device, dtype=dtype,
+            ),
+            confidence=torch.zeros(
+                batch_size, history_length, canvas_length,
+                device=device, dtype=torch.float32,
+            ),
+            entropy=torch.zeros(
+                batch_size, history_length, canvas_length,
+                device=device, dtype=torch.float32,
+            ),
+            token_changed=torch.zeros(
+                batch_size, history_length, canvas_length,
+                device=device, dtype=torch.float32,
+            ),
+            valid=torch.zeros(
+                batch_size, history_length, canvas_length,
+                device=device, dtype=torch.bool,
+            ),
+        )
+
+    def detach(self) -> "TrajectoryHistory":
+        return TrajectoryHistory(
+            hidden=self.hidden.detach(),
+            confidence=self.confidence.detach(),
+            entropy=self.entropy.detach(),
+            token_changed=self.token_changed.detach(),
+            valid=self.valid.detach(),
+        )
+
+    def append(
+        self,
+        hidden: torch.Tensor,
+        confidence: torch.Tensor,
+        entropy: torch.Tensor,
+        token_changed: torch.Tensor,
+        live_mask: torch.Tensor | None = None,
+    ) -> "TrajectoryHistory":
+        # Truncated-BPTT observation. Replay uses temporal context / committed
+        # memory, not this ring; keeping frames live would retain every heavy
+        # decoder graph across the chunk.
+        frame = hidden.detach()
+        if live_mask is None:
+            newest_valid = torch.ones(
+                self.valid.shape[0],
+                self.valid.shape[2],
+                device=self.valid.device,
+                dtype=torch.bool,
+            )
+        else:
+            newest_valid = live_mask.to(device=self.valid.device, dtype=torch.bool)
+            if newest_valid.shape != self.valid[:, 0].shape:
+                raise ValueError("`live_mask` must have shape [batch, canvas].")
+        return TrajectoryHistory(
+            hidden=torch.cat((self.hidden[:, 1:], frame.unsqueeze(1)), dim=1),
+            confidence=torch.cat(
+                (self.confidence[:, 1:], confidence.detach().float().unsqueeze(1)),
+                dim=1,
+            ),
+            entropy=torch.cat(
+                (self.entropy[:, 1:], entropy.detach().float().unsqueeze(1)),
+                dim=1,
+            ),
+            token_changed=torch.cat(
+                (self.token_changed[:, 1:], token_changed.detach().float().unsqueeze(1)),
+                dim=1,
+            ),
+            valid=torch.cat((self.valid[:, 1:], newest_valid.unsqueeze(1)), dim=1),
+        )
+
+    def shift(
+        self,
+        commit_lengths: torch.Tensor | int,
+        *,
+        entropy_fill_value: float = 0.0,
+    ) -> "TrajectoryHistory":
+        batch, history_length, canvas_length, _hidden = self.hidden.shape
+        if isinstance(commit_lengths, int):
+            lengths = torch.full(
+                (batch,), commit_lengths, device=self.hidden.device, dtype=torch.long
+            )
+        else:
+            lengths = commit_lengths.to(device=self.hidden.device, dtype=torch.long)
+        if bool((lengths <= 0).all()):
+            return self.detach()
+        positions = torch.arange(canvas_length, device=self.hidden.device)[None, :]
+        source = positions + lengths[:, None]
+        retained = source.lt(canvas_length)
+
+        def shifted(tensor: torch.Tensor, fill_value: float | int = 0) -> torch.Tensor:
+            index = source.clamp_max(canvas_length - 1)
+            extra = tensor.ndim - 3
+            view = index.view(batch, 1, canvas_length, *([1] * extra)).expand_as(tensor)
+            gathered = tensor.gather(2, view)
+            fill = torch.as_tensor(fill_value, device=tensor.device, dtype=tensor.dtype)
+            mask = retained.view(batch, 1, canvas_length, *([1] * extra))
+            return torch.where(mask, gathered, fill)
+
+        return TrajectoryHistory(
+            hidden=shifted(self.hidden),
+            confidence=shifted(self.confidence),
+            entropy=shifted(self.entropy, entropy_fill_value),
+            token_changed=shifted(self.token_changed),
+            valid=shifted(self.valid, False),
+        )
+
+
+@dataclass
+class TrajectoryTape:
+    """Row-level denoise snapshots. Time axis does not follow canvas shift."""
+
+    probes: torch.Tensor
+    valid: torch.Tensor
+
+    @classmethod
+    def empty(
+        cls,
+        *,
+        batch_size: int,
+        tape_length: int,
+        num_probes: int,
+        probe_dim: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> "TrajectoryTape":
+        return cls(
+            probes=torch.zeros(
+                batch_size, tape_length, num_probes, probe_dim,
+                device=device, dtype=dtype,
+            ),
+            valid=torch.zeros(
+                batch_size, tape_length, device=device, dtype=torch.bool,
+            ),
+        )
+
+    def detach(self) -> "TrajectoryTape":
+        return TrajectoryTape(probes=self.probes.detach(), valid=self.valid.detach())
+
+    def append(self, probes: torch.Tensor, valid: torch.Tensor) -> "TrajectoryTape":
+        # Canvas snapshots are detached before pooling. Keep the pool graph so
+        # the next denoise's tape read can train the compressor; TBPTT still
+        # cuts at `detach()`.
+        flag = valid.to(device=self.valid.device, dtype=torch.bool)
+        if flag.ndim == 0:
+            flag = flag.expand(self.valid.shape[0])
+        if flag.shape != self.valid[:, 0].shape:
+            raise ValueError("Tape frame validity must have shape [batch].")
+        if probes.shape[0] != self.probes.shape[0] or probes.shape[-2:] != self.probes.shape[-2:]:
+            raise ValueError("Tape probes do not match the ring.")
+        return TrajectoryTape(
+            probes=torch.cat((self.probes[:, 1:], probes.unsqueeze(1)), dim=1),
+            valid=torch.cat((self.valid[:, 1:], flag.unsqueeze(1)), dim=1),
+        )
+
+
+@dataclass
+class LatentDeliberationState:
+    """Persistent slots plus per-canvas trajectory clocks. No token latents."""
+
+    memory_slots: torch.Tensor
+    confidence: torch.Tensor
+    entropy: torch.Tensor
+    age: torch.Tensor
+    token_changed: torch.Tensor
+    confidence_delta: torch.Tensor
+    entropy_delta: torch.Tensor
+    ponder_steps: torch.Tensor
+    stagnation_steps: torch.Tensor
+
+    @classmethod
+    def empty(
+        cls,
+        *,
+        batch_size: int,
+        canvas_length: int,
+        latent_dim: int,
+        memory_slots: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> "LatentDeliberationState":
+        return cls(
+            memory_slots=torch.zeros(
+                batch_size, memory_slots, latent_dim, device=device, dtype=dtype
+            ),
+            confidence=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            entropy=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            age=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.int32
+            ),
+            token_changed=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            confidence_delta=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            entropy_delta=torch.zeros(
+                batch_size, canvas_length, device=device, dtype=torch.float32
+            ),
+            ponder_steps=torch.zeros(batch_size, device=device, dtype=torch.int32),
+            stagnation_steps=torch.zeros(batch_size, device=device, dtype=torch.int32),
+        )
+
+    def detach(self) -> "LatentDeliberationState":
+        return LatentDeliberationState(
+            memory_slots=self.memory_slots.detach(),
+            confidence=self.confidence.detach(),
+            entropy=self.entropy.detach(),
+            age=self.age.detach(),
+            token_changed=self.token_changed.detach(),
+            confidence_delta=self.confidence_delta.detach(),
+            entropy_delta=self.entropy_delta.detach(),
+            ponder_steps=self.ponder_steps.detach(),
+            stagnation_steps=self.stagnation_steps.detach(),
+        )
+
+    def shift(
+        self, committed: int, *, entropy_fill_value: float = 0.0
+    ) -> "LatentDeliberationState":
+        canvas_length = self.confidence.shape[1]
+        if not 0 <= committed <= canvas_length:
+            raise ValueError("`committed` must be in [0, canvas_length].")
+        if committed == 0:
+            return self.detach()
+
+        def shifted(tensor: torch.Tensor, fill_value: float | int = 0) -> torch.Tensor:
+            result = torch.full_like(tensor, fill_value)
+            if committed < canvas_length:
+                result[:, : canvas_length - committed] = tensor[:, committed:]
+            return result
+
+        return LatentDeliberationState(
+            memory_slots=self.memory_slots.clone(),
+            confidence=shifted(self.confidence),
+            entropy=shifted(self.entropy, entropy_fill_value),
+            age=shifted(self.age),
+            token_changed=shifted(self.token_changed),
+            confidence_delta=shifted(self.confidence_delta),
+            entropy_delta=shifted(self.entropy_delta),
+            ponder_steps=torch.zeros_like(self.ponder_steps),
+            stagnation_steps=torch.zeros_like(self.stagnation_steps),
+        )
+
+
+@dataclass
+class LatentProcessorOutput:
+    context: torch.Tensor
+    working_state: torch.Tensor
+    state: LatentDeliberationState
+    history_projected: torch.Tensor
+
+
+def advance_trajectory_clocks(
+    ponder_steps: torch.Tensor,
+    stagnation_steps: torch.Tensor,
+    *,
+    commit_lengths: torch.LongTensor,
+    active_rows: torch.BoolTensor,
+    progress_scores: torch.Tensor | None = None,
+    min_progress: float = 0.0,
+) -> tuple[torch.IntTensor, torch.IntTensor]:
+    """Advance useful-ponder and stagnation clocks for each row."""
+
+    if min_progress < 0:
+        raise ValueError("`min_progress` must be non-negative.")
+    if not (
+        ponder_steps.shape == stagnation_steps.shape == commit_lengths.shape
+        == active_rows.shape
+    ):
+        raise ValueError("Trajectory clock inputs must share shape [batch].")
+    committed = commit_lengths.gt(0)
+    waiting = active_rows & ~committed
+    next_ponder = torch.where(
+        committed, torch.zeros_like(ponder_steps), ponder_steps + waiting.to(torch.int32)
+    )
+    next_stagnation = torch.where(
+        committed,
+        torch.zeros_like(stagnation_steps),
+        stagnation_steps + waiting.to(torch.int32),
+    )
+    return next_ponder.to(torch.int32), next_stagnation.to(torch.int32)
+
+
+def should_force_trajectory_jump(
+    stagnation_steps: torch.Tensor,
+    *,
+    progress_scores: torch.Tensor | None = None,
+    min_progress: float = 0.0,
+    stagnation_threshold: int,
+    ponder_steps: torch.Tensor | None = None,
+    max_ponder_steps: int | None = None,
+) -> torch.BoolTensor:
+    """Determine whether to force a trajectory JUMP for each row.
+
+    JUMP is triggered when stagnation_steps reaches or exceeds stagnation_threshold
+    (default 12) and the current single-step progress is not strictly greater than
+    min_progress (default 0.005).
+    """
+    if stagnation_threshold <= 0:
+        raise ValueError("`stagnation_threshold` must be positive.")
+    if min_progress < 0:
+        raise ValueError("`min_progress` must be non-negative.")
+
+    if progress_scores is None:
+        stagnation_jump = stagnation_steps.ge(stagnation_threshold)
+    else:
+        if progress_scores.shape != stagnation_steps.shape:
+            raise ValueError("`progress_scores` must share shape with `stagnation_steps`.")
+        stagnation_jump = stagnation_steps.ge(stagnation_threshold) & progress_scores.le(
+            float(min_progress)
+        )
+
+    if ponder_steps is not None and max_ponder_steps is not None and max_ponder_steps > 0:
+        ponder_jump = ponder_steps.ge(max_ponder_steps)
+        return (ponder_jump | stagnation_jump).to(torch.bool)
+
+    return stagnation_jump.to(torch.bool)
+
+
+def _logit01(values: torch.Tensor) -> torch.Tensor:
+    clipped = values.clamp(1.0e-6, 1.0 - 1.0e-6)
+    return torch.log(clipped) - torch.log1p(-clipped)
+
+
+def _renorm_confidence(confidence: torch.Tensor) -> torch.Tensor:
+    return _logit01(confidence).clamp(-8.0, 8.0) / 8.0
+
+
+def _canvas_fourier(canvas_length: int, device: torch.device, dtype: torch.dtype) -> torch.Tensor:
+    positions = torch.arange(canvas_length, device=device, dtype=dtype) / max(canvas_length, 1)
+    features = []
+    for wave in range(_FOURIER_WAVES):
+        angle = (2.0 ** wave) * math.pi * positions
+        features.append(torch.sin(angle))
+        features.append(torch.cos(angle))
+    return torch.stack(features, dim=-1)
+
+
+def _safe_cosine(left: torch.Tensor, right: torch.Tensor) -> torch.Tensor:
+    left_n = F.normalize(left.float(), dim=-1, eps=1.0e-6)
+    right_n = F.normalize(right.float(), dim=-1, eps=1.0e-6)
+    return (left_n * right_n).sum(dim=-1).clamp(-1.0, 1.0)
+
+
+def _sdpa_mask_value(dtype: torch.dtype) -> float:
+    """Additive SDPA mask that stays finite on MPS fp16/bf16."""
+
+    if dtype in (torch.float16, torch.bfloat16):
+        return -1.0e4
+    return -1.0e9
+
+
+def _apply_rotary(payload: torch.Tensor, positions: torch.Tensor) -> torch.Tensor:
+    dim = payload.shape[-1]
+    half = dim // 2
+    if half == 0:
+        return payload
+    device = payload.device
+    inv = torch.arange(half, device=device, dtype=torch.float32)
+    inv = 10000.0 ** (-inv / max(half, 1))
+    angle = positions.to(dtype=torch.float32).unsqueeze(-1) * inv
+    cos = angle.cos().to(dtype=payload.dtype)
+    sin = angle.sin().to(dtype=payload.dtype)
+    while cos.ndim < payload.ndim:
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+    left, right = payload[..., :half], payload[..., half: half * 2]
+    rotated = torch.cat((left * cos - right * sin, left * sin + right * cos), dim=-1)
+    if dim > half * 2:
+        rotated = torch.cat((rotated, payload[..., half * 2 :]), dim=-1)
+    return rotated
+
+
+class _RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1.0e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(dim))
+        self.eps = eps
+
+    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
+        rms = hidden.float().square().mean(dim=-1, keepdim=True).add(self.eps).rsqrt()
+        return (hidden.float() * rms).to(dtype=hidden.dtype) * self.weight.to(dtype=hidden.dtype)
+
+
+class _SwiGLU(nn.Module):
+    def __init__(self, dim: int, hidden: int) -> None:
+        super().__init__()
+        self.gate = nn.Linear(dim, hidden, bias=False)
+        self.up = nn.Linear(dim, hidden, bias=False)
+        self.down = nn.Linear(hidden, dim, bias=False)
+
+    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
+        return self.down(F.silu(self.gate(hidden)) * self.up(hidden))
+
+
+class SharedHistoryProjector(nn.Module):
+    """2816 → rank projection, once per denoise (and once more on the commit tail)."""
+
+    def __init__(self, hidden_size: int, rank: int) -> None:
+        super().__init__()
+        self.norm = _RMSNorm(hidden_size)
+        self.proj = nn.Linear(hidden_size, rank, bias=False)
+
+    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
+        return self.proj(self.norm(hidden))
+
+
+class CanvasProbePool(nn.Module):
+    """Learned queries compress one canvas snapshot into P rank-space probes."""
+
+    def __init__(self, rank: int, num_probes: int, num_heads: int) -> None:
+        super().__init__()
+        if rank % num_heads:
+            raise ValueError("Tape rank must be divisible by heads.")
+        if num_probes <= 0:
+            raise ValueError("`num_probes` must be positive.")
+        self.rank = rank
+        self.num_probes = num_probes
+        self.num_heads = num_heads
+        self.head_dim = rank // num_heads
+        self.queries = nn.Parameter(torch.empty(num_probes, rank))
+        self.k_proj = nn.Linear(rank, rank, bias=False)
+        self.v_proj = nn.Linear(rank, rank, bias=False)
+        self.reset_parameters()
+
+    @torch.no_grad()
+    def reset_parameters(self) -> None:
+        nn.init.normal_(self.queries, mean=0.0, std=0.02)
+
+    def forward(
+        self,
+        projected: torch.Tensor,
+        live_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        batch, canvas, _rank = projected.shape
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.queries.to(dtype=projected.dtype).view(1, self.num_probes, heads, head_dim)
+        query = query.expand(batch, -1, -1, -1).permute(0, 2, 1, 3)
+        keys = self.k_proj(projected).view(batch, canvas, heads, head_dim).transpose(1, 2)
+        values = self.v_proj(projected).view(batch, canvas, heads, head_dim).transpose(1, 2)
+        if live_mask is None:
+            allowed = torch.ones(batch, canvas, device=projected.device, dtype=torch.bool)
+        else:
+            allowed = live_mask.to(device=projected.device, dtype=torch.bool)
+            if allowed.shape != (batch, canvas):
+                raise ValueError("`live_mask` must have shape [batch, canvas].")
+        has_live = allowed.any(dim=-1)
+        safe = allowed.clone()
+        safe[:, 0] = safe[:, 0] | ~has_live
+        # This small P×canvas pool is a poor place to trade stability for BF16:
+        # on MPS the first B16 tape frame can contain NaNs even with finite Q/K/V
+        # and at least one unmasked key per row.  Perform only the attention
+        # reduction in FP32; projections and stored probes retain model dtype.
+        additive = torch.zeros(
+            batch, 1, 1, canvas, device=projected.device, dtype=torch.float32
+        )
+        additive = additive.masked_fill(
+            ~safe.view(batch, 1, 1, canvas), _sdpa_mask_value(torch.float32)
+        )
+        context = _fp32_scaled_dot_product_attention(
+            query, keys, values, attn_mask=additive
+        )
+        probes = context.transpose(1, 2).reshape(batch, self.num_probes, self.rank)
+        return probes * has_live.to(dtype=probes.dtype).view(batch, 1, 1)
+
+
+class SharedPersistentKV(nn.Module):
+    """Frozen-M key/value projection shared across working-processor blocks."""
+
+    def __init__(self, dim: int, num_heads: int, kv_rank: int) -> None:
+        super().__init__()
+        if kv_rank % num_heads:
+            raise ValueError("`kv_rank` must be divisible by `num_heads`.")
+        self.num_heads = num_heads
+        self.kv_rank = kv_rank
+        self.head_dim = kv_rank // num_heads
+        self.address_norm = _RMSNorm(dim)
+        self.value_norm = _RMSNorm(dim)
+        self.k_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.v_proj = nn.Linear(dim, kv_rank, bias=False)
+
+    def forward(
+        self, memory: torch.Tensor, slot_identity: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        batch, slots, _dim = memory.shape
+        keys = self.k_proj(self.address_norm(memory + slot_identity))
+        values = self.v_proj(self.value_norm(memory))
+        keys = keys.view(batch, slots, self.num_heads, self.head_dim).transpose(1, 2)
+        values = values.view(batch, slots, self.num_heads, self.head_dim).transpose(1, 2)
+        return keys, values
+
+
+class _HistoryAttention(nn.Module):
+    """Per-position attention over shared rank-space history keys."""
+
+    def __init__(self, dim: int, num_heads: int, kv_rank: int) -> None:
+        super().__init__()
+        if kv_rank % num_heads:
+            raise ValueError("`kv_rank` must be divisible by `num_heads`.")
+        self.num_heads = num_heads
+        self.kv_rank = kv_rank
+        self.head_dim = kv_rank // num_heads
+        self.q_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.o_proj = nn.Linear(kv_rank, dim, bias=False)
+        self.q_norm = _RMSNorm(dim)
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+        *,
+        attn_bias: torch.Tensor,
+        key_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        batch, canvas, _dim = query.shape
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.q_proj(self.q_norm(query))
+        query = query.view(batch, canvas, heads, head_dim).transpose(1, 2)
+        if keys.ndim == 5:
+            expected = (batch, heads, canvas, keys.shape[-2], head_dim)
+            if keys.shape != expected or values.shape != expected:
+                raise ValueError("Preformatted history K/V dimensions do not match.")
+            slots = int(keys.shape[-2])
+        else:
+            slots = int(keys.shape[2])
+            keys = keys.view(batch, canvas, slots, heads, head_dim).permute(0, 3, 1, 2, 4)
+            values = values.view(batch, canvas, slots, heads, head_dim).permute(0, 3, 1, 2, 4)
+        query = query.reshape(batch * heads * canvas, 1, head_dim)
+        keys = keys.reshape(batch * heads * canvas, slots, head_dim)
+        values = values.reshape(batch * heads * canvas, slots, head_dim)
+        has_hist = key_mask.any(dim=-1)
+        safe_mask = key_mask.clone()
+        safe_mask[..., 0] = safe_mask[..., 0] | ~has_hist
+        mask = safe_mask.reshape(batch, 1, canvas, slots)
+        mask = mask.expand(-1, heads, -1, -1).reshape(batch * heads * canvas, 1, slots)
+        bias = attn_bias.reshape(batch * heads * canvas, 1, slots)
+        additive = bias.masked_fill(~mask, _sdpa_mask_value(query.dtype))
+        context = _fp32_scaled_dot_product_attention(
+            query, keys, values, attn_mask=additive
+        )
+        context = context.view(batch, heads, canvas, head_dim).transpose(1, 2).reshape(
+            batch, canvas, self.kv_rank
+        )
+        output = self.o_proj(context)
+        keep = has_hist.unsqueeze(-1)
+        return torch.where(keep, output, output.new_zeros(output.shape))
+
+
+class _QueryOutputAttention(nn.Module):
+    """Q/O attention against precomputed K/V."""
+
+    def __init__(self, dim: int, num_heads: int, kv_rank: int) -> None:
+        super().__init__()
+        if kv_rank % num_heads:
+            raise ValueError("`kv_rank` must be divisible by `num_heads`.")
+        self.num_heads = num_heads
+        self.kv_rank = kv_rank
+        self.head_dim = kv_rank // num_heads
+        self.q_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.o_proj = nn.Linear(kv_rank, dim, bias=False)
+        self.q_norm = _RMSNorm(dim)
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+        attn_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        batch, queries, _dim = query.shape
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.q_proj(self.q_norm(query)).view(batch, queries, heads, head_dim).transpose(1, 2)
+        mask = attn_mask
+        keep_rows = None
+        if mask is not None and mask.ndim == 2:
+            if mask.shape[0] == batch:
+                if mask.dtype == torch.bool:
+                    keep_rows = mask.any(dim=-1)
+                    safe = mask.clone()
+                    safe[:, 0] = safe[:, 0] | ~keep_rows
+                    mask = safe
+                mask = mask.view(batch, 1, 1, mask.shape[-1])
+            else:
+                mask = mask.view(1, 1, queries, keys.shape[-2])
+        elif mask is not None and mask.ndim == 3:
+            mask = mask.unsqueeze(1)
+        if mask is not None and mask.dtype == torch.bool:
+            additive = torch.zeros(
+                mask.shape, device=query.device, dtype=query.dtype
+            )
+            mask = additive.masked_fill(~mask, _sdpa_mask_value(query.dtype))
+        context = _fp32_scaled_dot_product_attention(
+            query, keys, values, attn_mask=mask
+        )
+        context = context.transpose(1, 2).reshape(batch, queries, self.kv_rank)
+        output = self.o_proj(context)
+        if keep_rows is not None:
+            output = output * keep_rows.to(dtype=output.dtype).view(batch, 1, 1)
+        return output
+
+
+class _RankAttention(nn.Module):
+    """Sequence attention in a rank-``kv_rank`` subspace, then map back to ``dim``."""
+
+    def __init__(self, dim: int, num_heads: int, kv_rank: int) -> None:
+        super().__init__()
+        if kv_rank % num_heads:
+            raise ValueError("`kv_rank` must be divisible by `num_heads`.")
+        self.num_heads = num_heads
+        self.kv_rank = kv_rank
+        self.head_dim = kv_rank // num_heads
+        self.q_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.k_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.v_proj = nn.Linear(dim, kv_rank, bias=False)
+        self.o_proj = nn.Linear(kv_rank, dim, bias=False)
+        self.q_norm = _RMSNorm(dim)
+        self.k_norm = _RMSNorm(dim)
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+        attn_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        batch, queries, _dim = query.shape
+        key_len = keys.shape[1]
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.q_proj(self.q_norm(query)).view(batch, queries, heads, head_dim).transpose(1, 2)
+        keys = self.k_proj(self.k_norm(keys)).view(batch, key_len, heads, head_dim).transpose(1, 2)
+        values = self.v_proj(values).view(batch, key_len, heads, head_dim).transpose(1, 2)
+        mask = attn_mask
+        if mask is not None and mask.ndim == 2:
+            mask = mask.view(1, 1, queries, key_len)
+        elif mask is not None and mask.ndim == 3:
+            mask = mask.unsqueeze(1)
+        context = _fp32_scaled_dot_product_attention(
+            query, keys, values, attn_mask=mask
+        )
+        context = context.transpose(1, 2).reshape(batch, queries, self.kv_rank)
+        return self.o_proj(context)
+
+
+class _ProcessorBlock(nn.Module):
+    """History-read canvas state, local or global mixing, read-only slot CA, SwiGLU."""
+
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        local_attention_window: int,
+        kv_rank: int,
+        ffn_dim: int,
+        *,
+        global_attention: bool,
+    ) -> None:
+        super().__init__()
+        self.history_attention = _HistoryAttention(dim, num_heads, kv_rank)
+        self.state_norm = _RMSNorm(dim)
+        self.local_attention = _RankAttention(dim, num_heads, kv_rank)
+        self.local_attention_window = local_attention_window
+        self.global_attention = global_attention
+        self.register_buffer("_local_attention_mask", torch.empty(0), persistent=False)
+        self.token_memory_attention = _QueryOutputAttention(dim, num_heads, kv_rank)
+        self.tape_attention = _QueryOutputAttention(dim, num_heads, kv_rank)
+        self.token_ff_norm = _RMSNorm(dim)
+        self.ff = _SwiGLU(dim, ffn_dim)
+
+    def _local_mask(self, canvas: int, device: torch.device, dtype: torch.dtype) -> torch.Tensor:
+        if (
+            self._local_attention_mask.shape != (canvas, canvas)
+            or self._local_attention_mask.device != device
+            or self._local_attention_mask.dtype != dtype
+        ):
+            positions = torch.arange(canvas, device=device)
+            allowed = (positions[:, None] - positions[None, :]).abs() < self.local_attention_window
+            mask = torch.zeros(canvas, canvas, device=device, dtype=dtype)
+            self._local_attention_mask = mask.masked_fill(~allowed, _sdpa_mask_value(dtype))
+        return self._local_attention_mask
+
+    def forward(
+        self,
+        canvas_state: torch.Tensor,
+        history_keys: torch.Tensor,
+        history_values: torch.Tensor,
+        attn_bias: torch.Tensor,
+        key_mask: torch.Tensor,
+        memory_keys: torch.Tensor,
+        memory_values: torch.Tensor,
+        history_query: torch.Tensor,
+        tape_keys: torch.Tensor | None = None,
+        tape_values: torch.Tensor | None = None,
+        tape_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        canvas_state = canvas_state + self.history_attention(
+            history_query, history_keys, history_values,
+            attn_bias=attn_bias, key_mask=key_mask,
+        )
+        if tape_keys is not None and tape_values is not None:
+            canvas_state = canvas_state + self.tape_attention(
+                self.state_norm(canvas_state), tape_keys, tape_values, attn_mask=tape_mask
+            )
+        normalized = self.state_norm(canvas_state)
+        attn_mask = None if self.global_attention else self._local_mask(
+            canvas_state.shape[1], canvas_state.device, canvas_state.dtype
+        )
+        canvas_state = canvas_state + self.local_attention(
+            normalized, normalized, normalized, attn_mask=attn_mask
+        )
+        normalized = self.state_norm(canvas_state)
+        canvas_state = canvas_state + self.token_memory_attention(
+            normalized, memory_keys, memory_values
+        )
+        return canvas_state + self.ff(self.token_ff_norm(canvas_state))
+
+
+class DecoderMemoryBus(nn.Module):
+    """Sidecar readers on full-attention decoder layers.
+
+    ``alpha`` starts at 0 so the residual is zero. Scale with ``tanh(alpha)``
+    rather than a hard ``where(alpha == 0)`` so the gate stays differentiable.
+    ``o_proj`` is *not* zeroed: that pair was a dead-gradient product.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_heads: int,
+        num_readers: int,
+        memory_dim: int,
+        kv_rank: int,
+        *,
+        relative_bias: bool = False,
+        address_with_identity: bool = False,
+        max_relative_span: int = 256,
+    ) -> None:
+        super().__init__()
+        if num_readers > 0:
+            if kv_rank % num_heads:
+                raise ValueError("Memory bus rank must be divisible by heads.")
+            if hidden_size % num_heads:
+                raise ValueError("Memory bus hidden size must be divisible by heads.")
+        self.hidden_size = hidden_size
+        self.num_heads = num_heads
+        self.num_readers = num_readers
+        self.kv_rank = kv_rank
+        self.head_dim = kv_rank // num_heads if num_heads else kv_rank
+        self.relative_bias = relative_bias
+        self.address_with_identity = address_with_identity
+        self.memory_norm = _RMSNorm(memory_dim)
+        self.address_norm = _RMSNorm(memory_dim)
+        self.memory_to_hidden = (
+            nn.Identity()
+            if memory_dim == hidden_size
+            else nn.Linear(memory_dim, hidden_size, bias=False)
+        )
+        self.k_proj = nn.Linear(hidden_size, kv_rank, bias=False)
+        self.v_proj = nn.Linear(hidden_size, kv_rank, bias=False)
+        self.q_norm = _RMSNorm(hidden_size)
+        self.q_proj = nn.ModuleList(
+            [nn.Linear(hidden_size, kv_rank, bias=False) for _ in range(num_readers)]
+        )
+        self.o_proj = nn.ModuleList(
+            [nn.Linear(kv_rank, hidden_size, bias=False) for _ in range(num_readers)]
+        )
+        self.alpha = nn.Parameter(torch.zeros(max(num_readers, 1), max(num_heads, 1)))
+        span = max(2 * max_relative_span - 1, 1)
+        self.rel_bias = nn.Parameter(torch.zeros(max(num_heads, 1), span))
+        self.max_relative_span = max_relative_span
+        self.enabled = False
+        self.freeze()
+
+    def freeze(self) -> None:
+        self.enabled = False
+        for parameter in self.parameters():
+            parameter.requires_grad_(False)
+
+    def unfreeze(self) -> None:
+        if self.num_readers <= 0:
+            return
+        self.enabled = True
+        for parameter in self.parameters():
+            parameter.requires_grad_(True)
+
+    def prepare_kv(
+        self,
+        memory: torch.Tensor,
+        slot_identity: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor] | None:
+        if self.num_readers <= 0:
+            return None
+        if self.training and not self.enabled:
+            return None
+        if self.address_with_identity:
+            if slot_identity is None:
+                raise ValueError("Persistent bus requires slot identity on keys.")
+            mapped_keys = self.memory_to_hidden(self.address_norm(memory + slot_identity))
+            mapped_values = self.memory_to_hidden(self.memory_norm(memory))
+        else:
+            mapped_keys = mapped_values = self.memory_to_hidden(self.memory_norm(memory))
+        batch, slots, _dim = mapped_keys.shape
+        heads = self.num_heads
+        head_dim = self.head_dim
+        keys = self.k_proj(mapped_keys).view(batch, slots, heads, head_dim).transpose(1, 2)
+        values = self.v_proj(mapped_values).view(batch, slots, heads, head_dim).transpose(1, 2)
+        return keys, values
+
+    def _relative_mask(self, queries: int, keys: int, device: torch.device, dtype: torch.dtype) -> torch.Tensor | None:
+        if not self.relative_bias:
+            return None
+        q = torch.arange(queries, device=device)
+        k = torch.arange(keys, device=device)
+        rel = (q[:, None] - k[None, :] + (keys - 1)).clamp(0, self.rel_bias.shape[1] - 1)
+        return self.rel_bias[:, rel].to(dtype=dtype)
+
+    def read(
+        self,
+        hidden: torch.Tensor,
+        reader_index: int,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+    ) -> torch.Tensor:
+        batch, canvas, _dim = hidden.shape
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.q_proj[reader_index](self.q_norm(hidden))
+        query = query.view(batch, canvas, heads, head_dim).transpose(1, 2)
+        bias = self._relative_mask(canvas, keys.shape[2], hidden.device, query.dtype)
+        if bias is not None:
+            bias = bias.unsqueeze(0)
+        context = _fp32_scaled_dot_product_attention(
+            query, keys, values, attn_mask=bias
+        )
+        scale = torch.tanh(self.alpha[reader_index]).to(dtype=hidden.dtype).view(1, heads, 1, 1)
+        context = context * scale
+        context = context.transpose(1, 2).reshape(batch, canvas, self.kv_rank)
+        return hidden + self.o_proj[reader_index](context)
+
+    @torch.no_grad()
+    def reset_identity_parameters(self) -> None:
+        self.alpha.zero_()
+        self.rel_bias.zero_()
+
+
+class _SequenceBlock(nn.Module):
+    def __init__(self, dim: int, num_heads: int, ffn_dim: int) -> None:
+        super().__init__()
+        self.attn = _RankAttention(dim, num_heads, dim)
+        self.norm = _RMSNorm(dim)
+        self.ff_norm = _RMSNorm(dim)
+        self.ff = _SwiGLU(dim, ffn_dim)
+
+    def forward(self, hidden: torch.Tensor, attn_mask: torch.Tensor | None) -> torch.Tensor:
+        normalized = self.norm(hidden)
+        hidden = hidden + self.attn(normalized, normalized, normalized, attn_mask=attn_mask)
+        return hidden + self.ff(self.ff_norm(hidden))
+
+
+class ExperienceRoleEncoder(nn.Module):
+    """Three role queries over a committed token's packed rank-space trajectory."""
+
+    def __init__(self, rank: int, num_heads: int, hidden_size: int) -> None:
+        super().__init__()
+        self.rank = rank
+        self.num_heads = num_heads
+        self.head_dim = rank // num_heads
+        self.role_queries = nn.Parameter(torch.empty(_EXPERIENCE_ROLES, rank))
+        self.working_proj = nn.Linear(hidden_size, rank, bias=False)
+        self.q_proj = nn.Linear(rank, rank, bias=False)
+        self.k_proj = nn.Linear(rank, rank, bias=False)
+        self.v_proj = nn.Linear(rank, rank, bias=False)
+        self.o_proj = nn.Linear(rank, rank, bias=False)
+        self.reason_embed = nn.Embedding(COMMIT_REASON_COUNT, rank)
+        self.reset_parameters()
+
+    @torch.no_grad()
+    def reset_parameters(self) -> None:
+        nn.init.normal_(self.role_queries, mean=0.0, std=0.02)
+
+    def forward(
+        self,
+        *,
+        working_state: torch.Tensor,
+        history_keys: torch.Tensor,
+        history_values: torch.Tensor,
+        history_mask: torch.Tensor,
+        z_final: torch.Tensor,
+        commit_reason: torch.Tensor,
+    ) -> torch.Tensor:
+        batch, canvas, slots, rank = history_keys.shape
+        working = self.working_proj(working_state)
+        extra = torch.stack((z_final, working), dim=2)
+        keys = torch.cat((history_keys, extra), dim=2)
+        values = torch.cat((history_values, extra), dim=2)
+        extra_mask = torch.ones(batch, canvas, 2, device=history_mask.device, dtype=torch.bool)
+        mask = torch.cat((history_mask, extra_mask), dim=2)
+        roles = self.role_queries.to(dtype=keys.dtype).view(1, 1, _EXPERIENCE_ROLES, rank)
+        roles = roles.expand(batch, canvas, -1, -1)
+        reason = self.reason_embed(commit_reason.clamp(0, COMMIT_REASON_COUNT - 1))
+        roles = roles + reason.to(dtype=roles.dtype).view(batch, 1, 1, rank)
+        heads = self.num_heads
+        head_dim = self.head_dim
+        query = self.q_proj(roles).view(batch, canvas, _EXPERIENCE_ROLES, heads, head_dim)
+        query = query.permute(0, 3, 1, 2, 4).reshape(
+            batch * heads * canvas, _EXPERIENCE_ROLES, head_dim
+        )
+        key = self.k_proj(keys).view(batch, canvas, slots + 2, heads, head_dim)
+        key = key.permute(0, 3, 1, 2, 4).reshape(batch * heads * canvas, slots + 2, head_dim)
+        value = self.v_proj(values).view(batch, canvas, slots + 2, heads, head_dim)
+        value = value.permute(0, 3, 1, 2, 4).reshape(batch * heads * canvas, slots + 2, head_dim)
+        attn_mask = mask.view(batch, 1, canvas, 1, slots + 2)
+        attn_mask = attn_mask.expand(-1, heads, -1, _EXPERIENCE_ROLES, -1)
+        attn_mask = attn_mask.reshape(batch * heads * canvas, _EXPERIENCE_ROLES, slots + 2)
+        additive = torch.zeros(
+            query.shape[0],
+            query.shape[1],
+            key.shape[1],
+            device=query.device,
+            dtype=query.dtype,
+        )
+        additive = additive.masked_fill(~attn_mask, _sdpa_mask_value(query.dtype))
+        context = _fp32_scaled_dot_product_attention(
+            query, key, value, attn_mask=additive
+        )
+        context = context.view(batch, heads, canvas, _EXPERIENCE_ROLES, head_dim)
+        context = context.permute(0, 2, 3, 1, 4).reshape(batch, canvas, _EXPERIENCE_ROLES, rank)
+        return self.o_proj(context)
+
+
+class CommitSequenceTransformer(nn.Module):
+    """Bidirectional phrase-level mixer over 3L experience role tokens."""
+
+    def __init__(self, dim: int, num_heads: int, num_layers: int, ffn_dim: int) -> None:
+        super().__init__()
+        self.role_embed = nn.Embedding(_EXPERIENCE_ROLES, dim)
+        self.blocks = nn.ModuleList(
+            [_SequenceBlock(dim, num_heads, ffn_dim) for _ in range(num_layers)]
+        )
+        self.norm = _RMSNorm(dim)
+
+    def forward(
+        self,
+        tokens: torch.Tensor,
+        positions: torch.Tensor,
+        valid: torch.Tensor,
+    ) -> torch.Tensor:
+        batch, length, dim = tokens.shape
+        roles = torch.arange(_EXPERIENCE_ROLES, device=tokens.device).repeat(length // _EXPERIENCE_ROLES + 1)
+        roles = roles[:length]
+        hidden = tokens + self.role_embed(roles).to(dtype=tokens.dtype)
+        heads = self.blocks[0].attn.num_heads
+        head_dim = dim // heads
+        hidden = hidden.view(batch, length, heads, head_dim).transpose(1, 2)
+        hidden = _apply_rotary(hidden, positions)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, dim)
+        keep_rows = valid.any(dim=-1)
+        safe = valid.clone()
+        if length > 0:
+            safe[:, 0] = safe[:, 0] | ~keep_rows
+        keep = safe.unsqueeze(1) & safe.unsqueeze(2)
+        attn_mask = torch.zeros(
+            batch, length, length, device=tokens.device, dtype=tokens.dtype
+        )
+        attn_mask = attn_mask.masked_fill(
+            ~keep, _sdpa_mask_value(tokens.dtype)
+        )
+        for block in self.blocks:
+            hidden = block(hidden, attn_mask)
+        hidden = self.norm(hidden)
+        return torch.where(valid.unsqueeze(-1), hidden, hidden.new_zeros(hidden.shape))
+
+
+class TransformerCommitWriter(nn.Module):
+    """Identity-init slot-gated persistent write."""
+
+    def __init__(
+        self,
+        dim: int,
+        rank: int,
+        num_heads: int,
+        ffn_dim: int,
+        experience_dim: int,
+    ) -> None:
+        super().__init__()
+        self.cross = _RankAttention(dim, num_heads, rank)
+        self.experience_up = (
+            nn.Identity()
+            if experience_dim == dim
+            else nn.Linear(experience_dim, dim, bias=False)
+        )
+        self.self_attn = _RankAttention(dim, num_heads, rank)
+        self.ff = _SwiGLU(dim, ffn_dim)
+        self.ff_norm = _RMSNorm(dim)
+        self.norm = _RMSNorm(dim)
+        self.gate = nn.Linear(dim * 2, 1, bias=True)
+        self.beta_write = nn.Parameter(torch.zeros(()))
+        self.gamma_ca = nn.Parameter(torch.tensor(0.1))
+        self.gamma_sa = nn.Parameter(torch.zeros(()))
+        self.gamma_ffn = nn.Parameter(torch.tensor(0.1))
+        self.reset_identity_parameters()
+
+    @torch.no_grad()
+    def reset_identity_parameters(self) -> None:
+        nn.init.zeros_(self.gate.weight)
+        nn.init.constant_(self.gate.bias, _GATE_BIAS)
+        self.beta_write.zero_()
+        self.gamma_sa.zero_()
+        self.gamma_ca.copy_(self.gamma_ca.new_tensor(0.1))
+        self.gamma_ffn.copy_(self.gamma_ffn.new_tensor(0.1))
+
+    def forward(
+        self,
+        memory: torch.Tensor,
+        experience: torch.Tensor,
+        experience_mask: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        mapped = self.experience_up(experience)
+        row_has_experience = experience_mask.any(dim=-1)
+        safe_mask = experience_mask
+        if experience_mask.shape[-1] > 0:
+            safe_mask = experience_mask.clone()
+            safe_mask[:, 0] = safe_mask[:, 0] | ~row_has_experience
+        keep = safe_mask.unsqueeze(1) & torch.ones(
+            memory.shape[0], memory.shape[1], 1, device=memory.device, dtype=torch.bool
+        )
+        attn_mask = torch.zeros(
+            memory.shape[0],
+            memory.shape[1],
+            mapped.shape[1],
+            device=memory.device,
+            dtype=memory.dtype,
+        )
+        attn_mask = attn_mask.masked_fill(~keep, _sdpa_mask_value(memory.dtype))
+        delta_ca = self.cross(self.norm(memory), mapped, mapped, attn_mask=attn_mask)
+        hidden = memory + self.gamma_ca.to(dtype=memory.dtype) * delta_ca
+        delta_sa = self.self_attn(self.norm(hidden), hidden, hidden)
+        hidden = hidden + self.gamma_sa.to(dtype=memory.dtype) * delta_sa
+        delta_ff = self.ff(self.ff_norm(hidden))
+        proposed = hidden + self.gamma_ffn.to(dtype=memory.dtype) * delta_ff
+        delta = proposed - memory
+        gate = torch.sigmoid(self.gate(torch.cat((memory, proposed), dim=-1)))
+        scale = torch.tanh(self.beta_write).to(dtype=memory.dtype)
+        written = memory + scale * gate * delta
+        written = torch.where(row_has_experience.view(memory.shape[0], 1, 1), written, memory)
+        return written, gate, delta
+
+
+class LatentDeliberationTransformer(nn.Module):
+    """Working trajectory processor plus commit-only persistent writer."""
+
+    def __init__(
+        self,
+        *,
+        hidden_size: int,
+        vocab_size: int,
+        latent_dim: int = 2816,
+        ffn_dim: int = 7168,
+        memory_slots: int = 256,
+        num_layers: int = 4,
+        num_heads: int = 16,
+        local_attention_window: int = 128,
+        dropout: float = 0.0,
+        history_length: int = 16,
+        tape_probes: int = 16,
+        history_kv_rank: int = 1024,
+        num_memory_readers: int = 0,
+        num_working_readers: int | None = None,
+        num_persistent_readers: int | None = None,
+        working_last_block_global: bool = True,
+        experience_roles: int = _EXPERIENCE_ROLES,
+        commit_sequence_layers: int = 2,
+        commit_sequence_dim: int | None = None,
+        writer_ffn_dim: int | None = None,
+        max_canvas_length: int = 256,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        del dropout, experience_roles
+        if latent_dim % num_heads:
+            raise ValueError("`latent_dim` must be divisible by `num_heads`.")
+        if local_attention_window <= 0:
+            raise ValueError("`local_attention_window` must be positive.")
+        if history_length <= 0:
+            raise ValueError("`history_length` must be positive.")
+        if ffn_dim <= 0:
+            raise ValueError("`ffn_dim` must be positive.")
+        if history_kv_rank % num_heads or history_kv_rank > latent_dim:
+            raise ValueError("Invalid history K/V rank.")
+        self.hidden_size = hidden_size
+        self.vocab_size = vocab_size
+        self.latent_dim = latent_dim
+        self.memory_slots = memory_slots
+        self.history_length = history_length
+        self.tape_probes = int(tape_probes)
+        if self.tape_probes <= 0:
+            raise ValueError("`tape_probes` must be positive.")
+        self.history_views = _HISTORY_VIEWS
+        self.log_vocab = math.log(max(vocab_size, 2))
+        packet_dim = int(commit_sequence_dim or history_kv_rank)
+        if packet_dim % num_heads:
+            raise ValueError("`commit_sequence_dim` must be divisible by `num_heads`.")
+        self.packet_dim = packet_dim
+        self.history_in = (
+            nn.Identity()
+            if hidden_size == latent_dim
+            else nn.Linear(hidden_size, latent_dim, bias=False)
+        )
+        self.query_in = (
+            nn.Identity()
+            if hidden_size == latent_dim
+            else nn.Linear(hidden_size, latent_dim, bias=False)
+        )
+        self.history_projector = SharedHistoryProjector(latent_dim, history_kv_rank)
+        self.tape_pool = CanvasProbePool(history_kv_rank, self.tape_probes, num_heads)
+        self.persistent_kv = SharedPersistentKV(latent_dim, num_heads, history_kv_rank)
+        self.bias_in = nn.Linear(
+            _KEY_META_DIM + _QUERY_META_DIM + _ROW_META_DIM, _METADATA_HIDDEN, bias=True
+        )
+        self.bias_out = nn.Linear(_METADATA_HIDDEN, num_heads, bias=True)
+        nn.init.zeros_(self.bias_out.weight)
+        nn.init.zeros_(self.bias_out.bias)
+        self.film_in = nn.Linear(_KEY_META_DIM, _FILM_RANK, bias=True)
+        self.film_out = nn.Linear(_FILM_RANK, 2 * history_kv_rank, bias=True)
+        nn.init.zeros_(self.film_out.weight)
+        nn.init.zeros_(self.film_out.bias)
+        self.blocks = nn.ModuleList(
+            [
+                _ProcessorBlock(
+                    latent_dim,
+                    num_heads,
+                    local_attention_window,
+                    history_kv_rank,
+                    ffn_dim,
+                    global_attention=bool(
+                        working_last_block_global and index == num_layers - 1
+                    ),
+                )
+                for index in range(num_layers)
+            ]
+        )
+        self.output_norm = _RMSNorm(latent_dim)
+        self.output_to_hidden = (
+            nn.Identity()
+            if hidden_size == latent_dim
+            else nn.Linear(latent_dim, hidden_size, bias=False)
+        )
+        self.memory_slot_identity = nn.Parameter(torch.empty(memory_slots, latent_dim))
+        bus_heads = num_heads if hidden_size % num_heads == 0 else 1
+        bus_rank = history_kv_rank if history_kv_rank % bus_heads == 0 else bus_heads
+        working_readers = num_memory_readers if num_working_readers is None else num_working_readers
+        persistent_readers = (
+            num_memory_readers if num_persistent_readers is None else num_persistent_readers
+        )
+        self.working_memory_bus = DecoderMemoryBus(
+            hidden_size=hidden_size,
+            num_heads=bus_heads,
+            num_readers=working_readers,
+            memory_dim=hidden_size,
+            kv_rank=bus_rank,
+            relative_bias=True,
+            address_with_identity=False,
+            max_relative_span=max_canvas_length,
+        )
+        self.persistent_memory_bus = DecoderMemoryBus(
+            hidden_size=hidden_size,
+            num_heads=bus_heads,
+            num_readers=persistent_readers,
+            memory_dim=latent_dim,
+            kv_rank=bus_rank,
+            relative_bias=False,
+            address_with_identity=True,
+            max_relative_span=max_canvas_length,
+        )
+        self.experience_encoder = ExperienceRoleEncoder(
+            packet_dim, num_heads, hidden_size
+        )
+        self.commit_sequence = CommitSequenceTransformer(
+            packet_dim,
+            num_heads,
+            commit_sequence_layers,
+            max(packet_dim * 2, packet_dim),
+        )
+        self.commit_writer = TransformerCommitWriter(
+            latent_dim,
+            history_kv_rank,
+            num_heads,
+            writer_ffn_dim or ffn_dim,
+            packet_dim,
+        )
+        self.reset_identity_parameters()
+
+    @property
+    def memory_bus(self) -> DecoderMemoryBus:
+        return self.persistent_memory_bus
+
+    @torch.no_grad()
+    def reset_memory_slot_identity(self) -> None:
+        workspace = torch.empty_like(self.memory_slot_identity, dtype=torch.float32)
+        if self.memory_slots <= self.latent_dim:
+            nn.init.orthogonal_(workspace)
+        else:
+            nn.init.normal_(workspace, mean=0.0, std=1.0)
+            workspace = F.normalize(workspace, dim=-1)
+        self.memory_slot_identity.copy_(workspace.to(dtype=self.memory_slot_identity.dtype))
+
+    @torch.no_grad()
+    def reset_identity_parameters(self) -> None:
+        """Initialize direct parameters after generic PreTrainedModel init."""
+
+        self.reset_memory_slot_identity()
+        # These direct Parameters are created on `meta` during low-memory
+        # from_pretrained loading. Generic initialization covers Linear,
+        # Embedding, and RMSNorm modules, but not standalone query tensors.
+        self.tape_pool.reset_parameters()
+        self.experience_encoder.reset_parameters()
+        nn.init.zeros_(self.bias_out.weight)
+        nn.init.zeros_(self.bias_out.bias)
+        nn.init.zeros_(self.film_out.weight)
+        nn.init.zeros_(self.film_out.bias)
+        self.commit_writer.reset_identity_parameters()
+        self.working_memory_bus.reset_identity_parameters()
+        self.persistent_memory_bus.reset_identity_parameters()
+
+    def scaled_memory_slot_identity(
+        self,
+        *,
+        batch_size: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> torch.Tensor:
+        identity = F.normalize(self.memory_slot_identity.float(), dim=-1)
+        identity = identity * math.sqrt(self.latent_dim)
+        return identity.to(device=device, dtype=dtype).unsqueeze(0).expand(
+            batch_size, -1, -1
+        )
+
+    def project_context(self, canvas_state: torch.Tensor) -> torch.Tensor:
+        return self.output_to_hidden(self.output_norm(canvas_state))
+
+    def encode_tape_frame(
+        self,
+        hidden: torch.Tensor,
+        live_mask: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Compress a detached canvas snapshot into tape probes."""
+
+        projected = self.history_projector(self.history_in(hidden.detach()))
+        if not bool(torch.isfinite(projected.detach()).all()):
+            raise FloatingPointError("Non-finite trajectory tape projection.")
+        probes = self.tape_pool(projected, live_mask)
+        # Materialize the MPS FP32 reduction before the probes enter the
+        # recurrent ring.  Besides fail-fast validation, this is a required
+        # producer/consumer barrier for the next BF16 denoise on MPS.
+        if not bool(torch.isfinite(probes.detach()).all()):
+            raise FloatingPointError("Non-finite trajectory tape probes.")
+        if live_mask is None:
+            valid = torch.ones(hidden.shape[0], device=hidden.device, dtype=torch.bool)
+        else:
+            valid = live_mask.to(device=hidden.device, dtype=torch.bool).any(dim=-1)
+        return probes, valid
+
+    def _tape_keys(
+        self,
+        tape: TrajectoryTape,
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor] | tuple[None, None, None]:
+        if not bool(tape.valid.any()):
+            return None, None, None
+        rank = self.tape_pool.rank
+        heads = self.tape_pool.num_heads
+        head_dim = self.tape_pool.head_dim
+        batch, tape_length, probes, probe_dim = tape.probes.shape
+        if probe_dim != rank:
+            raise ValueError("Tape probe width does not match the projector rank.")
+        keys = tape.probes.to(dtype=dtype).reshape(batch, tape_length * probes, heads, head_dim)
+        keys = keys.transpose(1, 2)
+        mask = tape.valid.unsqueeze(-1).expand(-1, -1, probes).reshape(batch, tape_length * probes)
+        return keys, keys, mask
+
+    def _geometry(self, history: TrajectoryHistory) -> dict[str, torch.Tensor]:
+        valid = history.valid
+        batch, history_length, canvas, hidden_size = history.hidden.shape
+        velocity = torch.zeros(
+            batch, history_length, canvas,
+            device=history.hidden.device, dtype=torch.float32,
+        )
+        acceleration = torch.zeros_like(velocity)
+        reversal = torch.zeros_like(velocity)
+        recurrence = torch.zeros_like(velocity)
+        osc = torch.zeros_like(velocity)
+        scale = math.sqrt(max(hidden_size, 1))
+
+        # Geometry is diagnostic conditioning over a detached history ring.
+        # Processing one time edge at a time keeps only three FP32 frames and
+        # two deltas live instead of materializing FP32 hidden/delta/accel for
+        # the complete [B, H, C, D] ring.  Each scalar uses the same FP32
+        # subtraction, norm, and cosine operations as the dense formulation.
+        if history_length > 1:
+            previous_previous: torch.Tensor | None = None
+            previous = history.hidden[:, 0].float()
+            previous_delta: torch.Tensor | None = None
+            for index in range(1, history_length):
+                current = history.hidden[:, index].float()
+                delta = current - previous
+                velocity[:, index] = delta.norm(dim=-1) / scale
+                if previous_previous is not None and previous_delta is not None:
+                    accel = current - 2.0 * previous + previous_previous
+                    acceleration[:, index] = accel.norm(dim=-1) / scale
+                    reversal[:, index] = -_safe_cosine(delta, previous_delta)
+                    recurrence[:, index] = _safe_cosine(current, previous_previous)
+                    osc[:, index] = (
+                        recurrence[:, index] - _safe_cosine(current, previous)
+                    )
+                previous_previous = previous
+                previous = current
+                previous_delta = delta
+        raw_mask = valid
+        delta_mask = valid.clone()
+        delta_mask[:, 0] = False
+        if valid.shape[1] > 1:
+            delta_mask[:, 1:] = valid[:, 1:] & valid[:, :-1]
+        accel_mask = valid.clone()
+        accel_mask[:, :2] = False
+        if valid.shape[1] > 2:
+            accel_mask[:, 2:] = valid[:, 2:] & valid[:, 1:-1] & valid[:, :-2]
+        return {
+            "velocity": velocity.masked_fill(~delta_mask, 0.0),
+            "acceleration": acceleration.masked_fill(~accel_mask, 0.0),
+            "reversal": reversal.masked_fill(~accel_mask, 0.0),
+            "recurrence": recurrence.masked_fill(~accel_mask, 0.0),
+            "oscillation": osc.masked_fill(~accel_mask, 0.0),
+            "raw_mask": raw_mask,
+            "delta_mask": delta_mask,
+            "accel_mask": accel_mask,
+        }
+
+    def _frame_metadata(
+        self,
+        history: TrajectoryHistory,
+        state: LatentDeliberationState,
+        dtype: torch.dtype,
+        geometry: dict[str, torch.Tensor],
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch, history_length, canvas, _dim = history.hidden.shape
+        log_vocab = self.log_vocab
+        confidence = _renorm_confidence(history.confidence.to(dtype=dtype))
+        entropy = (history.entropy.to(dtype=dtype) / log_vocab).clamp(0.0, 1.0)
+        if history_length == 1:
+            recency = torch.ones(
+                batch, history_length, canvas, device=history.hidden.device, dtype=dtype
+            )
+        else:
+            recency = torch.linspace(
+                0.0, 1.0, history_length, device=history.hidden.device, dtype=dtype
+            )
+            recency = recency.view(1, history_length, 1).expand(batch, history_length, canvas)
+        retirement = torch.zeros(
+            batch, history_length, canvas, device=history.hidden.device, dtype=dtype
+        )
+        oldest = min(_RETIREMENT_FRAMES, history_length)
+        if oldest:
+            scale = torch.linspace(
+                1.0, 1.0 / oldest, oldest, device=history.hidden.device, dtype=dtype
+            )
+            retirement[:, :oldest] = scale.view(1, oldest, 1)
+            retirement = retirement * history.valid.to(dtype=dtype)
+        changed = history.token_changed.to(dtype=dtype)
+        delta_c = torch.zeros_like(confidence)
+        delta_e = torch.zeros_like(entropy)
+        if history_length > 1:
+            delta_c[:, 1:] = (confidence[:, 1:] - confidence[:, :-1]).clamp(-1.0, 1.0)
+            delta_e[:, 1:] = ((history.entropy[:, 1:] - history.entropy[:, :-1]) / log_vocab).clamp(
+                -1.0, 1.0
+            ).to(dtype=dtype)
+        age = (
+            state.age.to(dtype=dtype).clamp_max(_AGE_MAX).log1p()
+            / math.log1p(_AGE_MAX)
+        )
+        age_frames = torch.zeros_like(confidence)
+        age_frames[:, -1] = age
+        key_meta = torch.stack(
+            (
+                confidence, entropy, age_frames, changed, delta_c, delta_e,
+                recency, retirement,
+                geometry["velocity"].to(dtype=dtype),
+                geometry["acceleration"].to(dtype=dtype),
+                geometry["reversal"].to(dtype=dtype),
+                geometry["recurrence"].to(dtype=dtype),
+                geometry["oscillation"].to(dtype=dtype),
+            ),
+            dim=-1,
+        )
+        query_scalars = torch.stack(
+            (
+                _renorm_confidence(state.confidence.to(dtype=dtype)),
+                (state.entropy.to(dtype=dtype) / log_vocab).clamp(0.0, 1.0),
+                age,
+                state.token_changed.to(dtype=dtype),
+                state.confidence_delta.to(dtype=dtype).clamp(-1.0, 1.0),
+                (state.entropy_delta.to(dtype=dtype) / log_vocab).clamp(-1.0, 1.0),
+            ),
+            dim=-1,
+        )
+        fourier = _canvas_fourier(canvas, history.hidden.device, dtype).unsqueeze(0).expand(
+            batch, -1, -1
+        )
+        query_meta = torch.cat((fourier, query_scalars), dim=-1)
+        ponder = (
+            state.ponder_steps.to(dtype=dtype).clamp_max(_PONDER_MAX).log1p()
+            / math.log1p(_PONDER_MAX)
+        )
+        stagnation = (
+            state.stagnation_steps.to(dtype=dtype).clamp_max(_STAGNATION_MAX).log1p()
+            / math.log1p(_STAGNATION_MAX)
+        )
+        row_meta = torch.stack((ponder, stagnation), dim=-1)
+        return key_meta, query_meta, row_meta, history.valid
+
+    def _history_views(
+        self,
+        history: TrajectoryHistory,
+        key_meta: torch.Tensor,
+        geometry: dict[str, torch.Tensor],
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        mapped = self.history_in(history.hidden.to(dtype=dtype))
+        projected = self.history_projector(mapped)
+        return self._views_from_projected(
+            projected, history, key_meta, geometry, dtype,
+            preformat_heads=True,
+        )
+
+    def _views_from_projected(
+        self,
+        projected: torch.Tensor,
+        history: TrajectoryHistory,
+        key_meta: torch.Tensor,
+        geometry: dict[str, torch.Tensor],
+        dtype: torch.dtype,
+        *,
+        preformat_heads: bool = False,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        valid = history.valid
+        raw_mask = geometry["raw_mask"]
+        delta_mask = geometry["delta_mask"]
+        accel_mask = geometry["accel_mask"]
+        latest_index = (
+            valid.to(torch.int64) * (
+                torch.arange(valid.shape[1], device=valid.device).view(1, -1, 1) + 1
+            )
+        ).amax(dim=1) - 1
+        has_latest = latest_index.ge(0)
+        latest_index = latest_index.clamp_min(0)
+        gather = latest_index.view(projected.shape[0], 1, projected.shape[2], 1).expand(
+            -1, 1, -1, projected.shape[-1]
+        )
+        z_latest = projected.gather(1, gather).squeeze(1)
+        residual = projected - z_latest.unsqueeze(1)
+        residual_mask = raw_mask & has_latest.unsqueeze(1)
+        if projected.shape[1] > 1:
+            delta = torch.cat(
+                (torch.zeros_like(projected[:, :1]), projected[:, 1:] - projected[:, :-1]),
+                dim=1,
+            )
+        else:
+            delta = torch.zeros_like(projected)
+        accel = torch.zeros_like(projected)
+        if projected.shape[1] > 2:
+            accel[:, 2:] = projected[:, 2:] - 2.0 * projected[:, 1:-1] + projected[:, :-2]
+        views = torch.stack((projected, delta, accel, residual), dim=2)
+        view_mask = torch.stack((raw_mask, delta_mask, accel_mask, residual_mask), dim=2)
+        film = self.film_out(F.silu(self.film_in(key_meta.to(dtype=dtype))))
+        scale, shift = film.chunk(2, dim=-1)
+        numeric_mask = view_mask.unsqueeze(-1).to(dtype=views.dtype)
+        # The unmasked `views` tensor is dead here.  Mask it in-place and use
+        # it as the key storage instead of allocating a second full copy.
+        # Applying the same mask again after the FiLM shift preserves invalid
+        # entries as exact zeros and leaves every valid entry unchanged.
+        views.mul_(numeric_mask)
+        values = views * (1.0 + scale.unsqueeze(2))
+        values.add_(shift.unsqueeze(2)).mul_(numeric_mask)
+        keys = views
+        batch, history_length, views_n, canvas, dim = keys.shape
+        if preformat_heads:
+            heads = self.blocks[0].history_attention.num_heads
+            head_dim = dim // heads
+            keys = keys.view(
+                batch, history_length, views_n, canvas, heads, head_dim
+            ).permute(0, 4, 3, 1, 2, 5).reshape(
+                batch, heads, canvas, history_length * views_n, head_dim
+            )
+            values = values.view(
+                batch, history_length, views_n, canvas, heads, head_dim
+            ).permute(0, 4, 3, 1, 2, 5).reshape(
+                batch, heads, canvas, history_length * views_n, head_dim
+            )
+        else:
+            keys = keys.permute(0, 3, 1, 2, 4).reshape(
+                batch, canvas, history_length * views_n, dim
+            )
+            values = values.permute(0, 3, 1, 2, 4).reshape(
+                batch, canvas, history_length * views_n, dim
+            )
+        key_mask = view_mask.permute(0, 3, 1, 2).reshape(batch, canvas, history_length * views_n)
+        return keys, values, key_mask, projected
+
+    def _attention_bias(
+        self,
+        key_meta: torch.Tensor,
+        query_meta: torch.Tensor,
+        row_meta: torch.Tensor,
+        view_mask: torch.Tensor,
+        num_heads: int,
+        dtype: torch.dtype,
+    ) -> torch.Tensor:
+        batch, history_length, canvas, _meta = key_meta.shape
+        views = _HISTORY_VIEWS
+        query = query_meta[:, None, :, :].expand(-1, history_length, -1, -1)
+        row = row_meta[:, None, None, :].expand(-1, history_length, canvas, -1)
+        packed = torch.cat((key_meta.to(dtype=dtype), query, row), dim=-1)
+        bias = self.bias_out(F.silu(self.bias_in(packed)))
+        bias = bias.permute(0, 3, 2, 1).unsqueeze(-1).expand(-1, -1, -1, -1, views)
+        return bias.reshape(batch, num_heads, canvas, history_length * views).to(dtype=dtype)
+
+    def forward(
+        self,
+        *,
+        token_embeddings: torch.Tensor,
+        confidence: torch.Tensor,
+        entropy: torch.Tensor,
+        state: LatentDeliberationState,
+        history: TrajectoryHistory,
+        tape: TrajectoryTape | None = None,
+    ) -> LatentProcessorOutput:
+        if token_embeddings.ndim != 3:
+            raise ValueError("`token_embeddings` must have shape [batch, canvas, hidden].")
+        batch_size, canvas_length, hidden_size = token_embeddings.shape
+        if hidden_size != self.hidden_size:
+            raise ValueError("Unexpected hidden size for latent deliberation.")
+        if state.memory_slots.shape != (batch_size, self.memory_slots, self.latent_dim):
+            raise ValueError("State memory slots do not match this module.")
+        if history.hidden.shape[:3] != (batch_size, self.history_length, canvas_length):
+            raise ValueError("Trajectory history does not match the current canvas.")
+        if state.age.dtype is not torch.int32:
+            raise TypeError("Latent deliberation ages must use int32.")
+        if tape is None:
+            tape = TrajectoryTape.empty(
+                batch_size=batch_size,
+                tape_length=self.history_length,
+                num_probes=self.tape_probes,
+                probe_dim=self.tape_pool.rank,
+                device=token_embeddings.device,
+                dtype=token_embeddings.dtype,
+            )
+        if tape.probes.shape[:2] != (batch_size, self.history_length):
+            raise ValueError("Trajectory tape does not match the current batch.")
+
+        dtype = token_embeddings.dtype
+        query = self.query_in(token_embeddings)
+        geometry = self._geometry(history)
+        key_meta, query_meta, row_meta, _valid = self._frame_metadata(
+            history, state, dtype, geometry
+        )
+        keys, values, key_mask, projected = self._history_views(
+            history, key_meta, geometry, dtype
+        )
+        num_heads = self.blocks[0].history_attention.num_heads
+        attn_bias = self._attention_bias(
+            key_meta, query_meta, row_meta, key_mask, num_heads, dtype
+        )
+        tape_keys, tape_values, tape_mask = self._tape_keys(tape, dtype)
+        # Working state accumulates from zero. Empty history and zero memory
+        # therefore produce a zero self-conditioning residual.
+        canvas_state = torch.zeros_like(query)
+        slot_identity = self.scaled_memory_slot_identity(
+            batch_size=batch_size, device=state.memory_slots.device, dtype=query.dtype
+        )
+        memory_keys, memory_values = self.persistent_kv(state.memory_slots, slot_identity)
+        for block in self.blocks:
+            canvas_state = block(
+                canvas_state, keys, values, attn_bias, key_mask,
+                memory_keys, memory_values, query,
+                tape_keys, tape_values, tape_mask,
+            )
+        context = self.project_context(canvas_state)
+        next_state = LatentDeliberationState(
+            memory_slots=state.memory_slots,
+            confidence=confidence.to(dtype=torch.float32),
+            entropy=entropy.to(dtype=torch.float32),
+            age=state.age,
+            token_changed=state.token_changed,
+            confidence_delta=state.confidence_delta,
+            entropy_delta=state.entropy_delta,
+            ponder_steps=state.ponder_steps,
+            stagnation_steps=state.stagnation_steps,
+        )
+        return LatentProcessorOutput(
+            context=context,
+            working_state=context,
+            state=next_state,
+            history_projected=projected,
+        )
+
+    def _slice_commit_canvas(
+        self,
+        *,
+        working_state: torch.Tensor,
+        history: TrajectoryHistory,
+        history_projected: torch.Tensor,
+        heavy_hidden: torch.Tensor,
+        max_commit: int,
+    ) -> tuple[torch.Tensor, TrajectoryHistory, torch.Tensor, torch.Tensor]:
+        return (
+            working_state[:, :max_commit],
+            TrajectoryHistory(
+                hidden=history.hidden[:, :, :max_commit],
+                confidence=history.confidence[:, :, :max_commit],
+                entropy=history.entropy[:, :, :max_commit],
+                token_changed=history.token_changed[:, :, :max_commit],
+                valid=history.valid[:, :, :max_commit],
+            ),
+            history_projected[:, :, :max_commit],
+            heavy_hidden[:, :max_commit],
+        )
+
+    def _experience_encoder_step(
+        self,
+        working_state: torch.Tensor,
+        history_keys: torch.Tensor,
+        history_values: torch.Tensor,
+        history_mask: torch.Tensor,
+        z_final: torch.Tensor,
+        commit_reason: torch.Tensor,
+    ) -> torch.Tensor:
+        return self.experience_encoder(
+            working_state=working_state,
+            history_keys=history_keys,
+            history_values=history_values,
+            history_mask=history_mask,
+            z_final=z_final,
+            commit_reason=commit_reason,
+        )
+
+    def _encode_experience_roles(
+        self,
+        *,
+        working_state: torch.Tensor,
+        history_keys: torch.Tensor,
+        history_values: torch.Tensor,
+        history_mask: torch.Tensor,
+        z_final: torch.Tensor,
+        commit_reason: torch.Tensor,
+    ) -> torch.Tensor:
+        canvas = int(working_state.shape[1])
+        stripe = min(_EXPERIENCE_CANVAS_STRIPE, canvas)
+        parts: list[torch.Tensor] = []
+        for start in range(0, canvas, stripe):
+            stop = min(start + stripe, canvas)
+            parts.append(
+                self._experience_encoder_step(
+                    working_state[:, start:stop],
+                    history_keys[:, start:stop],
+                    history_values[:, start:stop],
+                    history_mask[:, start:stop],
+                    z_final[:, start:stop],
+                    commit_reason,
+                )
+            )
+        return parts[0] if len(parts) == 1 else torch.cat(parts, dim=1)
+
+    def _pack_experience(
+        self,
+        *,
+        working_state: torch.Tensor,
+        history: TrajectoryHistory,
+        history_projected: torch.Tensor,
+        heavy_hidden: torch.Tensor,
+        commit_lengths: torch.Tensor,
+        prefix_lengths: torch.Tensor,
+        commit_reason: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch, canvas, _hidden = working_state.shape
+        max_commit = min(int(commit_lengths.max().clamp_min(0)), canvas)
+        if max_commit <= 0:
+            empty = working_state.new_zeros(batch, 0, self.packet_dim)
+            return empty, empty.new_zeros(batch, 0, dtype=torch.bool), empty.new_zeros(batch, 0)
+        working_state, history, history_projected, heavy_hidden = self._slice_commit_canvas(
+            working_state=working_state,
+            history=history,
+            history_projected=history_projected,
+            heavy_hidden=heavy_hidden,
+            max_commit=max_commit,
+        )
+        dtype = working_state.dtype
+        geometry = self._geometry(history)
+        key_meta, _query_meta, _row_meta, _valid = self._frame_metadata(
+            history,
+            LatentDeliberationState.empty(
+                batch_size=batch,
+                canvas_length=max_commit,
+                latent_dim=self.latent_dim,
+                memory_slots=self.memory_slots,
+                device=working_state.device,
+                dtype=dtype,
+            ),
+            dtype,
+            geometry,
+        )
+        keys, values, key_mask, _projected = self._views_from_projected(
+            history_projected.to(dtype=dtype), history, key_meta, geometry, dtype
+        )
+        # Heavy is a TBPTT observation here, same as history frames: CE already
+        # backpropagated through this decoder stack. The writer stays in the
+        # temporal graph via `working_state` and the committed memory output.
+        z_final = self.history_projector(
+            self.history_in(heavy_hidden.detach().to(dtype=dtype))
+        )
+        roles = self._encode_experience_roles(
+            working_state=working_state,
+            history_keys=keys,
+            history_values=values,
+            history_mask=key_mask,
+            z_final=z_final,
+            commit_reason=commit_reason,
+        )
+        tokens = roles.reshape(batch, max_commit * _EXPERIENCE_ROLES, -1)
+        token_valid = torch.arange(max_commit, device=working_state.device)[None, :] < commit_lengths[:, None]
+        valid = token_valid.unsqueeze(-1).expand(-1, -1, _EXPERIENCE_ROLES).reshape(
+            batch, max_commit * _EXPERIENCE_ROLES
+        )
+        abs_pos = prefix_lengths[:, None] + torch.arange(
+            max_commit, device=working_state.device
+        )[None, :]
+        pos = abs_pos.unsqueeze(-1).expand(-1, -1, _EXPERIENCE_ROLES).reshape(
+            batch, max_commit * _EXPERIENCE_ROLES
+        )
+        mixed = self.commit_sequence(tokens, pos, valid)
+        return mixed, valid, pos
+
+    def commit_write(
+        self,
+        *,
+        memory: torch.Tensor,
+        working_state: torch.Tensor,
+        history: TrajectoryHistory,
+        history_projected: torch.Tensor,
+        heavy_hidden: torch.Tensor,
+        commit_lengths: torch.Tensor,
+        prefix_lengths: torch.Tensor | None = None,
+        commit_reason: torch.Tensor | None = None,
+        **kwargs: Any,
+    ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        batch = memory.shape[0]
+        canvas = working_state.shape[1]
+        lengths = commit_lengths.to(device=memory.device, dtype=torch.long)
+        if prefix_lengths is None:
+            prefixes = torch.zeros(batch, device=memory.device, dtype=torch.long)
+        else:
+            prefixes = prefix_lengths.to(device=memory.device, dtype=torch.long)
+        if commit_reason is None:
+            reasons = torch.full(
+                (batch,), COMMIT_REASON_NORMAL, device=memory.device, dtype=torch.long
+            )
+        else:
+            reasons = commit_reason.to(device=memory.device, dtype=torch.long)
+        if bool((lengths <= 0).all()):
+            zero = memory.new_zeros(batch, self.memory_slots, 1)
+            return memory, {
+                "gate_mean": zero.mean(),
+                "gate_max": zero.amax(),
+                "gate_gt_01": zero.new_zeros(()),
+                "gate_gt_05": zero.new_zeros(()),
+                "delta_norm_mean": memory.new_zeros(()),
+            }
+        experience, experience_mask, _pos = self._pack_experience(
+            working_state=working_state,
+            history=history,
+            history_projected=history_projected,
+            heavy_hidden=heavy_hidden,
+            commit_lengths=lengths,
+            prefix_lengths=prefixes,
+            commit_reason=reasons,
+        )
+        max_commit = int(lengths.max())
+        role_stop = max_commit * _EXPERIENCE_ROLES
+        chunk_tokens = experience[:, :role_stop]
+        chunk_mask = experience_mask[:, :role_stop]
+        if chunk_tokens.shape[1] > 0:
+            written, last_gate, last_delta = self.commit_writer(
+                memory, chunk_tokens, chunk_mask
+            )
+        else:
+            written = memory
+            last_gate = memory.new_zeros(batch, self.memory_slots, 1)
+            last_delta = memory.new_zeros(memory.shape)
+        gate = last_gate.detach()
+        delta_norm = last_delta.detach().float().norm(dim=-1)
+        diagnostics = {
+            "gate_mean": gate.mean(),
+            "gate_max": gate.amax(),
+            "gate_gt_01": gate.gt(0.1).float().sum(),
+            "gate_gt_05": gate.gt(0.5).float().sum(),
+            "delta_norm_mean": delta_norm.mean(),
+        }
+        unchanged = lengths.le(0).view(batch, 1, 1)
+        written = torch.where(unchanged, memory, written)
+        return written, diagnostics
+
+
+def slice_trajectory_history(
+    history: TrajectoryHistory, rows: slice | torch.Tensor
+) -> TrajectoryHistory:
+    return TrajectoryHistory(
+        hidden=history.hidden[rows],
+        confidence=history.confidence[rows],
+        entropy=history.entropy[rows],
+        token_changed=history.token_changed[rows],
+        valid=history.valid[rows],
+    )
+
+
+def cat_trajectory_history(
+    histories: Sequence[TrajectoryHistory],
+) -> TrajectoryHistory:
+    return TrajectoryHistory(
+        hidden=torch.cat([history.hidden for history in histories], dim=0),
+        confidence=torch.cat([history.confidence for history in histories], dim=0),
+        entropy=torch.cat([history.entropy for history in histories], dim=0),
+        token_changed=torch.cat([history.token_changed for history in histories], dim=0),
+        valid=torch.cat([history.valid for history in histories], dim=0),
+    )
+
+
+def choose_trajectory_history(
+    previous: TrajectoryHistory,
+    updated: TrajectoryHistory,
+    update_mask: torch.Tensor,
+) -> TrajectoryHistory:
+    def choose(old: torch.Tensor, new: torch.Tensor) -> torch.Tensor:
+        mask = update_mask.view(update_mask.shape[0], *([1] * (old.ndim - 1)))
+        return torch.where(mask, new, old)
+
+    return TrajectoryHistory(
+        hidden=choose(previous.hidden, updated.hidden),
+        confidence=choose(previous.confidence, updated.confidence),
+        entropy=choose(previous.entropy, updated.entropy),
+        token_changed=choose(previous.token_changed, updated.token_changed),
+        valid=choose(previous.valid, updated.valid),
+    )
+
+
+def slice_trajectory_tape(
+    tape: TrajectoryTape, rows: slice | torch.Tensor
+) -> TrajectoryTape:
+    return TrajectoryTape(probes=tape.probes[rows], valid=tape.valid[rows])
+
+
+def cat_trajectory_tape(tapes: Sequence[TrajectoryTape]) -> TrajectoryTape:
+    return TrajectoryTape(
+        probes=torch.cat([tape.probes for tape in tapes], dim=0),
+        valid=torch.cat([tape.valid for tape in tapes], dim=0),
+    )
+
+
+def choose_trajectory_tape(
+    previous: TrajectoryTape,
+    updated: TrajectoryTape,
+    update_mask: torch.Tensor,
+) -> TrajectoryTape:
+    def choose(old: torch.Tensor, new: torch.Tensor) -> torch.Tensor:
+        mask = update_mask.view(update_mask.shape[0], *([1] * (old.ndim - 1)))
+        return torch.where(mask, new, old)
+
+    return TrajectoryTape(
+        probes=choose(previous.probes, updated.probes),
+        valid=choose(previous.valid, updated.valid),
+    )
+
+
+def empty_trajectory_tape(
+    *,
+    batch_size: int,
+    config: object,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> TrajectoryTape:
+    rank = int(getattr(config, "latent_history_kv_rank"))
+    return TrajectoryTape.empty(
+        batch_size=batch_size,
+        tape_length=int(getattr(config, "latent_history_length")),
+        num_probes=int(getattr(config, "latent_tape_probes", 16)),
+        probe_dim=rank,
+        device=device,
+        dtype=dtype,
+    )
+
+
+def slice_latent_state(
+    state: LatentDeliberationState, rows: slice | torch.Tensor
+) -> LatentDeliberationState:
+    return LatentDeliberationState(
+        memory_slots=state.memory_slots[rows],
+        confidence=state.confidence[rows],
+        entropy=state.entropy[rows],
+        age=state.age[rows],
+        token_changed=state.token_changed[rows],
+        confidence_delta=state.confidence_delta[rows],
+        entropy_delta=state.entropy_delta[rows],
+        ponder_steps=state.ponder_steps[rows],
+        stagnation_steps=state.stagnation_steps[rows],
+    )
+
+
+def cat_latent_states(states: Sequence[LatentDeliberationState]) -> LatentDeliberationState:
+    def cat(name: str) -> torch.Tensor:
+        return torch.cat([getattr(state, name) for state in states], dim=0)
+
+    return LatentDeliberationState(
+        memory_slots=cat("memory_slots"),
+        confidence=cat("confidence"),
+        entropy=cat("entropy"),
+        age=cat("age"),
+        token_changed=cat("token_changed"),
+        confidence_delta=cat("confidence_delta"),
+        entropy_delta=cat("entropy_delta"),
+        ponder_steps=cat("ponder_steps"),
+        stagnation_steps=cat("stagnation_steps"),
+    )
+
+
+def infer_commit_reason(
+    commit_lengths: torch.Tensor,
+    *,
+    jump_rows: torch.Tensor | None = None,
+    commit_token_ids: torch.Tensor | None = None,
+    terminal_token_ids: Sequence[int] = (),
+    training_random: bool = False,
+) -> torch.Tensor:
+    """Return per-row commit-reason codes. No hard skip; writer sees the label."""
+
+    reasons = torch.full(
+        commit_lengths.shape,
+        COMMIT_REASON_NONE,
+        device=commit_lengths.device,
+        dtype=torch.long,
+    )
+    committed = commit_lengths.gt(0)
+    default = (
+        COMMIT_REASON_TRAINING_RANDOM if training_random else COMMIT_REASON_NORMAL
+    )
+    reasons = torch.where(committed, torch.full_like(reasons, default), reasons)
+    if jump_rows is not None:
+        reasons = torch.where(
+            committed & jump_rows.to(dtype=torch.bool),
+            torch.full_like(reasons, COMMIT_REASON_FORCED_JUMP),
+            reasons,
+        )
+    if commit_token_ids is not None and terminal_token_ids:
+        positions = torch.arange(
+            commit_token_ids.shape[1], device=commit_token_ids.device
+        )[None, :]
+        selected = positions.lt(commit_lengths[:, None])
+        terminal = torch.zeros_like(committed)
+        for token_id in terminal_token_ids:
+            terminal |= (commit_token_ids.eq(int(token_id)) & selected).any(dim=-1)
+        reasons = torch.where(
+            committed & terminal,
+            torch.full_like(reasons, COMMIT_REASON_TERMINAL),
+            reasons,
+        )
+    return reasons
+
+
+def memory_bus_parameter_names(module: nn.Module) -> list[str]:
+    return [
+        name for name, _parameter in module.named_parameters()
+        if "working_memory_bus." in name or "persistent_memory_bus." in name
+        or "memory_bus." in name
+    ]
+
+
+__all__ = [
+    "COMMIT_REASON_FALLBACK",
+    "COMMIT_REASON_FORCED_JUMP",
+    "COMMIT_REASON_NONE",
+    "COMMIT_REASON_NORMAL",
+    "COMMIT_REASON_TERMINAL",
+    "COMMIT_REASON_TRAINING_RANDOM",
+    "DecoderMemoryBus",
+    "LatentDeliberationState",
+    "LatentDeliberationTransformer",
+    "LatentProcessorOutput",
+    "TrajectoryHistory",
+    "TrajectoryTape",
+    "advance_trajectory_clocks",
+    "cat_latent_states",
+    "cat_trajectory_history",
+    "cat_trajectory_tape",
+    "choose_trajectory_history",
+    "choose_trajectory_tape",
+    "empty_trajectory_tape",
+    "infer_commit_reason",
+    "memory_bus_parameter_names",
+    "should_force_trajectory_jump",
+    "slice_latent_state",
+    "slice_trajectory_history",
+    "slice_trajectory_tape",
+]

model-00001-of-00011.safetensors

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

model-00002-of-00011.safetensors

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

model-00003-of-00011.safetensors

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

model-00004-of-00011.safetensors

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

model-00005-of-00011.safetensors

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

model-00006-of-00011.safetensors

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

model-00007-of-00011.safetensors

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