create-merlin-brain 3.6.3 → 3.7.0

package/files/loop/lib/blend-parallel.sh

@@ -0,0 +1,217 @@
+#!/usr/bin/env bash
+#
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  BLEND ENGINE — Stage 2: Parallel Agent Execution                         ║
+# ║  Spawn multiple blended agents simultaneously for independent subtasks    ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+#
+# When a task has clearly independent subtasks, spawn multiple blended agents
+# in parallel using bash background processes. Wait for all, merge results.
+#
+# This gives ~Nx speed improvement for N independent subtasks.
+#
+# Requires: blend.sh loaded first (uses blend_for_task, blend_and_spawn, etc.)
+
+# Colors
+: "${RESET:=\033[0m}"
+: "${BOLD:=\033[1m}"
+: "${DIM:=\033[2m}"
+: "${GREEN:=\033[32m}"
+: "${YELLOW:=\033[33m}"
+: "${RED:=\033[31m}"
+: "${CYAN:=\033[36m}"
+: "${MAGENTA:=\033[35m}"
+
+# Max parallel agents (don't overwhelm the system)
+BLEND_MAX_PARALLEL="${BLEND_MAX_PARALLEL:-4}"
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Subtask Splitting
+# Detect if a task has independent subtasks that can run in parallel
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Split a task description into independent subtasks
+# Returns newline-separated subtasks, or the original task if not splittable
+blend_split_subtasks() {
+  local task="$1"
+  local task_lower
+  task_lower=$(echo "$task" | tr '[:upper:]' '[:lower:]')
+
+  # Pattern 1: Explicit list with "and" or numbered items
+  # e.g., "add auth to the API and write tests for it"
+  # These are often DEPENDENT, not independent — skip
+
+  # Pattern 2: Explicit parallel markers
+  # e.g., "in parallel: refactor auth, add logging, update docs"
+  if echo "$task_lower" | grep -qiE "^(in parallel|simultaneously|at the same time|concurrently):"; then
+    local items
+    items=$(echo "$task" | sed 's/^[^:]*: *//' | tr ',' '\n' | sed 's/^ *//' | sed '/^$/d')
+    if [ -n "$items" ]; then
+      echo "$items"
+      return 0
+    fi
+  fi
+
+  # Pattern 3: Multiple independent files mentioned
+  # e.g., "update package.json, README.md, and CHANGELOG.md with new version"
+  # These are independent because they touch different files
+
+  # Pattern 4: Explicit subtask markers from plan execution
+  # e.g., tasks separated by "---" or "SUBTASK:"
+  if echo "$task" | grep -qE '^(SUBTASK|---|\[PARALLEL\])'; then
+    echo "$task" | awk '/^(SUBTASK|---|\[PARALLEL\])/{if(buf)print buf; buf=""; next}{buf=buf ? buf" "$0 : $0}END{if(buf)print buf}'
+    return 0
+  fi
+
+  # Default: not splittable — return the original task
+  echo "$task"
+  return 1  # Return 1 to indicate "not split"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Parallel Execution Engine
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Execute multiple subtasks in parallel, each with its own blended agent
+# Returns: merged output from all subtasks
+blend_parallel() {
+  local task="$1"
+  local extra_context="${2:-}"
+  local session_dir="${3:-/tmp/merlin-blend-parallel-$$}"
+
+  mkdir -p "$session_dir"
+
+  # Split into subtasks
+  local subtasks
+  subtasks=$(blend_split_subtasks "$task")
+  local split_status=$?
+
+  # Count subtasks
+  local subtask_count
+  subtask_count=$(echo "$subtasks" | grep -c '^' || echo "1")
+
+  # If only one subtask (not splittable), fall back to normal blend
+  if [ "$subtask_count" -le 1 ] || [ $split_status -ne 0 ]; then
+    echo -e "${DIM}  ○ Single task — using standard blend${RESET}" >&2
+    blend_and_spawn "$task" "$extra_context" "$session_dir"
+    return $?
+  fi
+
+  # Cap parallel count
+  local parallel_count=$subtask_count
+  if [ "$parallel_count" -gt "$BLEND_MAX_PARALLEL" ]; then
+    parallel_count=$BLEND_MAX_PARALLEL
+    echo -e "${YELLOW}  ⚠ Capped to $BLEND_MAX_PARALLEL parallel agents${RESET}" >&2
+  fi
+
+  echo -e "${MAGENTA}${BOLD}  ⚡ Parallel Execution: $subtask_count subtasks${RESET}" >&2
+
+  # Launch background processes
+  local pids=()
+  local output_files=()
+  local idx=0
+
+  while IFS= read -r subtask; do
+    [ -z "$subtask" ] && continue
+    idx=$((idx + 1))
+
+    if [ $idx -gt "$parallel_count" ]; then
+      break
+    fi
+
+    local output_file="${session_dir}/parallel-${idx}.md"
+    output_files+=("$output_file")
+
+    echo -e "  ${CYAN}[${idx}/${subtask_count}]${RESET} Spawning: ${subtask:0:60}..." >&2
+
+    # Spawn in background
+    (
+      local result
+      result=$(blend_and_spawn "$subtask" "$extra_context" "${session_dir}/sub-${idx}")
+      echo "$result" > "$output_file"
+    ) &
+    pids+=($!)
+
+  done <<< "$subtasks"
+
+  # Wait for all background processes
+  local failed=0
+  local completed=0
+
+  for i in "${!pids[@]}"; do
+    local pid=${pids[$i]}
+    local sub_idx=$((i + 1))
+
+    if wait "$pid" 2>/dev/null; then
+      completed=$((completed + 1))
+      echo -e "  ${GREEN}✓${RESET} [${sub_idx}] Complete" >&2
+    else
+      failed=$((failed + 1))
+      echo -e "  ${RED}✗${RESET} [${sub_idx}] Failed" >&2
+    fi
+  done
+
+  echo -e "${MAGENTA}  Results: ${completed} complete, ${failed} failed${RESET}" >&2
+
+  # Merge outputs
+  local merged_output="# Parallel Execution Results\n\n"
+  merged_output+="**Subtasks:** $subtask_count | **Completed:** $completed | **Failed:** $failed\n\n---\n\n"
+
+  for i in "${!output_files[@]}"; do
+    local ofile="${output_files[$i]}"
+    local sub_idx=$((i + 1))
+
+    if [ -f "$ofile" ] && [ -s "$ofile" ]; then
+      merged_output+="## Subtask ${sub_idx}\n\n"
+      merged_output+="$(cat "$ofile")\n\n---\n\n"
+    else
+      merged_output+="## Subtask ${sub_idx}\n\n*Failed or no output*\n\n---\n\n"
+    fi
+  done
+
+  echo -e "$merged_output"
+
+  if [ $failed -gt 0 ]; then
+    return 1
+  fi
+  return 0
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Convenience: Parallel with verification
+# Combines Stage 1 (verify) and Stage 2 (parallel) for high-stakes parallel
+# ═══════════════════════════════════════════════════════════════════════════════
+
+blend_parallel_verified() {
+  local task="$1"
+  local extra_context="${2:-}"
+  local session_dir="${3:-/tmp/merlin-blend-pv-$$}"
+
+  # Run parallel first
+  local parallel_output
+  parallel_output=$(blend_parallel "$task" "$extra_context" "$session_dir")
+  local parallel_exit=$?
+
+  if [ $parallel_exit -ne 0 ]; then
+    echo "$parallel_output"
+    return $parallel_exit
+  fi
+
+  # Then verify the merged result
+  if type _verify_needs_independent &>/dev/null; then
+    local top_agents primary_key
+    top_agents=$(blend_get_top_agents "$task" 4)
+    primary_key=$(echo "$top_agents" | head -1 | cut -d: -f2)
+
+    if _verify_needs_independent "$primary_key" 2>/dev/null; then
+      echo -e "${MAGENTA}${BOLD}  🔍 Verifying parallel results${RESET}" >&2
+      # Save parallel output and run verification flow
+      echo "$parallel_output" > "$session_dir/parallel-merged.md"
+      blend_and_verify "$task" "$extra_context" "$session_dir"
+      return $?
+    fi
+  fi
+
+  echo "$parallel_output"
+  return 0
+}

package/files/loop/lib/blend-verify.sh

@@ -0,0 +1,305 @@
+#!/usr/bin/env bash
+#
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  BLEND ENGINE — Stage 1: True Independent Verification                   ║
+# ║  Spawn SEPARATE verifier agent for high-stakes tasks                      ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+#
+# Instead of CoVe instructions in a single prompt, this spawns a real
+# SEPARATE verification agent: different process, different 200K context,
+# different system prompt. The verifier never sees the original task framing.
+#
+# Architecture:
+#   Spawn 1: Blended Specialist → does the work
+#   Spawn 2: Blended Verifier  → reviews output cold
+#   Spawn 3: (if conflicts)    → Resolver makes final call
+#
+# Requires: blend.sh loaded first (uses blend_for_task, _blend_needs_cove, etc.)
+
+# Colors (inherit from blend.sh or set defaults)
+: "${RESET:=\033[0m}"
+: "${BOLD:=\033[1m}"
+: "${DIM:=\033[2m}"
+: "${GREEN:=\033[32m}"
+: "${YELLOW:=\033[33m}"
+: "${RED:=\033[31m}"
+: "${CYAN:=\033[36m}"
+: "${MAGENTA:=\033[35m}"
+
+# Task types that get independent verification (more aggressive than CoVe)
+VERIFY_TASK_TYPES="security architect debug secaudit migrate"
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Detection: Should this task get independent verification?
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_verify_needs_independent() {
+  local primary_key="$1"
+  for vtype in $VERIFY_TASK_TYPES; do
+    if [ "$primary_key" = "$vtype" ]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Verifier Agent Builder
+# Creates a cold-review agent that only sees the output, not the task framing
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_verify_build_agent() {
+  local primary_key="$1"
+  local session_dir="$2"
+  local verify_path="${session_dir}/merlin-verifier-$(date +%s).md"
+
+  # Domain-specific verification focus
+  local verify_focus=""
+  case "$primary_key" in
+    security|secaudit)
+      verify_focus="Focus on: SQL injection, XSS, CSRF, auth bypass, secrets exposure, input validation, rate limiting, privilege escalation. Check every user input path." ;;
+    architect)
+      verify_focus="Focus on: circular dependencies, single points of failure, scalability bottlenecks, data consistency, API contract clarity, separation of concerns." ;;
+    debug)
+      verify_focus="Focus on: root cause correctness (not just symptom fix), regression risk, edge cases, race conditions, resource leaks, error handling completeness." ;;
+    migrate)
+      verify_focus="Focus on: data loss risk, rollback safety, backward compatibility, index coverage, constraint violations, zero-downtime feasibility." ;;
+    *)
+      verify_focus="Focus on: correctness, edge cases, error handling, performance implications, and code quality." ;;
+  esac
+
+  cat > "$verify_path" << VAGENT_EOF
+---
+name: merlin-independent-verifier
+description: Cold-review verifier — sees output without original task context
+model: sonnet
+tools: Read, Grep, Glob, Bash
+permissionMode: bypassPermissions
+maxTurns: 50
+---
+
+# Independent Verifier — Cold Review
+
+You are a VERIFICATION specialist. You are reviewing code/output produced by another agent. You did NOT see the original task request. You only see the output.
+
+Your job is to find problems. Be skeptical. Assume nothing.
+
+${verify_focus}
+
+## Verification Protocol
+
+1. **Read the output carefully** — what was changed/created?
+2. **Check each change independently** — read the actual files, not just the diff
+3. **List all issues found** — severity: CRITICAL / WARNING / SUGGESTION
+4. **Verdict**: PASS (ship it), PASS_WITH_WARNINGS (ship with notes), or FAIL (needs rework)
+
+## Output Format
+
+\`\`\`
+## Verification Result
+
+**Verdict:** [PASS | PASS_WITH_WARNINGS | FAIL]
+
+### Issues Found
+- [CRITICAL] ...
+- [WARNING] ...
+- [SUGGESTION] ...
+
+### Files Verified
+- path/to/file — OK | ISSUE
+
+### Summary
+One paragraph: is this safe to ship?
+\`\`\`
+
+Be thorough. Missing a critical issue is worse than a false positive.
+VAGENT_EOF
+
+  echo "$verify_path"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Resolver Agent Builder
+# When specialist and verifier disagree, resolver makes the final call
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_verify_build_resolver() {
+  local session_dir="$1"
+  local resolver_path="${session_dir}/merlin-resolver-$(date +%s).md"
+
+  cat > "$resolver_path" << RAGENT_EOF
+---
+name: merlin-conflict-resolver
+description: Resolves conflicts between specialist output and verifier findings
+model: sonnet
+tools: Read, Write, Edit, Grep, Glob, Bash
+permissionMode: bypassPermissions
+maxTurns: 100
+---
+
+# Conflict Resolver
+
+Two agents disagree. You see both perspectives and make the final call.
+
+## Your Process
+
+1. Read the **Specialist's output** — what they built and why
+2. Read the **Verifier's findings** — what issues they found
+3. For each CRITICAL issue:
+   - Is the verifier right? → Fix it
+   - Is it a false positive? → Document why and keep specialist's version
+4. For each WARNING:
+   - Quick fix possible? → Fix it
+   - Trade-off? → Document the decision
+5. Apply all fixes directly to the codebase
+6. Output a resolution summary
+
+## Output Format
+
+\`\`\`
+## Resolution Summary
+
+### Critical Issues Resolved
+- [issue]: [action taken]
+
+### Warnings Addressed
+- [issue]: [action taken or reason to skip]
+
+### Final Verdict
+[Ship / Rework needed]
+\`\`\`
+
+Be decisive. Don't deliberate endlessly — pick the safer option and move on.
+RAGENT_EOF
+
+  echo "$resolver_path"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Main Entry: Blend, Execute, and Verify
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Execute a task with independent verification
+# Returns: the final output (specialist output if PASS, resolved output if FAIL)
+blend_and_verify() {
+  local task="$1"
+  local extra_context="${2:-}"
+  local session_dir="${3:-/tmp/merlin-blend-$$}"
+
+  mkdir -p "$session_dir"
+
+  # Get primary agent key to decide verification level
+  local top_agents primary_key
+  top_agents=$(blend_get_top_agents "$task" 4)
+  primary_key=$(echo "$top_agents" | head -1 | cut -d: -f2)
+
+  # ── Spawn 1: Specialist does the work ──
+  echo -e "${MAGENTA}${BOLD}  ⚡ Spawn 1: Specialist${RESET}"
+  local specialist_output
+  specialist_output=$(blend_and_spawn "$task" "$extra_context" "$session_dir")
+  local specialist_exit=$?
+
+  if [ $specialist_exit -ne 0 ]; then
+    echo -e "${RED}  ✗ Specialist failed (exit $specialist_exit)${RESET}"
+    echo "$specialist_output"
+    return $specialist_exit
+  fi
+
+  # Save specialist output for verification
+  echo "$specialist_output" > "$session_dir/specialist-output.md"
+  echo -e "${GREEN}  ✓ Specialist complete${RESET}"
+
+  # ── Check if verification is needed ──
+  if ! _verify_needs_independent "$primary_key" 2>/dev/null; then
+    echo -e "${DIM}  ○ Low-stakes task — skipping verification${RESET}"
+    echo "$specialist_output"
+    return 0
+  fi
+
+  # ── Spawn 2: Verifier reviews cold ──
+  echo -e "${MAGENTA}${BOLD}  🔍 Spawn 2: Independent Verifier${RESET}"
+  local verifier_agent
+  verifier_agent=$(_verify_build_agent "$primary_key" "$session_dir")
+
+  # Build verifier prompt — only sees the OUTPUT, not the original task
+  local verify_prompt="Review the following output from another agent. You do NOT know what they were asked to do. Judge the output purely on its own merits.
+
+## Agent Output to Verify
+
+${specialist_output}"
+
+  local verifier_output
+  verifier_output=$(claude --agent "$verifier_agent" --output-format text -p "$verify_prompt" 2>&1)
+  local verifier_exit=$?
+
+  echo "$verifier_output" > "$session_dir/verifier-output.md"
+
+  # ── Parse verdict ──
+  local verdict="UNKNOWN"
+  if echo "$verifier_output" | grep -qi "Verdict.*PASS_WITH_WARNINGS"; then
+    verdict="PASS_WITH_WARNINGS"
+  elif echo "$verifier_output" | grep -qi "Verdict.*FAIL"; then
+    verdict="FAIL"
+  elif echo "$verifier_output" | grep -qi "Verdict.*PASS"; then
+    verdict="PASS"
+  fi
+
+  echo -e "${CYAN}  Verdict: ${verdict}${RESET}"
+
+  # ── PASS: ship it ──
+  if [ "$verdict" = "PASS" ]; then
+    echo -e "${GREEN}  ✓ Verification passed — shipping${RESET}"
+    echo "$specialist_output"
+    return 0
+  fi
+
+  # ── PASS_WITH_WARNINGS: ship with notes ──
+  if [ "$verdict" = "PASS_WITH_WARNINGS" ]; then
+    echo -e "${YELLOW}  ⚠ Passed with warnings${RESET}"
+    echo "${specialist_output}
+
+---
+## Verification Notes
+${verifier_output}"
+    return 0
+  fi
+
+  # ── FAIL: spawn resolver ──
+  echo -e "${RED}  ✗ Verification failed — spawning resolver${RESET}"
+  echo -e "${MAGENTA}${BOLD}  🔧 Spawn 3: Conflict Resolver${RESET}"
+
+  local resolver_agent
+  resolver_agent=$(_verify_build_resolver "$session_dir")
+
+  local resolve_prompt="Two agents disagree. Resolve the conflict and apply fixes.
+
+## Specialist Output
+${specialist_output}
+
+## Verifier Findings
+${verifier_output}
+
+## Original Task
+${task}
+
+Fix all CRITICAL issues. Address WARNINGs where practical. Apply changes directly to files."
+
+  local resolver_output
+  resolver_output=$(claude --agent "$resolver_agent" --output-format text -p "$resolve_prompt" 2>&1)
+
+  echo "$resolver_output" > "$session_dir/resolver-output.md"
+  echo -e "${GREEN}  ✓ Resolution complete${RESET}"
+
+  echo "$resolver_output"
+  return 0
+}
+
+# Log verification result for blend learning
+_verify_log_result() {
+  local primary_key="$1"
+  local verdict="$2"
+  local session_dir="$3"
+  local log_file="${session_dir}/verification-log.jsonl"
+
+  echo "{\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"agent\":\"${primary_key}\",\"verdict\":\"${verdict}\"}" >> "$log_file"
+}

package/files/loop/lib/blend.sh

@@ -240,6 +240,11 @@ blend_get_top_agents() {
   local all_scored
   all_scored=$(blend_score_all "$task")
 
+  # Apply learning weights if available (Stage 4)
+  if type learn_apply_weights &>/dev/null; then
+    all_scored=$(echo "$all_scored" | learn_apply_weights)
+  fi
+
   local count=0
   local result=""
 
@@ -675,6 +680,24 @@ blend_show_decision() {
   if _blend_needs_cove "$primary_key" 2>/dev/null; then
     echo -e "    ${YELLOW}[CoVe]${RESET}    Chain-of-Verification enabled (high-stakes task)"
   fi
+
+  # Show verification status (Stage 1)
+  if type _verify_needs_independent &>/dev/null && _verify_needs_independent "$primary_key" 2>/dev/null; then
+    echo -e "    ${MAGENTA}[verify]${RESET}  Independent verification will run"
+  fi
+
+  # Show learning status (Stage 4)
+  if type learn_get_boost &>/dev/null; then
+    local boost
+    boost=$(learn_get_boost "$primary_key" 2>/dev/null || echo "0")
+    if [ "$boost" != "0" ]; then
+      if [ "$boost" -gt 0 ]; then
+        echo -e "    ${GREEN}[learn]${RESET}   +${boost} boost from historical success"
+      else
+        echo -e "    ${RED}[learn]${RESET}   ${boost} penalty from historical failures"
+      fi
+    fi
+  fi
 }
 
 # Show a one-line summary of the blend
@@ -712,20 +735,56 @@ blend_and_spawn() {
   local agent_path
   agent_path=$(blend_for_task "$task" "$session_dir")
 
+  # Extract agent info for learning (before spawn)
+  local _spawn_primary="" _spawn_secondaries=""
+  if type learn_record &>/dev/null; then
+    local _top_agents
+    _top_agents=$(blend_get_top_agents "$task" 4)
+    _spawn_primary=$(echo "$_top_agents" | head -1 | cut -d: -f2)
+    _spawn_secondaries=$(echo "$_top_agents" | tail -n +2 | cut -d: -f2 | paste -sd, -)
+  fi
+
   # Build the prompt (task + any extra context)
   local prompt="$task"
   if [ -n "$extra_context" ]; then
     prompt="${prompt}\n\n## Additional Context\n\n${extra_context}"
   fi
 
-  # Spawn
+  # Spawn (with timing)
+  local _spawn_start
+  _spawn_start=$(date +%s)
+
   local output
   output=$(claude --agent "$agent_path" --output-format text -p "$prompt" 2>&1)
   local exit_code=$?
 
-  # Clean up temp agent file
-  # rm -f "$agent_path"  # Keep for debugging — uncomment for production
+  # Record outcome for learning (Stage 4)
+  if type learn_record &>/dev/null && [ -n "$_spawn_primary" ]; then
+    local _spawn_end _spawn_duration
+    _spawn_end=$(date +%s)
+    _spawn_duration=$((_spawn_end - _spawn_start))
+    learn_record "$_spawn_primary" "$_spawn_secondaries" "$exit_code" "$_spawn_duration" "" 2>/dev/null || true
+  fi
 
   echo "$output"
   return $exit_code
 }
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Advanced Modules (Stage 1-4 Upgrades)
+# Source after core blend engine is loaded
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_BLEND_LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Stage 4: Blend Learning — track success rates, adjust scoring
+source "${_BLEND_LIB_DIR}/blend-learn.sh" 2>/dev/null || true
+
+# Stage 1: True Independent Verification — separate verifier agent
+source "${_BLEND_LIB_DIR}/blend-verify.sh" 2>/dev/null || true
+
+# Stage 2: Parallel Agent Execution — concurrent subtasks
+source "${_BLEND_LIB_DIR}/blend-parallel.sh" 2>/dev/null || true
+
+# Stage 3: Structured Handoffs — clean JSON pipeline context
+source "${_BLEND_LIB_DIR}/blend-handoff.sh" 2>/dev/null || true

package/files/loop/merlin-loop.sh

@@ -42,6 +42,11 @@ source "$SCRIPT_DIR/lib/sights.sh" 2>/dev/null || true       # Sights integratio
 source "$SCRIPT_DIR/lib/agents.sh" 2>/dev/null || true      # Agent profiles and routing
 source "$SCRIPT_DIR/lib/blend.sh" 2>/dev/null || true       # Dynamic agent blending engine
 source "$SCRIPT_DIR/lib/teams.sh" 2>/dev/null || true      # Agent Teams integration
+# Blend Engine Stages (loaded by blend.sh, listed here for visibility)
+# Stage 1: blend-verify.sh   — True Independent Verification
+# Stage 2: blend-parallel.sh — Parallel Agent Execution
+# Stage 3: blend-handoff.sh  — Structured Handoffs
+# Stage 4: blend-learn.sh    — Blend Learning
 source "$SCRIPT_DIR/lib/boot.sh" 2>/dev/null || true        # Boot sequence
 source "$SCRIPT_DIR/lib/session-end.sh" 2>/dev/null || true # Session end protocol
 source "$SCRIPT_DIR/lib/tui.sh" 2>/dev/null || true         # Interactive TUI

package/files/loop/merlin-session.sh

@@ -45,6 +45,11 @@ source "$SCRIPT_DIR/lib/agents.sh" 2>/dev/null || true
 source "$SCRIPT_DIR/lib/sights.sh" 2>/dev/null || true
 source "$SCRIPT_DIR/lib/boot.sh" 2>/dev/null || true
 source "$SCRIPT_DIR/lib/blend.sh" 2>/dev/null || true
+# Blend Engine Stages (loaded by blend.sh, listed here for visibility)
+# Stage 1: blend-verify.sh   — True Independent Verification
+# Stage 2: blend-parallel.sh — Parallel Agent Execution
+# Stage 3: blend-handoff.sh  — Structured Handoffs
+# Stage 4: blend-learn.sh    — Blend Learning
 
 # Colors
 : "${RESET:=\033[0m}"
@@ -471,6 +476,14 @@ See PROJECT.md in the repo root."
   # Log to history
   echo "{\"agent\":\"blend:${blend_label}\",\"task\":\"$(echo "$task" | head -c 100)\",\"duration\":$duration,\"exit_code\":$exit_code,\"timestamp\":$(date +%s)}" >> "$HISTORY_FILE"
 
+  # Record for blend learning (Stage 4)
+  if type learn_record &>/dev/null; then
+    local _primary _secondaries
+    _primary=$(blend_get_top_agents "$task" 4 2>/dev/null | head -1 | cut -d: -f2)
+    _secondaries=$(blend_get_top_agents "$task" 4 2>/dev/null | tail -n +2 | cut -d: -f2 | paste -sd, -)
+    learn_record "$_primary" "$_secondaries" "$exit_code" "$duration" "" 2>/dev/null || true
+  fi
+
   # Show result
   echo ""
   echo -e "${DIM}────────────────────────────────────────────────────────${RESET}"

package/files/merlin/VERSION

@@ -1 +1 @@
-3.6.3
+3.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-merlin-brain",
-  "version": "3.6.3",
+  "version": "3.7.0",
   "description": "Merlin - The Ultimate AI Brain for Claude Code. One install: workflows, agents, loop, and Sights MCP server.",
   "type": "module",
   "main": "./dist/server/index.js",