Rewrite all think blocks in zero-knowledge derivation style

README.md

@@ -23,9 +23,9 @@ configs:
 
 150 single-turn (user → assistant) reasoning-focused coding samples for supervised
 fine-tuning (SFT) / distillation of small language models. Every assistant reply
-starts with a structured `<think>` block that derives the solution from first
-principles instead of pattern-completing a memorized template, followed by a concise
-explanation and a complete, runnable program.
+starts with a `<think>` block that derives the solution from first principles
+(zero-knowledge style, no template phases), followed by a concise explanation and a
+complete, runnable program.
 
 ## Format
 
@@ -41,18 +41,34 @@ assistant turn is:
 
 ```
 <think>
-1. DECONSTRUCTION & INVARIANTS: ...
-2. ARCHITECTURE & BINDING CONTRACT: ...   (INTERFACE & STRUCTURE for Python)
-3. DRAFTING CORE LOGIC & SELF-CORRECTION: ...
-4. CONCRETE DRY-RUN TRACE: ...
-5. COMPLETENESS VERIFICATION: ...
+We need ... Let's figure out ... (first-person derivation, no section headers)
+... state transitions written with real values, e.g. dq: [] -> [0] ...
+... at least two explicit "if I had done X instead, here is the wrong result" fixes ...
 </think>
 
-<2–4 sentence explanation>
+<2-4 sentence explanation>
 
 <complete runnable code in one fenced block>
 ```
 
+### Think-block style (zero-knowledge derivation)
+
+The think block is written as if the author has no memorized solution and derives
+everything from the problem statement:
+
+- First person, exploratory voice ("Let's figure out...", "Wait - ..."). No numbered
+  phases, no headings, no fixed DECONSTRUCTION / ARCHITECTURE template.
+- Every constant, coordinate, index, and boundary is derived from literal arithmetic on
+  the concrete demo input, not asserted.
+- Loop boundaries and off-by-one cases are tested with real numbers (first iteration,
+  last iteration, empty input).
+- State changes are spelled out as `before -> after` with actual values; each block
+  contains at least six such transitions.
+- At least two explicit wrong-behaviour corrections: what a plausible wrong
+  implementation would return, and why that is wrong.
+- Every variable, function, and DOM id mentioned is defined in the code that follows.
+- 350-550 words, plain ASCII.
+
 ## Composition
 
 | Slice | Count | Language | Delivery |
@@ -92,7 +108,8 @@ Every row was machine-checked before upload:
   `getElementById('x')` resolves to an `id="x"` in the same entry's markup.
 - Python entries: code blocks pass `ast.parse`; every embedded
   `if __name__ == "__main__":` demo **executes** and prints the annotated expected output.
-- No duplicate topics or duplicate user prompts; think blocks ≈ 280–630 words.
+- No duplicate topics or duplicate user prompts; think blocks 350-550 words with at
+  least six `->` transitions each.
 
 ## Honest limitations
 
@@ -100,7 +117,6 @@ Every row was machine-checked before upload:
   No browser/e2e testing was run on the 100 HTML/JS entries; canvas/audio behavior is
   traced, not observed.
 - Two near-duplicate mechanics (`stroop-test`, `color-reaction`) slipped through review.
-- Think-block length deviates from the ~350–550 word target in both directions.
 - Small sample (n=150) — a seed set to iterate on, not a training-ready corpus.
   Expect several percent of entries to need manual repair before training.
 - Assistant code follows the stated constraints (single file, stdlib-only) and encodes