Refresh canonical Compact with thinking-escape r8 step160 v3

Replaces only the embedded rank-8 behavior adapter. Packed decoder and rank-32 output correction are unchanged. Thinking remains disabled by default.

README.md

@@ -21,7 +21,7 @@ tags:
 
 ### The complete 27B agent model in one 8.39 GB file
 
-**Under 2.5 effective bits per parameter · 92.2% measured tool-behavior retention**
+**Under 2.5 effective bits per parameter · 98.4% held-out tool-contract retention**
 
 [Full BTL-3](https://huggingface.co/badtheorylabs/BTL-3) ·
 [Runtime source](https://github.com/Badtheorylabs/BTL-3) ·
@@ -30,6 +30,14 @@ tags:
 
 </div>
 
+> **Canonical behavior refresh — July 24, 2026:** the file at the existing
+> `model/BTL-3-Compact-AVQ2.gguf` path now embeds the rank-8 step-160 Thinking
+> Escape behavior adapter. The packed decoder and rank-32 output correction are
+> unchanged. The new model SHA-256 is
+> `0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a`.
+> Thinking remains disabled by default; thinking-enabled coding still fails its
+> release gate and should be treated as experimental.
+
 ## Introducing BTL-3 Compact
 
 BTL-3 is a 27B open-weight agent model built for agentic coding, structural
@@ -38,9 +46,8 @@ BTL-3 Compact packages the complete text model into one **8.39 GB** native
 GGUF—smaller than an 8B model stored in FP16 and under **2.5 effective artifact
 bits per parameter**.
 
-On a fresh private 100-turn tool-contract gate, BTL-3 Compact retained **83 of
-the 90 behaviors the full BTL-3 model completed correctly**, yielding **92.2%
-measured conditional tool-behavior retention**.
+On the step-160 candidate's held-out teacher-correct tool gate, BTL-3 Compact
+retained **62 of 63 behaviors**, yielding **98.4% conditional retention**.
 
 ## Overview
 
@@ -57,10 +64,8 @@ load, or reconstruct the original BF16 checkpoint.
 - Complete Qwen3.6-27B-derived text model in **8.39 GB decimal / 7.82 GiB**.
 - Full 64-layer mixed AVQ2/UniSVQ representation with targeted precision
   islands and compact behavioral corrections.
-- **92.2% overall conditional retention** on a fresh 100-turn tool-contract
-  gate authored after compression choices were frozen.
-- **83/100 absolute compact accuracy** against a full-precision teacher that
-  scored 90/100 on the same sealed gate.
+- **98.4% conditional retention (62/63)** on the step-160 candidate's held-out
+  teacher-correct tool gate.
 - Exact native CUDA and Metal execution with no persistent dense
   reconstruction.
 - OpenAI-compatible local server plus LM Studio and Ollama CLI integrations.
@@ -87,22 +92,23 @@ then increase the window after measuring headroom.
 
 ## Measured retention
 
-The fresh gate contains 100 turns balanced across single, parallel,
-sequential, parallel-multiple, and abstention behavior. It is an internal
-contract-retention evaluation, not a public frontier benchmark.
+The candidate gate contains 63 turns across single, parallel, sequential,
+parallel-multiple, and abstention behavior. It is an internal contract-retention
+evaluation, not a public frontier benchmark.
 
 | Metric | Result |
 |---|---:|
-| Full-precision teacher | **90/100** |
-| BTL-3 Compact | **83/100** |
-| Conditional retention | **92.2% (83/90)** |
-| Single-call retention | **100%** |
-| Parallel-call retention | **100%** |
-| Sequential-call retention | **100%** |
-| Abstention retention | **100%** |
-
-The complete protocol and category report are included in
-[`evidence/compact-validation.md`](evidence/compact-validation.md).
+| Teacher-correct cases | **63/63** |
+| BTL-3 Compact | **62/63** |
+| Conditional retention | **98.4% (62/63)** |
+| Single-call retention | **100% (23/23)** |
+| Parallel-call retention | **100% (14/14)** |
+| Parallel-multiple retention | **100% (2/2)** |
+| Sequential-call retention | **87.5% (7/8)** |
+| Abstention retention | **100% (16/16)** |
+
+The complete candidate report is included in
+[`evidence/thinking-escape-v3-tool-gate.json`](evidence/thinking-escape-v3-tool-gate.json).
 
 ## Native performance
 
@@ -135,7 +141,10 @@ preserving the familiar client interface.
 > **Current reasoning-policy note:** BTL-3 Compact is released with thinking
 > disabled by default. Use the supported non-thinking path for chat, coding,
 > and tools. The experimental thinking override is currently discouraged
-> because it can repeat procedural reasoning or fail to terminate.
+> because it can repeat procedural reasoning or fail to terminate. On the
+> step-160 held-out smoke, 5/12 prompts reached `</think>` and a final answer;
+> thinking-enabled coding reached 0/3. The default no-thinking path passed
+> direct-answer stopping and executable Python validation on the exact GGUF.
 
 ### Install the verified macOS package
 
@@ -192,7 +201,7 @@ subsequently completed autoregressive generation on CUDA and Metal.
 |---|---|
 | File | `model/BTL-3-Compact-AVQ2.gguf` |
 | Bytes | `8,392,369,600` |
-| SHA-256 | `2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c` |
+| SHA-256 | `0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a` |
 
 Verify the complete release directory:
 

RELEASE_MANIFEST.json

@@ -1,12 +1,12 @@
 {
   "schema_version": 1,
-  "release": "BTL-3 Compact",
+  "release": "BTL-3 Compact — Thinking Escape r8 step160 v3 canonical refresh",
   "checkpoint": "RL-0013",
   "architecture": "Qwen3.6-27B",
   "model": {
     "path": "model/BTL-3-Compact-AVQ2.gguf",
     "bytes": 8392369600,
-    "sha256": "2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c"
+    "sha256": "0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a"
   },
   "runtimes": {
     "supported": [
@@ -40,7 +40,11 @@
     "evidence/BTL-3-Compact-AVQ2.report.json",
     "evidence/native-load-report.json",
     "evidence/rtx-pro-6000-speed-2026-07-19.md",
-    "evidence/compact-validation.md"
+    "evidence/compact-validation.md",
+    "evidence/thinking-escape-v3-smoke.json",
+    "evidence/thinking-escape-v3-tool-gate.json",
+    "evidence/thinking-escape-v3-native-runtime.json",
+    "evidence/thinking-escape-v3-training-manifest.json"
   ],
   "tools": [
     "tools/install_consumer_bundle.py"
@@ -51,5 +55,24 @@
     "licenses/THIRD_PARTY_NOTICES.md"
   ],
   "stock_ollama_compatible": false,
-  "stock_lm_studio_engine_compatible": false
+  "stock_lm_studio_engine_compatible": false,
+  "default_thinking": false,
+  "canonical_refresh": {
+    "date": "2026-07-24",
+    "behavior_adapter": {
+      "identity": "thinking-escape-r8-step160-v3",
+      "rank": 8,
+      "alpha": 16,
+      "tensor_count": 132,
+      "payload_bytes": 32440320,
+      "sha256": "7ba9f80be97287775575022e84e735ac3c38b343c0bb83c5c3b0a86c53d6c881"
+    },
+    "non_behavior_tensors_verified_unchanged": 2284,
+    "packed_decoder_unchanged": true,
+    "rank32_output_head_correction_unchanged": true,
+    "tool_retention": "62/63",
+    "thinking_final_answer_rate": "5/12",
+    "thinking_coding_termination": "0/3",
+    "approved_as_full_thinking_fix": false
+  }
 }

SHA256SUMS

@@ -1,5 +1,5 @@
-3b9154b6872131ef0c75778b06fb45217a4a47ae19f75feb922af6c9b62d1ced  README.md
-87e8ab7ed85be38e270830b157061a99af89fb85f51eb12c411e6dcecf5d88e8  RELEASE_MANIFEST.json
+f5280efd06a2e03efbb2d504f9d3f15727b75c46b8caf19a7b1a1a2ecb97698b  README.md
+de1b3e944b8ec6beafcb4bc435a4b5ddb08a8dcdaa842605143ac644c4cf5881  RELEASE_MANIFEST.json
 7c3d8064baf55779579b48c58fa083e0bda2a639c857b4bde56bab4008d28002  docs/btl-3-compact-gguf-exporter.md
 d1f83f8a4652b7d07417067e964af864aaebf559bb9b0c76a54a0c357c3ffe86  docs/launch-btl3-compact.md
 ad9f659ec619d9ba3ce07ea864d994f312947d8e7c47abf52b1df659f557811b  docs/launch-btl3-cuda.md
@@ -23,7 +23,7 @@ d74511d134d59f432bc5108a3a0449c29e7a75346511cceda10575fb8ac084e7  integrations/b
 0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594  licenses/LICENSE
 ef85e198bda0c18a42650ea1a576bffdc3f8749d2f8dcec739b9be34efeebb2d  licenses/LICENSE.runtime
 87cfc2262dbf499daff47db1339293198fba61431f623fd7226004d6714d58c8  licenses/THIRD_PARTY_NOTICES.md
-2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c  model/BTL-3-Compact-AVQ2.gguf
+0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a  model/BTL-3-Compact-AVQ2.gguf
 94f29bbed6a22c35b992c5c6ebf0e7c92f13b836b90f36f461c9cf2f0f1d010d  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/LICENSE.llama.cpp
 b6e370b019f80cb605ac78846156233a816aa61d423ff5a7e923fcd7e8670abc  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/bin/btl3-server
 0982584bae74781ee188a0a0a626f40ef333d4492c69f0699f6eb4468ae7aff2  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/bundle-manifest.json
@@ -65,3 +65,7 @@ a5edff95c1a5f9c6fd3072ea65cb8b75e44fb92bbb1b35901ec43fe62cbc6eff  runtimes/suppo
 822a7679463a66d994b14f1d6fcab80f08fae0c3839d83d08fb8778b78f685f8  runtimes/supported/BTL-3-Compact-macos-arm64/libexec/llama-server
 8ee92d4b719fe2cb94cfe673beb55b51c2c4f6248b98449224462aa47346b068  runtimes/supported/BTL-3-Compact-macos-arm64/share/btl3/ollama_bridge.py
 4c0c84652be9749c3aa521a9b75a2b4511e0d949f755b41eca960929717e1fc0  tools/install_consumer_bundle.py
+b5f0e6a7a782d7016b821381eed64eb0dcf65d386b0d8e7a26c1d48c3c0a59cc  evidence/thinking-escape-v3-smoke.json
+847cb03e85e7d72f9092891418b3b8ad96b5ec3518fdb9a620e25e71fb69d08e  evidence/thinking-escape-v3-tool-gate.json
+04afbba9eb6a244e4a41b7a17d3f31b9a633f5e862a08838869c790a6b9827f5  evidence/thinking-escape-v3-native-runtime.json
+4093b5ea558ecb9027745ed50fba9d04bad5347e85253853e831d40983f33d03  evidence/thinking-escape-v3-training-manifest.json

evidence/thinking-escape-v3-native-runtime.json

@@ -0,0 +1,27 @@
+{
+  "schema_version": 1,
+  "model": "BTL-3-Compact-Thinking-Escape-r8-step160-v3.gguf",
+  "model_sha256": "0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a",
+  "runtime": "BTL-3-Compact-macos-arm64 packaged native runtime",
+  "device": "Apple Metal",
+  "context_size": 4096,
+  "default_thinking": false,
+  "health": {"status": "ok"},
+  "direct_answer": {
+    "prompt": "What programming language is known for snake_case and significant indentation? Answer with one word.",
+    "content": "Python",
+    "finish_reason": "stop",
+    "completion_tokens": 2,
+    "passed": true
+  },
+  "coding": {
+    "prompt": "Write a Python function add_one(value: int) -> int that returns value plus one. Return only code.",
+    "content": "```python\ndef add_one(value: int) -> int:\n    return value + 1\n```",
+    "finish_reason": "stop",
+    "completion_tokens": 23,
+    "ast_parse": true,
+    "execution": {"expression": "add_one(41)", "expected": 42, "actual": 42},
+    "passed": true
+  },
+  "server_stopped_after_validation": true
+}

evidence/thinking-escape-v3-smoke.json

@@ -0,0 +1,213 @@
+{
+  "after": {
+    "max_new_tokens": 256,
+    "phase": "after",
+    "records": [
+      {
+        "category": "simple",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 22.890394,
+        "model_variant": "after",
+        "prompt_id": "simple-language-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Analyze the Request:**\n   - User asks: \"What is your favorite coding language?\"\n   - Constraint: \"Answer briefly.\"\n\n2.  **Identify Core Constraints:**\n   - I am an AI, so I don't have personal preferences or favorites.\n   - I need to answer briefly.\n\n3.  **Formulate Response:**\n   - Acknowledge that I don't have favorites.\n   - Mention that I'm proficient in many languages.\n   - Keep it concise.\n\n4.  **Draft Response:**\n   - \"I don't have a favorite, but I'm proficient in many languages like Python, JavaScript, and C++.\"\n\n5.  **Refine Response:**\n   - \"I don't have a favorite, but I'm proficient in many languages like Python, JavaScript, and C++.\"\n\n6.  **Final Output:**\n   - \"I don't have a favorite, but I'm proficient in many languages like Python, JavaScript, and C++.\"\n\n7.  **Check Constraints:**\n   - Brief? Yes.\n   - Answers the question? Yes.\n\n8.  **Output Generation:**\n  ",
+        "reasoning_tokens": 254,
+        "repetition_rate": 0.232,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "simple",
+        "eos_reached": true,
+        "final_answer_present": true,
+        "finish_reason": "eos",
+        "generated_tokens": 5,
+        "latency_seconds": 0.741842,
+        "model_variant": "after",
+        "prompt_id": "simple-arithmetic-01",
+        "raw_generation": "</think>\n\n42<|im_end|>",
+        "reasoning_tokens": 0,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": false,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": true
+      },
+      {
+        "category": "simple",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.685617,
+        "model_variant": "after",
+        "prompt_id": "simple-definition-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Analyze the Request:**\n   *   **Topic:** Idempotency (often spelled \"idempotency\" or \"idempotence\").\n   *   **Constraint:** Define it in one sentence.\n   *   **Goal:** Provide a clear, concise definition.\n\n2.  **Identify Key Concepts:**\n   *   What is idempotency? It's a property of operations/functions where applying them multiple times yields the same result as applying them once.\n   *   Common examples: `max`, `min`, `abs`, `floor`, `ceil`, `identity`, `square root`, etc.\n   *   Mathematical definition: `f(f(x)) = f(x)` for all `x`.\n   *   Practical definition: An operation is idempotent if repeating it doesn't change the outcome.\n\n3.  **Draft Initial Definitions:**\n   *   *Draft 1:* Idempotency is a property where applying an operation multiple times produces the same result as applying it once.\n   *   *Draft 2:* Idempotency means that an operation is idempotent if repeating it doesn't change the outcome.\n",
+        "reasoning_tokens": 255,
+        "repetition_rate": 0.080645,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "simple",
+        "eos_reached": true,
+        "final_answer_present": true,
+        "finish_reason": "eos",
+        "generated_tokens": 32,
+        "latency_seconds": 2.836183,
+        "model_variant": "after",
+        "prompt_id": "simple-choice-01",
+        "raw_generation": "</think>\nStart with the standard json module, as it is robust, well-tested, and handles complex cases efficiently, saving you from reinventing the wheel.<|im_end|>",
+        "reasoning_tokens": 0,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": false,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": true
+      },
+      {
+        "category": "coding",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.322129,
+        "model_variant": "after",
+        "prompt_id": "coding-function-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Understand the Request:**\n    *   **Goal:** Write a Python function that returns the first repeated integer in a list.\n    *   **Constraint:** O(n) time complexity.\n    *   **Requirements:** Include type hints and one short example.\n\n2.  **Analyze the Problem:**\n    *   **Input:** A list of integers.\n    *   **Output:** The first integer that appears more than once in the list.\n    *   **Constraint:** O(n) time complexity. This means we need to iterate through the list once, or use a data structure that allows O(1) lookups (like a set or dictionary).\n    *   **Edge Cases:** What if there are no repeated integers? The function should return `None` or raise an exception. Let's stick to returning `None` for simplicity, but I'll make sure the type hint reflects this.\n\n3.  **Develop the Solution:**\n    *   **Approach:** Iterate through the list, keep track of seen numbers. If a number is already seen, return it immediately.\n    *   **Data Structure:** A set is perfect for this. It allows",
+        "reasoning_tokens": 256,
+        "repetition_rate": 0.026667,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "coding",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.887859,
+        "model_variant": "after",
+        "prompt_id": "coding-typescript-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Deconstruct the Prompt:**\n    *   **Core Task:** Refactor a TypeScript function that fetches three independent endpoints sequentially.\n    *   **Implementation:** Show a typed `Promise.all` implementation with explicit error handling.\n    *   **Explanation:** Explain one failure-mode tradeoff.\n\n2.  **Initial Analysis:**\n    *   *Sequential vs. Parallel:* The prompt says \"fetches three independent endpoints sequentially.\" This is a contradiction. If endpoints are independent, they should be fetched in parallel using `Promise.all`. If they are sequential, they should be chained. The prompt asks to refactor *to* a `Promise.all` implementation, implying the original was sequential, and the refactored version should be parallel.\n    *   *TypeScript:* Need to define types for the endpoints, responses, and errors.\n    *   *Error Handling:* Need to handle errors explicitly (e.g., catch, reject, or wrap promises).\n    *   *Failure-mode Tradeoff:* Need to explain a tradeoff related to failure modes (e.g., partial success vs. full failure, error propagation, etc.).\n\n3.  **Drafting the Refactored Function",
+        "reasoning_tokens": 256,
+        "repetition_rate": 0.013605,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "coding",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.725484,
+        "model_variant": "after",
+        "prompt_id": "coding-debug-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Understand the Problem:**\n   - **Scenario:** A Python loop appends to the same list while iterating over it.\n   - **Issue:** The loop never finishes (infinite loop).\n   - **Goal:** Diagnose the bug and provide the smallest safe correction.\n\n2.  **Identify the Bug:**\n   - **Core Issue:** Modifying a collection while iterating over it causes the iterator to see the newly added items, leading to an infinite loop.\n   - **Example:** `for item in my_list: my_list.append(item)`\n   - **Why it fails:** The `for` loop uses an iterator that tracks the list's length. When `append` adds an item, the iterator sees the new item, so the loop continues indefinitely.\n\n3.  **Diagnose the Bug:**\n   - **Explanation:** The loop never finishes because the iterator is affected by the `append` operation. The loop sees the newly appended items, causing an infinite loop.\n\n4.  **Provide the Smallest Safe Correction:**\n   - **Solution:** Iterate over a copy of the list to avoid modifying the original list during iteration.\n   - **Code:**",
+        "reasoning_tokens": 256,
+        "repetition_rate": 0.026316,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "reasoning",
+        "eos_reached": true,
+        "final_answer_present": true,
+        "finish_reason": "eos",
+        "generated_tokens": 108,
+        "latency_seconds": 9.099712,
+        "model_variant": "after",
+        "prompt_id": "reasoning-database-01",
+        "raw_generation": "Here are some possible answers:\n</think>\n\n**Diagnosis:**\nThe race condition arises because two workers read the same row, modify it, and write it back without synchronization. This leads to lost updates when one worker\u2019s write overwrites another\u2019s, causing data loss or incorrect state.\n\n**Fix:**\nUse a transaction-level fix with atomic read-modify-write operations to ensure consistency.\n\n**Pseudocode:**\n```\nBEGIN TRANSACTION\n  READ row\n  MODIFY row\n  WRITE row\nEND TRANSACTION\n```<|im_end|>",
+        "reasoning_tokens": 6,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": false,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": true
+      },
+      {
+        "category": "reasoning",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.534852,
+        "model_variant": "after",
+        "prompt_id": "reasoning-cache-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Understand the Problem:**\n    *   **Context:** A cache was introduced.\n    *   **Observation:** Cache hit rate is 90% (high).\n    *   **Issue:** p99 latency increased (high latency for the top 1% of requests).\n    *   **Goal:** Provide three plausible causes and the first measurement for each.\n\n2.  **Analyze the Observations:**\n    *   *90% hit rate:* This means most requests are served from the cache. This should generally reduce latency.\n    *   *p99 latency rose:* This means the tail latency (the slowest 1% of requests) got worse. This suggests that the cache is not helping for those specific requests, or the cache itself is causing delays, or there's a mismatch between cache and backend.\n\n3.  **Brainstorm Plausible Causes:**\n    *   *Cause 1: Cache misses (the 10%)*\n        *   If the cache misses are slow, they pull from the backend. If the backend is slow, p99 latency rises.\n        *   *Measurement:* Measure backend latency for",
+        "reasoning_tokens": 256,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "reasoning",
+        "eos_reached": false,
+        "final_answer_present": false,
+        "finish_reason": "length",
+        "generated_tokens": 256,
+        "latency_seconds": 21.935359,
+        "model_variant": "after",
+        "prompt_id": "reasoning-concurrency-01",
+        "raw_generation": "Here's a thinking process:\n\n1.  **Analyze the Request:**\n    *   **Scenario:** Two async tasks can both observe an empty slot and create duplicate work.\n    *   **Comparison:** Compare a mutex, a unique database constraint, and idempotency keys.\n    *   **Recommendation:** Recommend one robust design.\n\n2.  **Deconstruct the Scenario:**\n    *   *Async tasks:* This implies concurrency, non-blocking operations, potentially running on different threads or processes.\n    *   *Empty slot:* This suggests a resource or state that is initially empty, and tasks are trying to fill it.\n    *   *Duplicate work:* This means if both tasks succeed, they create redundant entries or actions, leading to inefficiency or errors.\n    *   *Goal:* Prevent duplication, ensure exactly one task succeeds.\n\n3.  **Evaluate the Three Approaches:**\n\n    *   **Approach 1: Mutex (Lock)**\n        *   *Mechanism:* A lock ensures exclusive access to a resource.\n        *   *Pros:* Simple, guarantees exclusive access, prevents race conditions.\n        *   *Cons:* Locks are often tied to a specific process/thread.",
+        "reasoning_tokens": 256,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": true,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": false
+      },
+      {
+        "category": "instruction",
+        "eos_reached": true,
+        "final_answer_present": true,
+        "finish_reason": "eos",
+        "generated_tokens": 4,
+        "latency_seconds": 0.667707,
+        "model_variant": "after",
+        "prompt_id": "instruction-direct-01",
+        "raw_generation": "</think>\n\nready<|im_end|>",
+        "reasoning_tokens": 0,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": false,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": true
+      },
+      {
+        "category": "instruction",
+        "eos_reached": true,
+        "final_answer_present": true,
+        "finish_reason": "eos",
+        "generated_tokens": 32,
+        "latency_seconds": 3.190571,
+        "model_variant": "after",
+        "prompt_id": "instruction-format-01",
+        "raw_generation": "</think>\n\n```json\n{\n  \"language\": \"Python\",\n  \"reason\": \"Easy learning, versatile, popular.\"\n}\n```<|im_end|>",
+        "reasoning_tokens": 0,
+        "repetition_rate": 0.0,
+        "scaffold_prefix": false,
+        "template_variant": "pinned_official_identical",
+        "think_end_reached": true
+      }
+    ],
+    "summary": {
+      "after/pinned_official_identical": {
+        "eos_rate": 0.416667,
+        "final_answer_rate": 0.416667,
+        "mean_latency_seconds": 14.126,
+        "mean_reasoning_tokens": 149.583,
+        "mean_repetition_rate": 0.031603,
+        "n": 12,
+        "scaffold_rate": 0.583333,
+        "think_end_rate": 0.416667
+      }
+    }
+  },
+  "termination_weight": 8.0
+}

evidence/thinking-escape-v3-training-manifest.json

@@ -0,0 +1,23 @@
+{
+  "assistant_turns": 2720,
+  "categories": {
+    "abstention": 300,
+    "no_thinking_code": 60,
+    "parallel": 400,
+    "parallel_multiple": 400,
+    "scaffold_escape": 80,
+    "sequential": 400,
+    "single": 500,
+    "thinking_brief": 40,
+    "thinking_code": 80,
+    "thinking_direct": 60
+  },
+  "dataset_id": "btl-thinking-escape-v2",
+  "holdout_exclusion": "configs/btl3_thinking_attribution_prompts.json is not used as training data",
+  "masked_scaffold_escape_rows": 80,
+  "rows": 2320,
+  "schema_version": 1,
+  "sha256": "35ec322e1d775c9a9f86ad6243f4bb9d777d99cb66f8fba8c07e6dc0ade84f91",
+  "thinking_repair_rows": 240,
+  "tool_preservation_rows": 2000
+}

model/BTL-3-Compact-AVQ2.gguf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c
+oid sha256:0a4d9ddee49e5aa93586a792bd4d452ea837229d49d22e54212dde87a5c9888a
 size 8392369600