diff --git a/.gitignore b/.gitignore
index 74dcc42..66446e8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,10 @@ Thumbs.db
 node_modules/
 npm-debug.log*
 
+# Python
+__pycache__/
+*.pyc
+
 # Misc
 *.log
 *.tmp
@@ -33,4 +37,4 @@ claudedocs/
 .mcp.json
 
 # Multi-provider (will be moved to dedicated repo)
-examples/multi-provider/
+examples/multi-provider/
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b8c589..9d7e124 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -48,6 +48,27 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - Golden rule banner: "LLM Thinks → MCP Controls → Tools Execute → Data Locked"
 - **machine-readable/reference.yaml**: Added `architecture_mcp_visual` (SVG diagram reference)
 
+## [3.12.1] - 2026-01-25
+
+### Added
+
+- **Bridge Script: Claude Code → doobidoo → LM Studio** (`examples/scripts/bridge.py`)
+  - Python CLI for executing Claude Code plans locally via LM Studio
+  - Cost optimization: Plan with Opus (~$0.50-2), execute free locally (80-90% savings)
+  - Architecture: Claude Code stores plans in doobidoo SQLite → bridge reads → LM Studio executes
+  - 5 components: DoobidooReader, LMStudioClient, Validator, StepExecutor, PlanExecutor
+  - JSON Schema for plan validation (`examples/scripts/bridge-plan-schema.json`)
+  - 4 validation types: json, syntax_check, contains_keys, non_empty
+  - Failure handling: retry_with_context, skip, halt strategies
+  - CLI: `--health`, `--list`, `--plan ID`, `-v` verbose mode
+  - Documentation in ultimate-guide.md §11.2 "Local Execution Bridge" (line 14079)
+- **examples/scripts/README.md**: New documentation for all utility scripts
+- **machine-readable/reference.yaml**: Added bridge_script, bridge_schema, bridge_guide entries
+
+### Changed
+
+- **.gitignore**: Added `__pycache__/` and `*.pyc` for Python artifacts
+
 ## [3.12.0] - 2026-01-25
 
 ### Added
diff --git a/README.md b/README.md
index f88dc24..3f3da51 100644
--- a/README.md
+++ b/README.md
@@ -373,7 +373,7 @@ Claude Code sends your prompts, file contents, and MCP results to Anthropic serv
 
 **Status**: Research preview (Pro $20/mo or Max $100-200/mo, macOS only, **VPN incompatible**)
 
-**Archive**: Historical versions available in git history (pre-v3.12.0)
+**Archive**: Historical versions available in git history (pre-v3.12.1)
 
 </details>
 
