kenaz 0.0.0-stage → 0.3.2

package/core/.kenaz/designs/REFLEX_INITIATOR_DESIGN.md

@@ -0,0 +1,501 @@
+# Reflex Arc as Intrinsic Metacognition Initiator — Design Spec
+
+**Task**: TASK_1242  
+**Status**: Design only — NO implementation  
+**Date**: 2026-04-17  
+**Author**: agent:unit  
+
+---
+
+## Executive Summary
+
+The Cognitive Reflex Arc currently operates as a **passive reward signal**: it fires per-turn, computes a `health_delta`, and shapes future tool selection through EFE feedback and Thalamus stimulation. The agent decides how to respond to that signal — but there is no mechanism by which the signal itself can *initiate* a reflection phase.
+
+This gap was identified in rune_82287c1b (2026-04-03) while mapping the ICML 2025 position paper arXiv:2506.05109 ("Truly Self-Improving Agents Require Intrinsic Metacognitive Learning") to KenazAI: all three metacognition pillars (knowledge, planning, evaluation) have partial implementations, but **all triggers are extrinsic** — human prompt, Huginn loop, or post-complete script. The initiator extension proposed here closes that gap.
+
+The core question: under what conditions should the reflex **act**, not just **signal**?
+
+---
+
+## Background
+
+### ICML 2025 Three-Pillar Framework (arXiv:2506.05109)
+
+The paper argues genuine self-improvement requires all three:
+
+| Pillar | Definition | KenazAI Status |
+|--------|------------|----------------|
+| **Metacognitive Knowledge** | Self-assessment of capabilities, tasks, strategies | ✅ Present — `ansuz_self_model.json` tendencies/blind_spots |
+| **Metacognitive Planning** | Autonomously deciding WHAT and HOW to learn | ❌ Absent — Ansuz follows fixed phase sequence |
+| **Metacognitive Evaluation** | Reflecting on whether evaluation method is effective | ⚠️ Partial — Phase 9 self-reflection, but static criteria |
+
+Key paper insight: "many ingredients for intrinsic metacognition are already present — the gap is connecting them into a recursive loop." The Reflex Initiator IS that connection: it converts reward signal into autonomous planning trigger.
+
+### Current Reflex Arc Architecture
+
+```
+UserPromptSubmit hook (reflex-feedback.js)
+  → reads conversation JSONL (previous assistant turn)
+  → extracts tool_use blocks
+  → reads mirror_id from ritual_state.json
+  → callLogger() → turn_feedback.jsonl (always)
+  → callExecutor() → [Gate A + Gate B] → EFE + Thalamus (if approved)
+```
+
+`MIRROR_TO_REFLEX` in `reflex_reward.js` maps 7 active mirrors:
+
+| Mirror | Blind Spot | Expected Tool | Penalty |
+|--------|------------|---------------|---------|
+| B-001 | checkpoint_skip | synapse_inscribe | −0.08 |
+| B-002 | selective_pulsing | synapse_pulse | −0.10 |
+| B-003 | no_proactive_recall | synapse_recall | −0.05 |
+| B-005 | error_assumption | Bash | −0.05 |
+| B-006 | completion_bias | synapse_search | −0.08 |
+| B-007 | convenience_bias | synapse_pulse | −0.10 |
+| B-008 | low_hyp_efficiency | synapse_efe | −0.05 |
+
+This is **one-directional** (reward shaping only). The initiator extension adds the **initiator direction**: under specific conditions, repeated mirror penalties trigger not just reward adjustment but an active reflection phase.
+
+### Prerequisite Gap (rune_957936466e)
+
+Behavioral blind-spot reflexes currently lack stable code symbol mappings needed for per-turn Thalamus neuron targeting. The MIRROR_TO_REFLEX `expected_tool` field is the partial resolution — it provides a named behavioral axis per mirror — but the symbol-to-neuron mapping for the initiator direction still needs a virtual symbol scheme (see Gate C section).
+
+---
+
+## Triggering pattern analysis
+
+Three candidate patterns, analyzed for precision, recall, and false-positive resistance.
+
+### Pattern A — Consecutive Same-Mirror Accumulator (Recommended)
+
+**Mechanism**: Track N consecutive turns where the SAME mirror_id fires an `absent_penalty` (i.e., mutation occurred without the expected tool). When N ≥ threshold, initiate reflection.
+
+```
+state: { mirror_id → consecutive_violation_count }
+each turn:
+  if absent_penalty fired for mirror_id:
+    count[mirror_id] += 1
+    if count[mirror_id] >= N_THRESHOLD:
+      → INITIATE reflection for mirror_id
+      count[mirror_id] = 0  ← reset after initiation
+  else:
+    count[mirror_id] = 0   ← reset on clean turn
+```
+
+**Proposed default**: N = 3 (3 consecutive violations = clear behavioral pattern, not noise).
+
+**Pros**:
+- Targeted: reflection is *about* the specific blind spot that triggered it
+- Interpretable: agent knows exactly WHY it is reflecting
+- Low false-positive rate: requires consecutive violations (random drift unlikely to hit 3 in a row)
+- State is minimal: O(mirrors) = O(7) counter array per session
+- Aligns with existing MIRROR_TO_REFLEX structure — no schema changes needed
+
+**Cons**:
+- Window is sequential, not temporal: 3 violations spread over 50 turns with good turns between don't accumulate
+- Blind to cross-mirror patterns: if B-002 and B-007 both fire alternately (both target synapse_pulse), they don't combine
+- Requires persistent state across turns — needs storage in `ritual_state.json` or a new `reflex_state.json`
+
+**Verdict**: Best fit for v1. High precision, interpretable, minimal state.
+
+---
+
+### Pattern B — Sliding Window Health Deficit
+
+**Mechanism**: Maintain a W-turn sliding window of `turn_health_delta` values. If the windowed sum falls below −T threshold, initiate reflection.
+
+```
+window: CircularBuffer[W] of health_delta
+each turn:
+  window.push(health_delta)
+  if sum(window) <= -T:
+    → INITIATE reflection
+    window.clear()  ← or partial reset (decay oldest)
+```
+
+**Proposed defaults**: W = 10, T = 0.50 (average of −0.05/turn sustained over 10 turns).
+
+**Pros**:
+- Integrates ALL signal types, not just mirror-specific penalties
+- Catches compound failures where no single mirror dominates
+- Natural math: health accumulates meaning across turns
+- Would catch turns where no mirror is active but behavior is still poor (unknown blind spots)
+
+**Cons**:
+- High false-positive risk on *legitimately* difficult turns: deep debugging naturally scores negative (lots of Bash errors, iteration)
+- Loses interpretability: agent doesn't know *why* it's reflecting — the deficit could be from many sources
+- Requires calibration: T is sensitive to task type and session phase
+- Can overlap with fatigue_warning: both fire during "bad session" conditions
+- Does not point to a specific correction action
+
+**Verdict**: Better as a secondary guard (conjunction with Pattern A), not as primary trigger.
+
+---
+
+### Pattern C — Rate-of-Violation Density
+
+**Mechanism**: Within a rolling W-turn window, compute `violation_count / W`. If ratio exceeds threshold R, initiate.
+
+```
+window: CircularBuffer[W] of (violation: bool)
+each turn:
+  window.push(absent_penalty_fired_any_mirror)
+  if sum(window) / W >= R:
+    → INITIATE reflection
+    window.partial_reset()  ← remove oldest W/2 entries
+```
+
+**Proposed defaults**: W = 20, R = 0.40 (8 of last 20 turns had a mirror penalty).
+
+**Pros**:
+- Relative metric: scales across short and long sessions
+- Less sensitive to single bad streaks than Pattern A's consecutive requirement
+- Naturally handles mixed violations across multiple mirrors
+
+**Cons**:
+- Needs W turns before it can fire (cold-start latency)
+- Partial reset logic adds complexity (how much history to retain post-trigger)
+- R = 0.40 may be too low for legitimate high-activity sessions
+- Coarser than Pattern A: doesn't distinguish which mirror is firing
+
+**Verdict**: Good for long-running sessions where Pattern A might never fire (violations spread out). Complement to Pattern A, not replacement.
+
+---
+
+### Pattern D — Rate-of-Change Inflection (Speculative)
+
+**Mechanism**: Detect when `health_delta` trend reverses from sustained positive to sustained negative.
+
+**Verdict**: Requires 3+ turn smoothing, noisy, unclear thresholds. Too complex for v1. Document for future consideration.
+
+---
+
+### Recommended Trigger Logic (v1)
+
+Use **Pattern A as primary** with **Pattern B as emergency fallback**:
+
+```
+PRIMARY:   any single mirror reaches N=3 consecutive violations → targeted reflection
+SECONDARY: window sum falls below T=-0.60 in W=8 turns         → general reflection
+GATE:      cannot trigger if fatigue_potential > 0.7 (defer to fatigue_warning)
+COOLDOWN:  minimum 5 turns between any two initiator fires (prevent oscillation)
+```
+
+---
+
+## Action menu
+
+The initiator can take exactly one of these actions when triggered. The list is bounded and ordered by intrusiveness.
+
+| Action | Mechanism | Intrusiveness | Reversibility |
+|--------|-----------|---------------|---------------|
+| **A1. Soft Prompt Injection** | Write next-turn context to `.kenaz/specialist/reflex_reflection_pending.json` — UserPromptSubmit hook reads it and prepends a structured reflection prompt to the hook output | Low | High — human ignores or dismisses |
+| **A2. Spike Signal** | Send a spike bus signal (`spike_bus_send`) with type=`reflex_reflection_needed`, payload=mirror_id — Thalamus picks up and modulates next turn's priors | Low | High — signal expires naturally |
+| **A3. Task Card Creation** | Create a task card in `.kenaz/tasks/active/` with type=`metacognition`, linked to the triggering mirror | Medium | Medium — human must close/dismiss |
+| **A4. Phase Pause Flag** | Write `.kenaz/specialist/phase_pause_requested.flag` — phase-gate.js respects this and defers to Phase 9 | Medium | Medium — flag must be deleted |
+
+**Recommended for v1**: A1 (Soft Prompt Injection) only.
+
+Rationale:
+- A1 is the least disruptive: it nudges, doesn't block
+- If agent ignores the injected prompt, no side effects remain
+- A2 (Spike) is also acceptable but requires Dashboard to be running
+- A3 (Task Card) creates persistent state the human must clean up — too heavy for automatic firing
+- A4 (Phase Pause) is too disruptive for initial deployment; reserve for Gate C+ future
+
+**Reflection prompt format** (A1 payload):
+```json
+{
+  "type": "reflex_reflection_needed",
+  "trigger": "pattern_A|pattern_B",
+  "mirror_id": "B-002",
+  "mirror_name": "selective_pulsing",
+  "consecutive_violations": 3,
+  "suggested_action": "Before the next Edit/Write/Read, ask: have I pulsed the symbol I'm about to touch?",
+  "dismiss_token": "<uuid>"
+}
+```
+
+The hook prepends to its stdout output: `[REFLEX_INITIATOR] B-002 selective_pulsing: 3 consecutive violations — reflection suggested.`
+
+---
+
+## Gate C Proposal
+
+Gates A and B protect `executeTurn()` (live substrate writes). Gate C must protect the initiator (autonomous behavior injection) — a more consequential action.
+
+**Gate C definition**:
+
+| Component | Implementation | Rationale |
+|-----------|----------------|-----------|
+| **C1. Flag file** | `.kenaz/specialist/reflex_initiator_approved.flag` | Human-created, same pattern as Gate A |
+| **C2. Observed dry-run period** | Minimum 50 turns in `turn_feedback.jsonl` AFTER executor went live (Gate A+B open) | Ensures initiator has real health data to pattern-match against, not synthetic |
+| **C3. Human verification review** | A `reflex_initiator_review.md` at `.kenaz/designs/reflex_initiator_review.md` must exist, signed by human, confirming they reviewed at least 10 sample trigger events from dry-run log | Prevents auto-activation before human understands what initiator would have done |
+
+**Gate C check pseudocode**:
+```js
+function checkInitiatorGate() {
+  if (!fs.existsSync(INITIATOR_FLAG_PATH))
+    return { ok: false, reason: 'GATE C1: initiator approval flag missing' };
+  
+  const lineCount = countLines(FEEDBACK_PATH);
+  if (lineCount < POST_EXECUTOR_THRESHOLD)
+    return { ok: false, reason: `GATE C2: need ${POST_EXECUTOR_THRESHOLD} post-executor turns, have ${lineCount}` };
+  
+  if (!fs.existsSync(REVIEW_PATH))
+    return { ok: false, reason: 'GATE C3: human review document missing' };
+  
+  return { ok: true };
+}
+```
+
+**Dry-run mode**: When Gate C is not satisfied, the initiator computes what it *would have done* and appends to a `reflex_initiator_dryrun.jsonl` log. This provides the 10 sample trigger events for Gate C3 review.
+
+---
+
+## Interaction with `fatigue_warning` Mechanism
+
+Both mechanisms interrupt work to trigger reflection, but they differ in origin, semantics, and resolution path.
+
+### Comparison
+
+| Dimension | `fatigue_warning` | Reflex Initiator |
+|-----------|-------------------|------------------|
+| **Source** | Muninn (external monitor) | Reflex arc (internal signal) |
+| **Trigger** | Token/context budget approaching limit | Behavioral pattern degradation |
+| **Semantics** | "Session is ending — preserve state" | "Behavior pattern detected — reflect on it" |
+| **Action** | ISBAR handoff (session-terminating) | Reflection prompt (session-continuing) |
+| **Resolution** | Human starts new session | Agent reflects within same session |
+| **Urgency** | High — context will be lost | Medium — behavior can correct mid-session |
+
+### Interaction Protocol
+
+1. **Priority**: `fatigue_warning` always wins. If fatigue_potential > 0.7, the initiator suppresses its trigger for that turn.
+2. **No simultaneous firing**: The initiator checks for a fatigue warning flag before firing. If `ansuz_session_handoff.json` was recently written, skip.
+3. **Complementary, not competing**: fatigue_warning fires near session END; initiator fires during active work. Their temporal windows are naturally separated in most sessions.
+4. **Mutual awareness**: The ISBAR handoff (from fatigue_warning) should include any pending reflex initiator state (which mirror triggered, what was suggested) as `pending_reflections` field. This allows next-session Ansuz to complete the reflection loop.
+
+### Handoff Integration (future)
+
+In `fatigue_warning_reaction.steps[4]` (kernel.yaml), add to the generated ISBAR:
+```json
+"pending_reflections": [
+  {
+    "mirror_id": "B-002",
+    "trigger_count": 3,
+    "suggested_action": "...",
+    "not_yet_acted_on": true
+  }
+]
+```
+
+---
+
+## Meta-Parameter Learnability Analysis
+
+Should the initiator threshold (N for Pattern A, T/W for Pattern B) be static or learned?
+
+### Arguments for Static (Hand-Tuned)
+
+- **Simplicity**: N=3 is easy to reason about and debug
+- **Stability**: learned thresholds can drift if the learning signal is itself noisy
+- **Bootstrap problem**: you need data to learn the threshold, but the threshold determines which data is relevant
+- **Interpretability**: "3 consecutive violations triggers reflection" is auditable by humans
+
+### Arguments for Learned (Meta-Parameter)
+
+- **Personalization**: different users and different task types warrant different sensitivity
+- **Adaptation**: if an agent becomes more skilled at a blind spot, threshold should rise (fewer false positives)
+- **STDP alignment**: Reflex Neurons already use STDP for tool-selection learning — extending to threshold learning is architecturally consistent
+
+### Recommendation
+
+**Start static, design for future learnability.**
+
+v1 implementation: hard-code N=3, W=10, T=0.50 as constants in the initiator module.
+
+Future learnability path:
+1. After each initiation, track whether the agent's behavior improved in the next K turns (measurable: did the mirror's absent_penalty rate drop?)
+2. If yes: threshold was appropriate — no change
+3. If no (agent ignored the reflection): threshold was too sensitive → N += 1
+4. Store learned threshold in `.kenaz/specialist/reflex_initiator_params.json` with confidence score
+5. Only allow learning when the post-initiator sample size ≥ 20 (statistical floor)
+
+**Critical constraint**: the threshold can only increase (grow less sensitive), never decrease below N_MIN = 2. This prevents the runaway self-interruption failure mode.
+
+---
+
+## Failure modes
+
+### FM-1: Runaway Self-Interruption
+
+**Description**: Each reflection prompt causes the agent to introspect, which generates low-information turns, which triggers more mirror penalties, which triggers more reflections — a feedback loop.
+
+**Conditions**: Low COOLDOWN_TURNS setting + agent responds to reflection by doing MORE of the same bad behavior
+
+**Prevention**:
+- **Mandatory cooldown**: minimum 5 turns between initiator fires (absolute, not per-mirror)
+- **Reflection outcome tracking**: if mirror violation rate doesn't improve within K turns post-reflection, mark the initiator as "ineffective for this session" and disable until next session
+- **Cap**: maximum 3 initiator fires per session (hard limit)
+
+---
+
+### FM-2: Bias Collusion
+
+**Description**: The agent's active blind spots determine which mirrors fire. The initiator amplifies those same blind spots — reflecting on B-002 (selective pulsing) causes the agent to focus on pulsing, which may suppress other patterns (B-001, B-006) by consuming cognitive bandwidth.
+
+**Conditions**: Mirror ID selection is not independent — certain blind spots are correlated
+
+**Prevention**:
+- Reflection prompt explicitly asks the agent to check ALL mirrors, not just the trigger mirror
+- Prompt format: "You have triggered B-002. Also check: are B-001, B-006, B-007 currently active?"
+- Cross-mirror audit prevents single-mirror tunnel vision
+
+---
+
+### FM-3: False Positives on Legitimate Degradation
+
+**Description**: Deep debugging sessions legitimately have poor health_delta (Bash errors, iteration cycles). Pattern B (health deficit) would fire on legitimate work.
+
+**Conditions**: Pattern B triggered during intensive debugging
+
+**Prevention**:
+- Prefer Pattern A (specific mirror, not aggregate health) as primary trigger
+- Context awareness: if `ritual_state.json` shows Phase 8 (dispatch) or active debugging context, raise threshold temporarily
+- Human-tunable: `reflex_initiator_params.json` can include phase-specific multipliers
+
+---
+
+### FM-4: Initiator Disrupts Task Flow
+
+**Description**: Agent is mid-implementation, in a productive state. Initiator injects a reflection prompt. Agent breaks flow to reflect, then loses context on the implementation.
+
+**Conditions**: Initiator fires during a Phase 8 (active dispatch) or Phase 2 (active research) sub-phase
+
+**Prevention**:
+- Defer initiation until a natural pause point: check `ritual_state.json` phase
+- If phase is 8 or mid-implementation, queue the reflection for next turn boundary (write to pending state, fire next turn)
+- Reflection prompt should be gentle: "Consider reflecting on your last 3 tool choices before continuing"
+
+---
+
+### FM-5: Context Poisoning via Reflection Prompt
+
+**Description**: The reflection prompt itself becomes an anchor in the agent's context. The agent starts pattern-matching against the reflection language rather than the actual task, producing meta-commentary instead of work.
+
+**Conditions**: Reflection prompt is too verbose or too close to task context
+
+**Prevention**:
+- Keep reflection prompts SHORT (≤ 3 lines in hook output)
+- Prompts should be questions, not assertions: "Did you pulse before touching this symbol?" not "You failed to pulse"
+- Include a `dismiss_token` that the agent can output to acknowledge-and-skip
+
+---
+
+### FM-6: Gate C Bypass via Automated Flag Creation
+
+**Description**: A future agent, observing that Gate C flag is missing, auto-creates it to "unblock" the initiator.
+
+**Conditions**: Agent has write access to `.kenaz/specialist/` and lacks awareness of the gate's purpose
+
+**Prevention**:
+- Gate C flag should contain a timestamp and human-written justification (not just be empty)
+- The check should validate file contents, not just existence: `JSON.parse(flag).approved_by === 'human'`
+- Document this constraint in CLAUDE.md rules
+
+---
+
+### FM-7: Symbol Mapping Gap (rune_957936466e)
+
+**Description**: The initiator needs to stimulate a Thalamus neuron for the triggering mirror, but mirrors don't have stable code symbol mappings. A1 (Soft Prompt Injection) doesn't need this, but A2 (Spike Signal) and future STDP-based learning do.
+
+**Status**: Partial resolution exists in `MIRROR_TO_REFLEX.expected_tool` — each mirror maps to an expected tool, which maps to a code symbol via `TOOL_TO_COMPONENT`. This is an indirect mapping: `mirror → expected_tool → component_symbol`.
+
+**Required for full loop closure**: A virtual symbol scheme `cognitive_operation:B-002` → registered Thalamus neuron. This is out of scope for v1 but must be addressed before Gate C3 (meta-parameter learning) can be enabled.
+
+---
+
+## Architecture Summary
+
+```
+reflex-feedback.js (UserPromptSubmit hook)
+    │
+    ├─ callLogger()         → turn_feedback.jsonl       [always]
+    ├─ callExecutor()       → EFE + Thalamus             [Gate A + B]
+    └─ callInitiator()  ←── NEW                          [Gate C]
+            │
+            ├─ checkInitiatorGate()                      [C1+C2+C3]
+            │       if dry-run → append reflex_initiator_dryrun.jsonl
+            │
+            ├─ updateTriggerState()                      [in-session state]
+            │       Pattern A: consecutive_violations[mirror_id] += 1
+            │       Pattern B: health_window.push(health_delta)
+            │
+            ├─ checkTrigger()
+            │       if fatigue_potential > 0.7 → skip (fatigue wins)
+            │       if cooldown active → skip
+            │       if session_fire_count >= 3 → skip
+            │       if Pattern A condition met → fire
+            │       elif Pattern B condition met → fire (fallback)
+            │
+            └─ fire(action=A1)
+                    → write reflex_reflection_pending.json
+                    → increment session_fire_count
+                    → reset consecutive_violations[mirror_id]
+                    → set cooldown_until = now + COOLDOWN_TURNS
+```
+
+**State file**: `.kenaz/specialist/reflex_initiator_state.json`
+```json
+{
+  "session_id": "...",
+  "consecutive_violations": { "B-001": 0, "B-002": 2, ... },
+  "health_window": [-0.05, 0.10, -0.08, ...],
+  "session_fire_count": 0,
+  "cooldown_remaining": 0,
+  "last_fire_ts": null
+}
+```
+
+---
+
+## Implementation Notes (for follow-up task)
+
+This section surfaces options for the implementer to choose from — NOT pre-committing to any approach.
+
+**State persistence**: In-memory (reset per session) vs. persistent across session (accumulate over days). Recommendation: start in-memory (simpler), add persistence only if the 5-turn cooldown proves insufficient.
+
+**Hook integration point**: `callInitiator()` should run AFTER `callExecutor()` (not before), because executor computes the final health_delta that Pattern B needs. Current hook flow is synchronous — initiator can be appended without async changes.
+
+**Dry-run output format**: The `reflex_initiator_dryrun.jsonl` log should use the same schema as the A1 payload plus a `would_have_fired: true/false` field and `gate_blocked_by` field. This enables Gate C3 human review.
+
+**Test surface**: The initiator is pure logic (no network calls for A1). Unit tests can inject turn sequences and assert trigger/no-trigger outcomes.
+
+---
+
+## Open Questions for Human Review
+
+1. **N_THRESHOLD**: Is 3 consecutive violations the right sensitivity? Could be 2 (more sensitive) or 5 (more conservative).
+2. **Action selection**: Should A1 (Soft Prompt) be the ONLY v1 action, or should A2 (Spike Signal) be included for when Dashboard is running?
+3. **Cross-mirror aggregation**: Should B-002 and B-007 (both target `synapse_pulse`) combine their counts? Or stay separate?
+4. **Fatigue priority cutoff**: Is 0.7 the right fatigue_potential threshold for initiator suppression?
+5. **Gate C3 format**: What exactly should the human write in `reflex_initiator_review.md` to satisfy the gate? Needs a template.
+6. **Session fire cap**: Is 3 the right maximum initiations per session?
+
+---
+
+## Evidence Links
+
+- **ICML 2025 arXiv:2506.05109**: Three-pillar intrinsic metacognition framework — all triggers in KenazAI are currently extrinsic
+- **rune_82287c1b**: Detailed KenazAI mapping of ICML framework — metacognitive planning pillar identified as the key gap
+- **rune_957936466e**: Symbol mapping gap — mirrors lack stable neuron targets (partially resolved by MIRROR_TO_REFLEX expected_tool)
+- **rune_02d248d6**: Reflex Neurons STDP design — LLM-agnostic architecture constraint that the initiator must respect
+- **rune_b05f973d**: Error floor semantics — health_delta computation (Pattern B relies on this)
+- **Cross-project rune (confidence floor)**: `synapse_inscribe` rejects confidence < 0.6; initiator-generated runes must pass confidence=0.6+
+- **kernel.yaml:fatigue_warning_reaction**: Full mechanism documented — initiator must not conflict with ISBAR generation steps
+- **reflex_reward.js:MIRROR_TO_REFLEX**: Source of truth for mirror definitions (B-001..B-008, B-004 resolved)
+- **reflex_executor.js:checkGates**: Gate A+B implementation pattern that Gate C should replicate
+
+---
+
+*Design reviewed: 2026-04-17. Implementation task to be created separately after human design review.*