@@ -443,7 +443,7 @@ Licensed under [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
 
 ---
 
-*Version 3.12.0 | January 2026 | Crafted with Claude*
+*Version 3.12.1 | January 2026 | Crafted with Claude*
 
 <!-- SEO Keywords -->
 <!-- claude code, claude code tutorial, anthropic cli, ai coding assistant, claude code mcp,
diff --git a/VERSION b/VERSION
index 92536a9..171a6a9 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-3.12.0
+3.12.1
diff --git a/examples/scripts/README.md b/examples/scripts/README.md
new file mode 100644
index 0000000..afd0bf6
--- /dev/null
+++ b/examples/scripts/README.md
@@ -0,0 +1,265 @@
+# Scripts
+
+Utility scripts for Claude Code power users.
+
+## Overview
+
+| Script | Description |
+|--------|-------------|
+| `audit-scan.sh` | Security and quality audit of Claude Code setup |
+| `check-claude.sh/.ps1` | Health check for Claude Code installation |
+| `clean-reinstall-claude.sh/.ps1` | Clean reinstall of Claude Code |
+| `fresh-context-loop.sh` | Run Claude Code in fresh context loops |
+| `session-search.sh` | Search across Claude Code session histories |
+| `session-stats.sh` | Statistics about Claude Code sessions |
+| `bridge.py` | Bridge: Claude Code → doobidoo → LM Studio |
+
+---
+
+## Bridge Script (Claude Code → LM Studio)
+
+**Purpose**: Execute Claude Code plans locally via LM Studio for cost savings.
+
+### Architecture
+
+```
+┌──────────────┐     store_memory      ┌─────────────────┐
+│ Claude Code  │ ─────────────────────►│    doobidoo     │
+│   (Opus)     │   tag: "plan"         │   SQLite + Vec  │
+│   PLANNER    │   status: "pending"   │ ~/.mcp-memory-  │
+└──────────────┘                       │  service/       │
+                                       └────────┬────────┘
+                                                │
+                                                │ Direct SQLite read
+                                                ▼
+                                       ┌─────────────────┐
+                                       │   bridge.py     │
+                                       │                 │
+                                       │ • PlanReader    │
+                                       │ • StepExecutor  │
+                                       │ • Validator     │
+                                       └────────┬────────┘
+                                                │
+                                                │ HTTP POST
+                                                │ /v1/chat/completions
+                                                ▼
+                                       ┌─────────────────┐
+                                       │    LM Studio    │
+                                       │  localhost:1234 │
+                                       └─────────────────┘
+```
+
+### Requirements
+
+```bash
+pip install httpx
+```
+
+- **doobidoo MCP server** with SQLite backend (`~/.mcp-memory-service/`)
+- **LM Studio** running on `localhost:1234` with a loaded model
+
+### Usage
+
+```bash
+# Check LM Studio is running
+python bridge.py --health
+
+# List pending plans
+python bridge.py --list
+
+# Execute all pending plans
+python bridge.py
+
+# Execute specific plan
+python bridge.py --plan plan_auth_refactor
+
+# Verbose mode
+python bridge.py -v
+```
+
+### Workflow
+
+#### 1. Claude Code creates the plan
+
+In Claude Code (Opus), store a plan via doobidoo:
+
+```
+store_memory("""
+{
+  "$schema": "bridge-plan-v1",
+  "id": "plan_auth_refactor",
+  "status": "pending",
+  "context": {
+    "project": "/path/to/project",
+    "objective": "Refactor authentication to use JWT",
+    "files_context": {
+      "src/auth.py": "LOAD",
+      "src/config.py": "REFERENCE"
+    }
+  },
+  "steps": [
+    {
+      "id": 1,
+      "type": "analysis",
+      "description": "Analyze current auth implementation",
+      "prompt": "Analyze the authentication code and identify migration points for JWT.",
+      "validation": {"type": "non_empty"}
+    },
+    {
+      "id": 2,
+      "type": "code_generation",
+      "description": "Generate JWT middleware",
+      "prompt": "Generate a JWT authentication middleware based on the analysis.",
+      "depends_on": [1],
+      "validation": {"type": "syntax_check"},
+      "file_output": "src/jwt_auth.py"
+    }
+  ]
+}
+""", tags=["plan"])
+```
+
+#### 2. Execute via bridge
+
+```bash
+python bridge.py
+# Reads plan from doobidoo SQLite
+# Executes each step via LM Studio
+# Stores results back in doobidoo
+```
+
+#### 3. Retrieve results in Claude Code
+
+```
+search_by_tag(["result", "plan_auth_refactor"])
+# Returns all execution results
+```
+
+### Plan Schema
+
+See `bridge-plan-schema.json` for the complete JSON Schema.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `$schema` | Yes | Must be `"bridge-plan-v1"` |
+| `id` | Yes | Unique plan ID (e.g., `plan_auth_refactor`) |
+| `status` | Yes | `pending`, `in_progress`, `completed`, `failed` |
+| `context.objective` | Yes | High-level goal description |
+| `context.project` | No | Absolute path to project root |
+| `context.files_context` | No | Files to inject (`LOAD`) or reference |
+| `steps` | Yes | Array of execution steps |
+
+### Step Types
+
+| Type | Use Case |
+|------|----------|
+| `analysis` | Analyze code, identify patterns, plan changes |
+| `code_generation` | Generate new code from scratch |
+| `code_modification` | Modify existing code |
+| `decision` | Make architectural or design decisions |
+
+### Validation Types
+
+| Type | Description |
+|------|-------------|
+| `non_empty` | Output is not empty (default) |
+| `json` | Valid JSON output |
+| `syntax_check` | Valid Python syntax |
+| `contains_keys` | JSON contains specific keys |
+
+### Failure Handling
+
+| on_failure | Behavior |
+|------------|----------|
+| `retry_with_context` | Retry with error feedback (default) |
+| `skip` | Skip step, continue execution |
+| `halt` | Stop entire plan |
+
+### Cost Savings
+
+- **Planning** (Opus): ~$0.50-2.00 per complex plan
+- **Execution** (LM Studio): Free (local)
+- **ROI**: 80-90% cost reduction on implementation tasks
+
+### Limitations
+
+| Limitation | Mitigation |
+|------------|------------|
+| Local model quality varies | Strict validation + retries |
+| No MCP tools in LM Studio | Inject file content in context |
+| Limited context window | Truncate old results |
+| No streaming | 120s timeout per step |
+
+---
+
+## Audit Scan
+
+Security and quality audit of your Claude Code configuration.
+
+```bash
+./audit-scan.sh
+```
+
+Checks:
+- Sensitive data in CLAUDE.md files
+- Permission configurations
+- MCP server security
+- Hook script safety
+
+---
+
+## Health Check
+
+Quick verification of Claude Code installation.
+
+```bash
+# macOS/Linux
+./check-claude.sh
+
+# Windows
+./check-claude.ps1
+```
+
+---
+
+## Clean Reinstall
+
+Complete reinstall preserving configurations.
+
+```bash
+# macOS/Linux
+./clean-reinstall-claude.sh
+
+# Windows
+./clean-reinstall-claude.ps1
+```
+
+---
+
+## Fresh Context Loop
+
+Run Claude Code with fresh context for long-running tasks.
+
+```bash
+./fresh-context-loop.sh --iterations 5 --project /path/to/project
+```
+
+---
+
+## Session Search
+
+Search across all Claude Code session histories.
+
+```bash
+./session-search.sh "authentication"
+```
+
+---
+
+## Session Stats
+
+Get statistics about your Claude Code usage.
+
+```bash
+./session-stats.sh
+```
diff --git a/examples/scripts/bridge-plan-schema.json b/examples/scripts/bridge-plan-schema.json
new file mode 100644
index 0000000..eee6ada
--- /dev/null
+++ b/examples/scripts/bridge-plan-schema.json
@@ -0,0 +1,126 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "bridge-plan-v1",
+  "title": "Bridge Plan Schema",
+  "description": "Schema for Claude Code → LM Studio bridge execution plans",
+  "type": "object",
+  "required": ["$schema", "id", "status", "context", "steps"],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "const": "bridge-plan-v1"
+    },
+    "id": {
+      "type": "string",
+      "pattern": "^plan_[a-z0-9_]+$",
+      "description": "Unique plan identifier (e.g., plan_auth_refactor)"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["pending", "in_progress", "completed", "failed"],
+      "default": "pending"
+    },
+    "context": {
+      "type": "object",
+      "required": ["objective"],
+      "properties": {
+        "project": {
+          "type": "string",
+          "description": "Absolute path to project root"
+        },
+        "objective": {
+          "type": "string",
+          "description": "High-level description of what the plan achieves"
+        },
+        "constraints": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Constraints or requirements for execution"
+        },
+        "files_context": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["LOAD", "REFERENCE"],
+            "description": "LOAD = inject content, REFERENCE = mention path only"
+          },
+          "description": "Files to include in execution context"
+        }
+      }
+    },
+    "steps": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "type", "description", "prompt"],
+        "properties": {
+          "id": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Step number (1-indexed)"
+          },
+          "type": {
+            "type": "string",
+            "enum": ["analysis", "code_generation", "code_modification", "decision"],
+            "description": "Type of task for this step"
+          },
+          "description": {
+            "type": "string",
+            "maxLength": 200,
+            "description": "Short description of what this step does"
+          },
+          "prompt": {
+            "type": "string",
+            "description": "Full prompt to send to LM Studio"
+          },
+          "depends_on": {
+            "type": "array",
+            "items": {"type": "integer"},
+            "default": [],
+            "description": "Step IDs that must complete before this one"
+          },
+          "validation": {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["json", "syntax_check", "contains_keys", "non_empty"],
+                "description": "Validation method for step output"
+              },
+              "keys": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Required keys for contains_keys validation"
+              }
+            },
+            "required": ["type"]
+          },
+          "file_output": {
+            "type": "string",
+            "description": "Path to write output (relative to project root)"
+          },
+          "on_failure": {
+            "type": "string",
+            "enum": ["retry_with_context", "skip", "halt"],
+            "default": "retry_with_context",
+            "description": "Behavior when step fails validation"
+          },
+          "max_retries": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 5,
+            "default": 2,
+            "description": "Maximum retry attempts"
+          }
+        }
+      }
+    },
+    "rollback_strategy": {
+      "type": "string",
+      "enum": ["revert_files", "none"],
+      "default": "none",
+      "description": "What to do on plan failure"
+    }
+  }
+}
diff --git a/examples/scripts/bridge.py b/examples/scripts/bridge.py
new file mode 100755
index 0000000..088116a
--- /dev/null
+++ b/examples/scripts/bridge.py
@@ -0,0 +1,715 @@
+#!/usr/bin/env python3
+"""
+Bridge Script: Claude Code → doobidoo → LM Studio
+
+Orchestrates plan execution from Claude Code (stored in doobidoo SQLite)
+to local LM Studio for cost-effective execution.
+
+Usage:
+    python bridge.py              # Execute all pending plans
+    python bridge.py --list       # List pending plans
+    python bridge.py --plan ID    # Execute specific plan
+    python bridge.py --health     # Check LM Studio connectivity
+
+Requires:
+    - doobidoo MCP server with SQLite backend (~/.mcp-memory-service/)
+    - LM Studio running on localhost:1234
+    - httpx: pip install httpx
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import logging
+import shutil
+import sqlite3
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+try:
+    import httpx
+except ImportError:
+    print("Error: httpx required. Install with: pip install httpx")
+    sys.exit(1)
+
+
+# === Configuration ===
+
+DOOBIDOO_DB = Path.home() / ".mcp-memory-service" / "memories.db"
+LM_STUDIO_URL = "http://localhost:1234/v1/chat/completions"
+LM_STUDIO_TIMEOUT = 120.0
+DEFAULT_MODEL = "default"  # LM Studio uses loaded model
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)-7s | %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("bridge")
+
+
+# === Data Classes ===
+
+
+@dataclass
+class StepResult:
+    """Result of executing a single step."""
+
+    step_id: int
+    success: bool
+    output: str
+    error: str | None = None
+    retries: int = 0
+
+
+@dataclass
+class PlanResult:
+    """Result of executing a complete plan."""
+
+    plan_id: str
+    success: bool
+    steps: list[StepResult] = field(default_factory=list)
+    error: str | None = None
+
+
+# === Doobidoo Reader ===
+
+
+class DoobidooReader:
+    """Direct SQLite access to doobidoo memory database."""
+
+    def __init__(self, db_path: Path = DOOBIDOO_DB):
+        self.db_path = db_path
+        if not db_path.exists():
+            raise FileNotFoundError(f"doobidoo database not found: {db_path}")
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(self.db_path)
+
+    def get_pending_plans(self) -> list[dict[str, Any]]:
+        """Fetch all plans with status=pending."""
+        plans = []
+        with self._connect() as conn:
+            cursor = conn.execute(
+                """
+                SELECT id, content, metadata, created_at
+                FROM memories
+                WHERE content LIKE '%"$schema": "bridge-plan-v1"%'
+                ORDER BY created_at DESC
+                """
+            )
+            for row in cursor:
+                try:
+                    content = json.loads(row[1])
+                    if content.get("status") == "pending":
+                        plans.append(
+                            {
+                                "db_id": row[0],
+                                "plan": content,
+                                "metadata": json.loads(row[2]) if row[2] else {},
+                                "created_at": row[3],
+                            }
+                        )
+                except json.JSONDecodeError:
+                    continue
+        return plans
+
+    def get_plan_by_id(self, plan_id: str) -> dict[str, Any] | None:
+        """Fetch a specific plan by its plan ID."""
+        with self._connect() as conn:
+            cursor = conn.execute(
+                """
+                SELECT id, content, metadata, created_at
+                FROM memories
+                WHERE content LIKE ?
+                ORDER BY created_at DESC
+                LIMIT 1
+                """,
+                (f'%"id": "{plan_id}"%',),
+            )
+            row = cursor.fetchone()
+            if row:
+                try:
+                    content = json.loads(row[1])
+                    if content.get("$schema") == "bridge-plan-v1":
+                        return {
+                            "db_id": row[0],
+                            "plan": content,
+                            "metadata": json.loads(row[2]) if row[2] else {},
+                            "created_at": row[3],
+                        }
+                except json.JSONDecodeError:
+                    pass
+        return None
+
+    def update_plan_status(self, db_id: str, status: str) -> None:
+        """Update plan status in the database."""
+        with self._connect() as conn:
+            cursor = conn.execute(
+                "SELECT content FROM memories WHERE id = ?", (db_id,)
+            )
+            row = cursor.fetchone()
+            if row:
+                content = json.loads(row[0])
+                content["status"] = status
+                conn.execute(
+                    "UPDATE memories SET content = ? WHERE id = ?",
+                    (json.dumps(content), db_id),
+                )
+                conn.commit()
+
+    def store_result(self, plan_id: str, result: PlanResult) -> None:
+        """Store execution result as a new memory entry."""
+        result_data = {
+            "type": "bridge_result",
+            "plan_id": plan_id,
+            "success": result.success,
+            "executed_at": datetime.now().isoformat(),
+            "steps": [
+                {
+                    "id": s.step_id,
+                    "success": s.success,
+                    "output": s.output[:2000],  # Truncate for storage
+                    "error": s.error,
+                    "retries": s.retries,
+                }
+                for s in result.steps
+            ],
+            "error": result.error,
+        }
+
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO memories (id, content, metadata, created_at)
+                VALUES (?, ?, ?, ?)
+                """,
+                (
+                    f"result_{plan_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                    json.dumps(result_data),
+                    json.dumps({"tags": ["result", plan_id]}),
+                    datetime.now().isoformat(),
+                ),
+            )
+            conn.commit()
+
+
+# === LM Studio Client ===
+
+
+class LMStudioClient:
+    """HTTP client for LM Studio API."""
+
+    def __init__(self, base_url: str = LM_STUDIO_URL, timeout: float = LM_STUDIO_TIMEOUT):
+        self.base_url = base_url
+        self.timeout = timeout
+        self.client = httpx.Client(timeout=timeout)
+
+    def health_check(self) -> bool:
+        """Check if LM Studio is running and responsive."""
+        try:
+            # Try models endpoint first
+            response = self.client.get(
+                self.base_url.replace("/chat/completions", "/models")
+            )
+            return response.status_code == 200
+        except httpx.RequestError:
+            return False
+
+    def generate(self, prompt: str, system: str | None = None) -> str:
+        """Generate completion from LM Studio."""
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+
+        response = self.client.post(
+            self.base_url,
+            json={
+                "model": DEFAULT_MODEL,
+                "messages": messages,
+                "temperature": 0.3,
+                "max_tokens": 4096,
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self.client.close()
+
+
+# === Validators ===
+
+
+class Validator:
+    """Validation functions for step outputs."""
+
+    @staticmethod
+    def validate(output: str, validation: dict[str, Any]) -> tuple[bool, str | None]:
+        """Validate output based on validation config."""
+        val_type = validation.get("type", "non_empty")
+
+        if val_type == "non_empty":
+            return Validator.non_empty(output)
+        elif val_type == "json":
+            return Validator.json_valid(output)
+        elif val_type == "syntax_check":
+            return Validator.python_syntax(output)
+        elif val_type == "contains_keys":
+            keys = validation.get("keys", [])
+            return Validator.contains_keys(output, keys)
+        else:
+            return True, None
+
+    @staticmethod
+    def non_empty(output: str) -> tuple[bool, str | None]:
+        """Check output is not empty or whitespace."""
+        if output and output.strip():
+            return True, None
+        return False, "Output is empty"
+
+    @staticmethod
+    def json_valid(output: str) -> tuple[bool, str | None]:
+        """Check output is valid JSON."""
+        try:
+            # Try to extract JSON from markdown code blocks
+            content = output
+            if "```json" in output:
+                start = output.find("```json") + 7
+                end = output.find("```", start)
+                if end > start:
+                    content = output[start:end].strip()
+            elif "```" in output:
+                start = output.find("```") + 3
+                end = output.find("```", start)
+                if end > start:
+                    content = output[start:end].strip()
+
+            json.loads(content)
+            return True, None
+        except json.JSONDecodeError as e:
+            return False, f"Invalid JSON: {e}"
+
+    @staticmethod
+    def python_syntax(output: str) -> tuple[bool, str | None]:
+        """Check output is valid Python syntax."""
+        try:
+            # Extract code from markdown blocks
+            content = output
+            if "```python" in output:
+                start = output.find("```python") + 9
+                end = output.find("```", start)
+                if end > start:
+                    content = output[start:end].strip()
+            elif "```" in output:
+                start = output.find("```") + 3
+                end = output.find("```", start)
+                if end > start:
+                    content = output[start:end].strip()
+
+            ast.parse(content)
+            return True, None
+        except SyntaxError as e:
+            return False, f"Syntax error: {e}"
+
+    @staticmethod
+    def contains_keys(output: str, keys: list[str]) -> tuple[bool, str | None]:
+        """Check JSON output contains required keys."""
+        valid, error = Validator.json_valid(output)
+        if not valid:
+            return valid, error
+
+        try:
+            # Extract JSON content
+            content = output
+            if "```json" in output:
+                start = output.find("```json") + 7
+                end = output.find("```", start)
+                if end > start:
+                    content = output[start:end].strip()
+
+            data = json.loads(content)
+            missing = [k for k in keys if k not in data]
+            if missing:
+                return False, f"Missing keys: {missing}"
+            return True, None
+        except (json.JSONDecodeError, TypeError) as e:
+            return False, f"JSON parse error: {e}"
+
+
+# === Step Executor ===
+
+
+class StepExecutor:
+    """Executes individual plan steps."""
+
+    def __init__(self, lm_client: LMStudioClient, project_root: Path | None = None):
+        self.lm_client = lm_client
+        self.project_root = project_root
+        self.context_accumulator: dict[int, str] = {}
+
+    def load_file_context(self, files_context: dict[str, str]) -> str:
+        """Load file contents for context injection."""
+        if not self.project_root or not files_context:
+            return ""
+
+        context_parts = []
+        for file_path, load_type in files_context.items():
+            full_path = self.project_root / file_path
+            if load_type == "LOAD" and full_path.exists():
+                try:
+                    content = full_path.read_text()
+                    context_parts.append(f"=== {file_path} ===\n{content}")
+                except Exception as e:
+                    context_parts.append(f"=== {file_path} ===\n[Error loading: {e}]")
+            elif load_type == "REFERENCE":
+                context_parts.append(f"=== {file_path} ===\n[File reference only]")
+
+        return "\n\n".join(context_parts)
+
+    def build_prompt(self, step: dict[str, Any], file_context: str) -> str:
+        """Build complete prompt with context."""
+        parts = []
+
+        # Add file context if available
+        if file_context:
+            parts.append("## File Context\n" + file_context)
+
+        # Add results from dependencies
+        depends_on = step.get("depends_on", [])
+        if depends_on:
+            dep_context = []
+            for dep_id in depends_on:
+                if dep_id in self.context_accumulator:
+                    dep_context.append(
+                        f"## Result from Step {dep_id}\n{self.context_accumulator[dep_id]}"
+                    )
+            if dep_context:
+                parts.append("\n\n".join(dep_context))
+
+        # Add the actual prompt
+        parts.append("## Task\n" + step["prompt"])
+
+        return "\n\n".join(parts)
+
+    def execute(
+        self, step: dict[str, Any], file_context: str
+    ) -> StepResult:
+        """Execute a single step with retries."""
+        step_id = step["id"]
+        max_retries = step.get("max_retries", 2)
+        on_failure = step.get("on_failure", "retry_with_context")
+        validation = step.get("validation", {"type": "non_empty"})
+
+        prompt = self.build_prompt(step, file_context)
+        retries = 0
+        last_error = None
+
+        while retries <= max_retries:
+            try:
+                log.info(f"Step {step_id}: Executing (attempt {retries + 1})")
+                output = self.lm_client.generate(prompt)
+
+                # Validate output
+                valid, error = Validator.validate(output, validation)
+                if valid:
+                    # Store in accumulator for dependent steps
+                    self.context_accumulator[step_id] = output
+
+                    # Write file if specified
+                    file_output = step.get("file_output")
+                    if file_output and self.project_root:
+                        self._write_output(file_output, output)
+
+                    log.info(f"Step {step_id}: Success")
+                    return StepResult(
+                        step_id=step_id,
+                        success=True,
+                        output=output,
+                        retries=retries,
+                    )
+
+                last_error = error
+                log.warning(f"Step {step_id}: Validation failed - {error}")
+
+                if on_failure == "retry_with_context" and retries < max_retries:
+                    # Add error context to prompt for retry
+                    prompt += f"\n\n## Previous Attempt Failed\nError: {error}\nPlease fix and try again."
+                    retries += 1
+                elif on_failure == "skip":
+                    return StepResult(
+                        step_id=step_id,
+                        success=False,
+                        output=output,
+                        error=f"Skipped after validation failure: {error}",
+                    )
+                else:
+                    break
+
+            except httpx.RequestError as e:
+                last_error = str(e)
+                log.error(f"Step {step_id}: Request error - {e}")
+                retries += 1
+
+        return StepResult(
+            step_id=step_id,
+            success=False,
+            output="",
+            error=last_error,
+            retries=retries,
+        )
+
+    def _write_output(self, file_path: str, output: str) -> None:
+        """Write step output to file."""
+        if not self.project_root:
+            return
+
+        full_path = self.project_root / file_path
+
+        # Extract code from markdown blocks
+        content = output
+        if "```python" in output:
+            start = output.find("```python") + 9
+            end = output.find("```", start)
+            if end > start:
+                content = output[start:end].strip()
+        elif "```" in output:
+            start = output.find("```") + 3
+            # Skip language identifier if present
+            newline = output.find("\n", start)
+            if newline > start:
+                start = newline + 1
+            end = output.find("```", start)
+            if end > start:
+                content = output[start:end].strip()
+
+        # Create parent directories
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Backup existing file
+        if full_path.exists():
+            backup = full_path.with_suffix(full_path.suffix + ".bak")
+            shutil.copy2(full_path, backup)
+
+        full_path.write_text(content)
+        log.info(f"Wrote output to {file_path}")
+
+
+# === Plan Executor ===
+
+
+class PlanExecutor:
+    """Executes complete plans."""
+
+    def __init__(self, reader: DoobidooReader, lm_client: LMStudioClient):
+        self.reader = reader
+        self.lm_client = lm_client
+
+    def execute(self, plan_data: dict[str, Any]) -> PlanResult:
+        """Execute a complete plan."""
+        db_id = plan_data["db_id"]
+        plan = plan_data["plan"]
+        plan_id = plan["id"]
+
+        log.info(f"Executing plan: {plan_id}")
+        log.info(f"Objective: {plan['context'].get('objective', 'N/A')}")
+
+        # Update status to in_progress
+        self.reader.update_plan_status(db_id, "in_progress")
+
+        # Setup executor
+        project_root = None
+        if project_path := plan["context"].get("project"):
+            project_root = Path(project_path)
+            if not project_root.exists():
+                log.warning(f"Project root does not exist: {project_root}")
+                project_root = None
+
+        step_executor = StepExecutor(self.lm_client, project_root)
+
+        # Load file context
+        files_context = plan["context"].get("files_context", {})
+        file_context = step_executor.load_file_context(files_context)
+
+        # Track step results
+        results: list[StepResult] = []
+        failed_steps: set[int] = set()
+
+        # Execute steps in order
+        for step in plan["steps"]:
+            step_id = step["id"]
+
+            # Check dependencies
+            depends_on = step.get("depends_on", [])
+            if any(dep in failed_steps for dep in depends_on):
+                log.warning(f"Step {step_id}: Skipping due to failed dependency")
+                results.append(
+                    StepResult(
+                        step_id=step_id,
+                        success=False,
+                        output="",
+                        error="Skipped: dependency failed",
+                    )
+                )
+                failed_steps.add(step_id)
+                continue
+
+            # Execute step
+            result = step_executor.execute(step, file_context)
+            results.append(result)
+
+            if not result.success:
+                failed_steps.add(step_id)
+                on_failure = step.get("on_failure", "retry_with_context")
+                if on_failure == "halt":
+                    log.error(f"Step {step_id} failed with halt policy - stopping plan")
+                    break
+
+        # Determine overall success
+        success = all(r.success for r in results)
+
+        # Handle rollback if needed
+        if not success and plan.get("rollback_strategy") == "revert_files":
+            self._rollback(project_root, plan["steps"])
+
+        # Update final status
+        final_status = "completed" if success else "failed"
+        self.reader.update_plan_status(db_id, final_status)
+
+        # Create result
+        plan_result = PlanResult(
+            plan_id=plan_id,
+            success=success,
+            steps=results,
+            error=None if success else "One or more steps failed",
+        )
+
+        # Store result
+        self.reader.store_result(plan_id, plan_result)
+
+        log.info(f"Plan {plan_id}: {'Completed successfully' if success else 'Failed'}")
+        return plan_result
+
+    def _rollback(self, project_root: Path | None, steps: list[dict]) -> None:
+        """Rollback file changes by restoring backups."""
+        if not project_root:
+            return
+
+        log.info("Rolling back file changes...")
+        for step in steps:
+            if file_output := step.get("file_output"):
+                backup = project_root / (file_output + ".bak")
+                original = project_root / file_output
+                if backup.exists():
+                    shutil.move(str(backup), str(original))
+                    log.info(f"Restored {file_output}")
+
+
+# === CLI ===
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Bridge: Claude Code → doobidoo → LM Studio"
+    )
+    parser.add_argument("--list", action="store_true", help="List pending plans")
+    parser.add_argument("--plan", type=str, help="Execute specific plan by ID")
+    parser.add_argument("--health", action="store_true", help="Check LM Studio health")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        log.setLevel(logging.DEBUG)
+
+    # Health check
+    if args.health:
+        client = LMStudioClient()
+        if client.health_check():
+            print("LM Studio: OK (running at localhost:1234)")
+            client.close()
+            return 0
+        else:
+            print("LM Studio: NOT RUNNING")
+            print("Start LM Studio and load a model first.")
+            client.close()
+            return 1
+
+    # Check doobidoo database
+    try:
+        reader = DoobidooReader()
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        print("Ensure doobidoo MCP server has been used at least once.")
+        return 1
+
+    # List plans
+    if args.list:
+        plans = reader.get_pending_plans()
+        if not plans:
+            print("No pending plans found.")
+            return 0
+
+        print(f"Found {len(plans)} pending plan(s):\n")
+        for p in plans:
+            plan = p["plan"]
+            print(f"  ID: {plan['id']}")
+            print(f"  Objective: {plan['context'].get('objective', 'N/A')}")
+            print(f"  Steps: {len(plan['steps'])}")
+            print(f"  Created: {p['created_at']}")
+            print()
+        return 0
+
+    # Check LM Studio
+    lm_client = LMStudioClient()
+    if not lm_client.health_check():
+        print("Error: LM Studio is not running at localhost:1234")
+        print("Start LM Studio and load a model first.")
+        lm_client.close()
+        return 1
+
+    executor = PlanExecutor(reader, lm_client)
+
+    # Execute specific plan
+    if args.plan:
+        plan_data = reader.get_plan_by_id(args.plan)
+        if not plan_data:
+            print(f"Plan not found: {args.plan}")
+            lm_client.close()
+            return 1
+
+        result = executor.execute(plan_data)
+        lm_client.close()
+        return 0 if result.success else 1
+
+    # Execute all pending plans
+    plans = reader.get_pending_plans()
+    if not plans:
+        print("No pending plans to execute.")
+        lm_client.close()
+        return 0
+
+    print(f"Executing {len(plans)} pending plan(s)...\n")
+    all_success = True
+
+    for plan_data in plans:
+        result = executor.execute(plan_data)
+        if not result.success:
+            all_success = False
+        print()
+
+    lm_client.close()
+    return 0 if all_success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/guide/cheatsheet.md b/guide/cheatsheet.md
index b79958f..f13093b 100644
--- a/guide/cheatsheet.md
+++ b/guide/cheatsheet.md
@@ -6,7 +6,7 @@
 
 **Written with**: Claude (Anthropic)
 
-**Version**: 3.12.0 | **Last Updated**: January 2026
+**Version**: 3.12.1 | **Last Updated**: January 2026
 
 ---
 
@@ -424,4 +424,4 @@ where.exe claude; claude doctor; claude mcp list
 
 **Author**: Florian BRUNIAUX | [@Méthode Aristote](https://methode-aristote.fr) | Written with Claude
 
-*Last updated: January 2026 | Version 3.12.0*
+*Last updated: January 2026 | Version 3.12.1*
diff --git a/guide/ultimate-guide.md b/guide/ultimate-guide.md
index 1458379..851cbd1 100644
--- a/guide/ultimate-guide.md
+++ b/guide/ultimate-guide.md
@@ -10,7 +10,7 @@
 
 **Last updated**: January 2026
 
-**Version**: 3.12.0
+**Version**: 3.12.1
 
 ---
 
@@ -13612,6 +13612,7 @@ source ~/.bashrc
 Diagnostic scripts for instant troubleshooting. Get them from:
 - Windows: [`examples/scripts/check-claude.ps1`](../examples/scripts/check-claude.ps1)
 - macOS/Linux: [`examples/scripts/check-claude.sh`](../examples/scripts/check-claude.sh)
+- Bridge health: `python examples/scripts/bridge.py --health` (LM Studio connectivity)
 
 ### Full Clean Reinstall Procedures
 
@@ -14076,6 +14077,83 @@ cco   # Offline mode (Ollama, 100% local)
 
 See: [cc-copilot-bridge Quick Start](https://github.com/FlorianBruniaux/cc-copilot-bridge#-quick-start)
 
+### Local Execution Bridge (Opus Plan → LM Studio Execute)
+
+For maximum cost savings, use Claude Code (Opus) for planning only, then execute locally via LM Studio.
+
+**Architecture:**
+
+```
+┌──────────────┐     store_memory      ┌─────────────────┐
+│ Claude Code  │ ─────────────────────►│    doobidoo     │
+│   (Opus)     │   tag: "plan"         │   SQLite + Vec  │
+│   PLANNER    │   status: "pending"   └────────┬────────┘
+└──────────────┘                                │
+                                                ▼
+                                       ┌─────────────────┐
+                                       │   bridge.py     │
+                                       │  (Python CLI)   │
+                                       └────────┬────────┘
+                                                │ HTTP
+                                                ▼
+                                       ┌─────────────────┐
+                                       │    LM Studio    │
+                                       │  localhost:1234 │
+                                       │   (MLX local)   │
+                                       └─────────────────┘
+```
+
+**Cost model:**
+- Planning (Opus): ~$0.50-2.00 per complex plan
+- Execution (LM Studio): Free (100% local)
+- **ROI**: 80-90% cost reduction on implementation tasks
+
+**Setup:**
+
+```bash
+# Requires doobidoo MCP and LM Studio running
+pip install httpx
+
+# Health check
+python examples/scripts/bridge.py --health
+
+# List pending plans
+python examples/scripts/bridge.py --list
+
+# Execute all pending plans
+python examples/scripts/bridge.py
+```
+
+**Workflow:**
+
+1. **Claude Code creates plan** (stored in doobidoo):
+```json
+{
+  "$schema": "bridge-plan-v1",
+  "id": "plan_jwt_migration",
+  "status": "pending",
+  "context": {
+    "objective": "Migrate auth to JWT",
+    "files_context": {"src/auth.py": "LOAD"}
+  },
+  "steps": [
+    {"id": 1, "type": "analysis", "prompt": "..."},
+    {"id": 2, "type": "code_generation", "depends_on": [1], "file_output": "src/jwt.py"}
+  ]
+}
+```
+
+2. **Bridge executes locally** via LM Studio
+3. **Results stored** back in doobidoo for Claude Code to review
+
+**When to use:**
+- Implementation tasks (not architectural decisions)
+- Code generation with clear specs
+- Bulk transformations
+- When Opus planning + local execution beats Opus end-to-end
+
+See: [`examples/scripts/bridge.py`](../examples/scripts/bridge.py), [`examples/scripts/README.md`](../examples/scripts/README.md)
+
 ## 11.3 Practical Workflows
 
 ### Research → Code Pipeline
@@ -14785,4 +14863,4 @@ Common misconceptions we've seen:
 
 **Contributions**: Issues and PRs welcome.
 
-**Last updated**: January 2026 | **Version**: 3.12.0
+**Last updated**: January 2026 | **Version**: 3.12.1
diff --git a/machine-readable/reference.yaml b/machine-readable/reference.yaml
index 796685e..3e4d9b9 100644
--- a/machine-readable/reference.yaml
+++ b/machine-readable/reference.yaml
@@ -3,7 +3,7 @@
 # Source: guide/ultimate-guide.md
 # Purpose: Condensed index for LLMs to quickly answer user questions about Claude Code
 
-version: "3.12.0"
+version: "3.12.1"
 updated: "2026-01-25"
 
 # ════════════════════════════════════════════════════════════════
@@ -27,6 +27,10 @@ deep_dive:
   # Session management
   session_search: "guide/observability.md:29"
   session_search_script: "examples/scripts/session-search.sh"
+  # Cost optimization - Local execution bridge
+  bridge_script: "examples/scripts/bridge.py"
+  bridge_schema: "examples/scripts/bridge-plan-schema.json"
+  bridge_guide: "guide/ultimate-guide.md:14079"
   # PDF Generation
   pdf_generation: "guide/workflows/pdf-generation.md"
   pdf_generator_skill: "examples/skills/pdf-generator.md"
@@ -689,7 +693,7 @@ ecosystem:
       - "Cross-links modified → Update all 4 repos"
     history:
       - date: "2026-01-20"
-        event: "Code Landing sync v3.12.0, 66 templates, cross-links"
+        event: "Code Landing sync v3.12.1, 66 templates, cross-links"
         commit: "5b5ce62"
       - date: "2026-01-20"
         event: "Cowork Landing fix (paths, README, UI badges)"