diff --git a/ClaudeRevit/Services/BenchmarkRunner.cs b/ClaudeRevit/Services/BenchmarkRunner.cs
index 1c25475..f811d3e 100644
--- a/ClaudeRevit/Services/BenchmarkRunner.cs
+++ b/ClaudeRevit/Services/BenchmarkRunner.cs
@@ -46,6 +46,8 @@ public static async Task RunAsync(
         bool resetBetweenTasks,
         int maxRoundsPerTask,
         int maxSecondsPerTask,
+        bool judgeViaClaudeCode,
+        bool runViaSubscription,
         Action<string> onStatus,
         Action<BenchmarkResult> onResult,
         CancellationToken ct)
@@ -55,15 +57,24 @@ public static async Task RunAsync(
         ToolDispatcher.ForceSuppress = true;
 
         // "claudecode" tests the MCP path end to end: the local `claude` CLI (on the subscription)
-        // drives the Revit tools through our MCP server. One impartial judge chat for the whole run.
-        var isClaudeCode = modelTag == "claudecode";
+        // drives the Revit tools through our MCP server. runViaSubscription does the same for any
+        // chosen model — the picked model is passed to the CLI via --model.
+        var isClaudeCode = modelTag == "claudecode" || runViaSubscription;
+        // The picked model → Claude Code --model alias (null = the CLI's default subscription model).
+        var ccModelAlias = modelTag == "claudecode" ? null : ClaudeCodeBackend.ModelAlias(modelTag);
+        // The judge can run on the subscription too (same claude.exe, no tools) so grading costs
+        // nothing on the API — needed since the account may sit at $0. It still grades from the
+        // objective probe only, so it stays impartial.
         string ccConfig = "", ccWorkDir = "", ccExe = "";
+        if (isClaudeCode || judgeViaClaudeCode)
+        {
+            ccExe = SettingsStore.ClaudeCodeExe;
+            ccWorkDir = McpServer.ClientWorkDir();
+        }
         if (isClaudeCode)
         {
             McpServer.Start();
             ccConfig = McpServer.WriteClientConfig();
-            ccWorkDir = McpServer.ClientWorkDir();
-            ccExe = SettingsStore.ClaudeCodeExe;
         }
         var judgeChat = new ChatService(ephemeral: true);
 
@@ -85,6 +96,7 @@ public static async Task RunAsync(
             // The model runs the task ONCE and recovers from any errors on its own — no judge hints.
             string finalText = "";
             string? error = null;
+            string? ccDiag = null;
             var budgetStopped = false;
             long inTok = 0, outTok = 0;
             var rounds = 0;
@@ -105,11 +117,19 @@ public static async Task RunAsync(
                             "mcp__clauderevit__*",
                             onText: t => sb.Append(t),
                             onTool: name => onStatus($"{task.Id} · {task.Title} · {name}"),
-                            taskCts.Token);
+                            taskCts.Token, model: ccModelAlias);
                         finalText = !string.IsNullOrEmpty(res.Text) ? res.Text : sb.ToString();
                         error = res.Error;
                         inTok = res.InputTokens; outTok = res.OutputTokens; rounds = res.NumTurns;
-                        modelUsed = "claude-code";
+                        modelUsed = ccModelAlias != null ? $"claude-code:{ccModelAlias}" : "claude-code";
+                        // Surface WHY a run did nothing: MCP connection status + result flag. A launch
+                        // with no tool calls and no tokens usually means MCP never connected.
+                        ccDiag = $"MCP: {res.McpStatus ?? "no init event"}" +
+                                 (res.IsError ? "; result=ERROR" : res.Subtype is { } st ? $"; result={st}" : "");
+                        if ((res.McpStatus == null ||
+                             res.McpStatus.IndexOf("connect", StringComparison.OrdinalIgnoreCase) < 0) &&
+                            outTok == 0)
+                            ccDiag += " — no Revit tools reached, nothing built";
                     }
                     catch (OperationCanceledException)
                     {
@@ -152,9 +172,12 @@ public static async Task RunAsync(
             onStatus($"{task.Id} · {task.Title} · grading…");
             var verdict = error != null
                 ? new Verdict(false, 0, "Run error: " + Truncate(error, 200), true)
-                : await JudgeAsync(judgeChat, judgeModel, task, before, after, finalText, ct);
+                : await JudgeAsync(judgeChat, judgeModel, task, before, after, finalText,
+                                   judgeViaClaudeCode, ccExe, ccWorkDir, ct);
             if (budgetStopped)
                 verdict = verdict with { Reason = "[stopped — task budget hit] " + verdict.Reason };
+            if (ccDiag != null)
+                verdict = verdict with { Reason = "[" + ccDiag + "] " + verdict.Reason };
 
             if (resetBetweenTasks)
                 await ResetAsync(baselineIds, ct);
@@ -208,7 +231,8 @@ private static async Task<string> StatsAsync(CancellationToken ct)
 
     private static async Task<Verdict> JudgeAsync(
         ChatService chat, string judgeModel, BenchmarkTask task,
-        string before, string after, string finalText, CancellationToken ct)
+        string before, string after, string finalText,
+        bool viaClaudeCode, string ccExe, string ccWorkDir, CancellationToken ct)
     {
         const string sys =
             "You are an impartial QA grader for a Revit modelling agent. Grade ONLY from the objective " +
@@ -226,7 +250,11 @@ private static async Task<Verdict> JudgeAsync(
             $"AGENT'S CLAIMED RESULT (unverified):\n{Truncate(finalText, 1000)}\n\nGrade now.";
         try
         {
-            var raw = await chat.RawCompleteAsync(judgeModel, sys, user, ct);
+            // On the subscription (no API cost) the CLI has no system-prompt flag in the same shape,
+            // so fold the grader instructions into the prompt; ParseVerdict tolerates surrounding prose.
+            var raw = viaClaudeCode
+                ? await ClaudeCodeBackend.CompleteAsync(ccExe, sys + "\n\n" + user, ccWorkDir, ct)
+                : await chat.RawCompleteAsync(judgeModel, sys, user, ct);
             return ParseVerdict(raw);
         }
         catch (Exception ex)
diff --git a/ClaudeRevit/Services/ChatService.cs b/ClaudeRevit/Services/ChatService.cs
index c0b30ef..0d7d7a2 100644
--- a/ClaudeRevit/Services/ChatService.cs
+++ b/ClaudeRevit/Services/ChatService.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.Json;
@@ -181,7 +182,14 @@ public ChatService() : this(false) { }
     public ChatService(bool ephemeral)
     {
         _ephemeral = ephemeral;
-        if (!ephemeral) _history.AddRange(HistoryStore.LoadApiHistory());
+        if (!ephemeral)
+        {
+            _history.AddRange(HistoryStore.LoadApiHistory());
+            // Restore the Claude Code (subscription) session so the conversation continues after a
+            // Revit restart, matching how the API history persists.
+            try { if (File.Exists(ClaudeCodeSessionFile)) _claudeCodeSessionId = File.ReadAllText(ClaudeCodeSessionFile).Trim(); }
+            catch { /* non-fatal */ }
+        }
 
         // A restored long history must be eligible for compaction on the very FIRST send
         // after a restart — otherwise an oversized persisted conversation is replayed
@@ -206,6 +214,37 @@ public ChatService(bool ephemeral)
     // Set by the chat pane: progress ping each tool-call round (current, max) for the status line.
     public Action<int, int>? OnRound;
 
+    // Claude Code (subscription) mode keeps the CLI's session id so follow-up messages continue the
+    // same conversation via --resume. Reset on ClearHistory.
+    private string? _claudeCodeSessionId;
+
+    // Set by the chat pane: when true, the selected model runs through the Claude Code CLI on the
+    // subscription (via --model) instead of the pay-per-token API. The advisor/auto-escalation does
+    // NOT apply here — Claude Code runs its own loop with the one chosen model.
+    public bool SubscriptionMode;
+
+    private static string ClaudeCodeSessionFile => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+        "ClaudeRevit", "claudecode-session.txt");
+
+    private void PersistClaudeCodeSession()
+    {
+        if (_ephemeral) return;
+        try
+        {
+            if (string.IsNullOrEmpty(_claudeCodeSessionId))
+            {
+                if (File.Exists(ClaudeCodeSessionFile)) File.Delete(ClaudeCodeSessionFile);
+            }
+            else
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(ClaudeCodeSessionFile)!);
+                File.WriteAllText(ClaudeCodeSessionFile, _claudeCodeSessionId);
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+
     public void RecreateClient() => _client = null;
 
     public void ClearHistory()
@@ -219,6 +258,8 @@ public void ClearHistory()
         _execCsharpOk = 0;
         _promoteNudged = false;
         _revealedCategories.Clear();
+        _claudeCodeSessionId = null;
+        PersistClaudeCodeSession();
         if (!_ephemeral) HistoryStore.Clear();
     }
 
@@ -260,6 +301,89 @@ public async Task<string> RawCompleteAsync(string modelTag, string systemPrompt,
         return string.Concat(msg.Content.Select(b => b.TryPickText(out var t) ? t.Text : ""));
     }
 
+    // Subscription mode: run the local Claude Code CLI headless, letting it drive the Revit tools
+    // through our in-process MCP server. Streams its narration into the pane and keeps the CLI's
+    // session id so follow-up messages continue the same conversation (--resume). Costs nothing on
+    // the API — the work runs on the user's Claude Pro/Max subscription.
+    private async Task SendViaClaudeCodeAsync(
+        ObservableCollection<ChatMessage> conversation, string prompt, Dispatcher ui,
+        string? modelAlias, CancellationToken ct)
+    {
+        if (!McpServer.IsRunning)
+        {
+            try { McpServer.Start(); }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException(
+                    "Couldn't start the MCP server that Claude Code needs — free the port in " +
+                    "Settings → MCP and try again. (" + ex.Message + ")");
+            }
+        }
+        var config = McpServer.WriteClientConfig();
+        var workDir = McpServer.ClientWorkDir();
+        var exe = SettingsStore.ClaudeCodeExe;
+
+        // Parity with the API path: give Claude Code the current document + selection so "this" /
+        // "the selected walls" resolve. The MCP session is long-lived, so we prepend this fresh each
+        // message (instructions, which carry memory/standards, are sent once at connect).
+        var contextedPrompt = prompt;
+        try
+        {
+            var contextJson = await ToolDispatcher.Instance.GetProjectContextAsync(ct);
+            var ctxHeader = "CURRENT DOCUMENT:\n" + contextJson;
+            var sel = SelectionService.Current;
+            if (sel.Ids.Count > 0)
+            {
+                var idList = sel.Ids.Count > 30
+                    ? string.Join(", ", sel.Ids.Take(30)) + $", … +{sel.Ids.Count - 30} more"
+                    : string.Join(", ", sel.Ids);
+                ctxHeader += $"\n\nCURRENT SELECTION: {sel.Description}. Element IDs: [{idList}]";
+            }
+            contextedPrompt = ctxHeader + "\n\n---\n\nUSER REQUEST:\n" + prompt;
+        }
+        catch { /* context is best-effort — fall back to the bare prompt */ }
+
+        ChatMessage? bubble = null;
+        void Append(string piece)
+        {
+            if (string.IsNullOrEmpty(piece)) return;
+            ui.InvokeAsync(() =>
+            {
+                if (bubble == null) { bubble = new ChatMessage { Role = "assistant", Text = "" }; conversation.Add(bubble); }
+                bubble.Text += piece;
+            });
+        }
+
+        var toolCount = 0;
+        var res = await ClaudeCodeBackend.RunAsync(
+            exe, contextedPrompt, workDir, config, resumeSessionId: _claudeCodeSessionId,
+            allowedToolsGlob: "mcp__clauderevit__*",
+            onText: Append,
+            onTool: _ => { toolCount++; OnRound?.Invoke(toolCount, toolCount); },
+            ct, model: modelAlias);
+
+        _claudeCodeSessionId = res.SessionId ?? _claudeCodeSessionId;
+        PersistClaudeCodeSession();
+
+        if (!string.IsNullOrEmpty(res.Error))
+        {
+            Append((bubble == null ? "" : "\n\n") + "⚠ " + res.Error);
+            return;
+        }
+        // Nothing streamed (e.g. a short answer delivered only in the final result event) — show it.
+        if (bubble == null && !string.IsNullOrEmpty(res.Text))
+            Append(res.Text);
+
+        if (SettingsStore.ShowTaskDiagnostics && bubble != null)
+        {
+            var tok = res.InputTokens + res.OutputTokens;
+            Append($"\n\n— claude-code (subscription — no API charge) · {res.NumTurns} turns · " +
+                   $"{res.DurationMs / 1000.0:0.0}s" +
+                   (tok > 0 ? $" · {tok:N0} tokens" : "") +
+                   (res.McpStatus != null ? $" · MCP {res.McpStatus}" : ""));
+        }
+    }
+
     public async Task SendAsync(
         ObservableCollection<ChatMessage> conversation,
         string model,
@@ -268,6 +392,20 @@ public async Task SendAsync(
         string? imageMime = null)
     {
         var ui = Dispatcher.CurrentDispatcher;
+
+        // Subscription path: the local Claude Code CLI drives the Revit tools through our MCP server.
+        // It runs its OWN agent loop, so bypass the whole Anthropic/alt pipeline (no API key, no tool
+        // schemas, no history compaction here) and just stream its output into the pane.
+        if (model == "claudecode" || SubscriptionMode)
+        {
+            var userText = conversation.LastOrDefault(m => m.Role == "user")?.Text ?? "";
+            if (string.IsNullOrWhiteSpace(userText)) return;
+            // "claudecode" = the CLI's default subscription model; any other pick maps to --model.
+            var alias = model == "claudecode" ? null : ClaudeCodeBackend.ModelAlias(model);
+            await SendViaClaudeCodeAsync(conversation, userText, ui, alias, ct);
+            return;
+        }
+
         bool alt = IsAlt(model);
         if (alt && !OpenAIBackend.IsConfigured)
             throw new InvalidOperationException(
diff --git a/ClaudeRevit/Services/ClaudeCodeBackend.cs b/ClaudeRevit/Services/ClaudeCodeBackend.cs
index 29486b4..d8b9892 100644
--- a/ClaudeRevit/Services/ClaudeCodeBackend.cs
+++ b/ClaudeRevit/Services/ClaudeCodeBackend.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.Json;
@@ -31,21 +32,54 @@ public sealed class Result
         public int NumTurns;
         public double CostUsd;
         public long DurationMs;
+        // Diagnostics: MCP server connection status from the init event ("clauderevit=connected"),
+        // and whether the final result was flagged an error. Explains a run that launched but did
+        // nothing (e.g. MCP failed to connect → no Revit tools → no work).
+        public string? McpStatus;
+        public bool IsError;
+        public string? Subtype;
     }
 
+    // Map our internal model tag to a Claude Code `--model` alias. Returns null for "auto"/"fable"/
+    // the default subscription model — where we let the CLI pick — since the advisor-escalation that
+    // "auto" means on the API doesn't exist inside Claude Code's own loop.
+    public static string? ModelAlias(string? tag) => tag switch
+    {
+        "opus-4-8" or "opus-4-7" or "opus-4-6" => "opus",
+        "sonnet-5" or "sonnet-4-6" => "sonnet",
+        "haiku-4-5" => "haiku",
+        _ => null
+    };
+
     public static async Task<Result> RunAsync(
         string exe, string prompt, string workDir, string mcpConfigPath, string? resumeSessionId,
-        string allowedToolsGlob, Action<string> onText, Action<string> onTool, CancellationToken ct)
+        string allowedToolsGlob, Action<string> onText, Action<string> onTool, CancellationToken ct,
+        string? model = null)
     {
         var args = new List<string>
         {
             "-p",
             "--output-format", "stream-json",
             "--verbose",
-            "--include-partial-messages",
-            "--mcp-config", mcpConfigPath,
-            "--allowedTools", allowedToolsGlob
+            "--include-partial-messages"
         };
+        if (!string.IsNullOrWhiteSpace(model))
+        {
+            args.Add("--model");
+            args.Add(model!);
+        }
+        // MCP + tools are for the "drive Revit" path. The judge runs with neither (empty) — a pure
+        // text-grading call — so skip the flags; an empty allowedTools glob denies every tool.
+        if (!string.IsNullOrWhiteSpace(mcpConfigPath))
+        {
+            args.Add("--mcp-config");
+            args.Add(mcpConfigPath);
+        }
+        if (!string.IsNullOrWhiteSpace(allowedToolsGlob))
+        {
+            args.Add("--allowedTools");
+            args.Add(allowedToolsGlob);
+        }
         if (!string.IsNullOrWhiteSpace(resumeSessionId))
         {
             args.Add("--resume");
@@ -53,30 +87,42 @@ public static async Task<Result> RunAsync(
         }
 
         var result = new Result();
-        Process proc;
-        try
+
+        // Revit is a GUI process — its PATH is often narrower than the user's shell, so a bare
+        // "claude" from an npm/native install frequently isn't found. Resolve to a full path across
+        // the common install locations FIRST; that also avoids cmd.exe's localized (and, on a Russian
+        // Windows, mojibaked) "'claude' is not recognized as a command" error leaking into results.
+        var resolved = Resolve(exe);
+        if (resolved == null)
         {
-            proc = Start(exe, args, workDir);
+            result.Error =
+                $"Claude Code CLI not found ('{exe}'). Install it (npm i -g @anthropic-ai/claude-code), " +
+                "run 'claude login' once, then set the full path to claude.cmd/claude.exe in Settings.";
+            return result;
         }
-        catch (Win32Exception)
+
+        var viaCmd = resolved.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase) ||
+                     resolved.EndsWith(".bat", StringComparison.OrdinalIgnoreCase);
+
+        Process proc;
+        try
         {
-            // npm-installed `claude` is a .cmd shim — not directly launchable; go through cmd.exe.
-            try
+            if (viaCmd)
             {
-                var viaCmd = new List<string> { "/c", exe };
-                viaCmd.AddRange(args);
-                proc = Start("cmd.exe", viaCmd, workDir);
+                // .cmd/.bat shims aren't PE images — must run through cmd.exe. The path is real, so
+                // cmd won't print a "not recognized" error.
+                var cmdArgs = new List<string> { "/c", resolved };
+                cmdArgs.AddRange(args);
+                proc = Start("cmd.exe", cmdArgs, workDir);
             }
-            catch (Exception ex)
+            else
             {
-                result.Error = $"Can't launch Claude Code ('{exe}'). Install it and run 'claude login', " +
-                               $"or set the full path in Settings. ({ex.Message})";
-                return result;
+                proc = Start(resolved, args, workDir);
             }
         }
         catch (Exception ex)
         {
-            result.Error = $"Can't launch Claude Code ('{exe}'): {ex.Message}";
+            result.Error = $"Can't launch Claude Code ('{resolved}'): {ex.Message}";
             return result;
         }
 
@@ -112,6 +158,20 @@ public static async Task<Result> RunAsync(
         return result;
     }
 
+    // A one-shot, no-tools text completion on the subscription — used for the impartial benchmark
+    // judge so grading costs nothing on the API. The bogus allowedTools glob matches no tool, so in
+    // headless (-p) mode every built-in tool is auto-denied and the model just returns text.
+    public static async Task<string> CompleteAsync(string exe, string prompt, string workDir, CancellationToken ct)
+    {
+        var res = await RunAsync(
+            exe, prompt, workDir, mcpConfigPath: "", resumeSessionId: null,
+            allowedToolsGlob: "__deny_all_tools__",
+            onText: _ => { }, onTool: _ => { }, ct);
+        if (string.IsNullOrEmpty(res.Text) && !string.IsNullOrEmpty(res.Error))
+            throw new InvalidOperationException(res.Error);
+        return res.Text;
+    }
+
     // Each stdout line is one JSON event. We pull: the session id (to resume the conversation next
     // turn), streamed assistant text deltas, tool-call names, and the final result text.
     private static void ParseLine(string line, Result result, Action<string> onText, Action<string> onTool)
@@ -128,10 +188,36 @@ private static void ParseLine(string line, Result result, Action<string> onText,
             var type = root.TryGetProperty("type", out var t) && t.ValueKind == JsonValueKind.String
                 ? t.GetString() : null;
 
+            // The init event lists the MCP servers Claude Code tried to attach and whether each
+            // connected — the single most useful signal when a run launches but does no work.
+            if (type == "system" && root.TryGetProperty("mcp_servers", out var servers) &&
+                servers.ValueKind == JsonValueKind.Array)
+            {
+                // Report ONLY our own server — the user's Claude Code may have many unrelated
+                // connectors (Gmail, Drive, Booking.com…) whose statuses would otherwise flood the
+                // diagnostic line.
+                var parts = new List<string>();
+                foreach (var s in servers.EnumerateArray())
+                {
+                    var name = s.TryGetProperty("name", out var n) && n.ValueKind == JsonValueKind.String
+                        ? n.GetString() ?? "" : "";
+                    if (name.IndexOf("clauderevit", StringComparison.OrdinalIgnoreCase) < 0) continue;
+                    var status = s.TryGetProperty("status", out var st) && st.ValueKind == JsonValueKind.String
+                        ? st.GetString() : "?";
+                    parts.Add($"{name}={status}");
+                }
+                if (parts.Count > 0) result.McpStatus = string.Join(", ", parts);
+                else if (result.McpStatus == null) result.McpStatus = "clauderevit=absent";
+            }
+
             if (type == "result")
             {
                 if (root.TryGetProperty("result", out var res) && res.ValueKind == JsonValueKind.String)
                     result.Text = res.GetString() ?? result.Text;
+                if (root.TryGetProperty("is_error", out var ie) && ie.ValueKind == JsonValueKind.True)
+                    result.IsError = true;
+                if (root.TryGetProperty("subtype", out var sub) && sub.ValueKind == JsonValueKind.String)
+                    result.Subtype = sub.GetString();
                 if (root.TryGetProperty("num_turns", out var nt) && nt.TryGetInt32(out var ntv)) result.NumTurns = ntv;
                 if (root.TryGetProperty("total_cost_usd", out var c) && c.TryGetDouble(out var cv)) result.CostUsd = cv;
                 if (root.TryGetProperty("duration_ms", out var dm) && dm.TryGetInt64(out var dmv)) result.DurationMs = dmv;
@@ -168,6 +254,79 @@ private static void ParseLine(string line, Result result, Action<string> onText,
         catch { /* non-JSON or partial line — ignore */ }
     }
 
+    // Find the `claude` executable. Honours an explicit path, then PATH (+ Windows extensions),
+    // then the well-known npm-global and native-install locations that Revit's PATH usually misses.
+    // Returns a full path, or null if nothing exists.
+    private static string? Resolve(string exe)
+    {
+        if (string.IsNullOrWhiteSpace(exe)) exe = "claude";
+
+        // Explicit path (has a directory separator) — trust it if it exists.
+        if (exe.IndexOf(Path.DirectorySeparatorChar) >= 0 || exe.IndexOf('/') >= 0)
+            return File.Exists(exe) ? exe : null;
+
+        var exts = new[] { "", ".cmd", ".exe", ".bat", ".ps1" };
+
+        // Search each PATH entry.
+        var pathVar = Environment.GetEnvironmentVariable("PATH") ?? "";
+        foreach (var dir in pathVar.Split(Path.PathSeparator))
+        {
+            if (string.IsNullOrWhiteSpace(dir)) continue;
+            foreach (var ext in exts)
+            {
+                try { var p = Path.Combine(dir, exe + ext); if (File.Exists(p)) return p; }
+                catch { /* bad PATH entry */ }
+            }
+        }
+
+        // Common install locations the GUI PATH tends to omit.
+        string? Env(string v) => Environment.GetEnvironmentVariable(v);
+        var candidates = new List<string?>
+        {
+            // npm global (default prefix)
+            Env("APPDATA") is { } ad ? Path.Combine(ad, "npm", exe + ".cmd") : null,
+            Env("APPDATA") is { } ad2 ? Path.Combine(ad2, "npm", exe + ".ps1") : null,
+            // native installer (irm https://claude.ai/install.ps1 | iex) → %USERPROFILE%\.local\bin\claude.exe
+            Env("USERPROFILE") is { } upn ? Path.Combine(upn, ".local", "bin", exe + ".exe") : null,
+            Env("USERPROFILE") is { } up3 ? Path.Combine(up3, ".local", "bin", exe) : null,
+            // other local installs
+            Env("LOCALAPPDATA") is { } la ? Path.Combine(la, "Programs", "claude", exe + ".exe") : null,
+            Env("USERPROFILE") is { } up ? Path.Combine(up, ".claude", "local", exe + ".exe") : null,
+            Env("USERPROFILE") is { } up2 ? Path.Combine(up2, ".claude", "local", exe) : null,
+            // unix-y (in case Revit ever runs elsewhere)
+            "/usr/local/bin/" + exe,
+            "/usr/bin/" + exe,
+        };
+        foreach (var c in candidates)
+        {
+            if (c != null) { try { if (File.Exists(c)) return c; } catch { } }
+        }
+
+        // Claude Desktop (the MSIX Store app) BUNDLES the Claude Code CLI under its package dir at
+        //   %LOCALAPPDATA%\Packages\Claude_*\LocalCache\Roaming\Claude\claude-code\<version>\claude.exe
+        // Users who only have the desktop app still have a working headless claude.exe here — it's just
+        // not on PATH. Glob for it and take the newest version folder.
+        try
+        {
+            var packages = Env("LOCALAPPDATA") is { } lad ? Path.Combine(lad, "Packages") : null;
+            if (packages != null && Directory.Exists(packages))
+            {
+                var best = Directory.EnumerateDirectories(packages, "Claude_*")
+                    .Select(pkg => Path.Combine(pkg, "LocalCache", "Roaming", "Claude", "claude-code"))
+                    .Where(Directory.Exists)
+                    .SelectMany(cc => Directory.EnumerateDirectories(cc))
+                    .Select(ver => Path.Combine(ver, "claude.exe"))
+                    .Where(File.Exists)
+                    .OrderByDescending(p => p, StringComparer.OrdinalIgnoreCase) // newest version last-sorts first
+                    .FirstOrDefault();
+                if (best != null) return best;
+            }
+        }
+        catch { /* enumeration raced or access denied */ }
+
+        return null;
+    }
+
     private static Process Start(string file, IEnumerable<string> args, string workDir)
     {
         var psi = new ProcessStartInfo
@@ -179,7 +338,8 @@ private static Process Start(string file, IEnumerable<string> args, string workD
             RedirectStandardError = true,
             UseShellExecute = false,
             CreateNoWindow = true,
-            StandardOutputEncoding = Encoding.UTF8
+            StandardOutputEncoding = Encoding.UTF8,
+            StandardErrorEncoding = Encoding.UTF8
         };
         foreach (var a in args) psi.ArgumentList.Add(a);
         return Process.Start(psi) ?? throw new InvalidOperationException("Process.Start returned null.");
diff --git a/ClaudeRevit/Services/McpServer.cs b/ClaudeRevit/Services/McpServer.cs
index 5cdd8df..3757ab2 100644
--- a/ClaudeRevit/Services/McpServer.cs
+++ b/ClaudeRevit/Services/McpServer.cs
@@ -209,6 +209,23 @@ private static async Task HandleRequest(HttpListenerContext ctx, CancellationTok
         }
     }
 
+    // The static driving rules PLUS the user's saved memory (project standards) and the proven-script
+    // digest — so a subscription/MCP session gets the same accumulated knowledge the API path injects
+    // into its system prompt. Instructions are sent once at initialize, so memory saved mid-session
+    // appears on the next reconnect.
+    private static string BuildInstructions()
+    {
+        var sb = new StringBuilder(Instructions);
+        var memory = MemoryStore.Load();
+        if (!string.IsNullOrWhiteSpace(memory))
+            sb.Append("\n\nSAVED MEMORY — user preferences and project standards; apply them:\n")
+              .Append(memory.Trim());
+        var experience = ExperienceStore.Digest();
+        if (!string.IsNullOrWhiteSpace(experience))
+            sb.Append("\n\n").Append(experience!.Trim());
+        return sb.ToString();
+    }
+
     private static async Task<(JsonNode? value, JsonObject? error)> Dispatch(string? method, JsonNode? prms, CancellationToken ct)
     {
         switch (method)
@@ -220,8 +237,10 @@ private static async Task HandleRequest(HttpListenerContext ctx, CancellationTok
                     ["protocolVersion"] = clientVer ?? "2025-06-18",
                     ["capabilities"] = new JsonObject { ["tools"] = new JsonObject() },
                     ["serverInfo"] = new JsonObject { ["name"] = "ClaudeRevit", ["version"] = "1.0" },
-                    // Surfaced to the model by the client — the hard-won rules for driving Revit well.
-                    ["instructions"] = Instructions
+                    // Surfaced to the model by the client — the hard-won rules for driving Revit well,
+                    // plus the user's saved standards and proven-script digest (parity with the API path,
+                    // whose system prompt carries the same). Built at session start.
+                    ["instructions"] = BuildInstructions()
                 }, null);
 
             case "ping":
diff --git a/ClaudeRevit/UI/BenchmarkWindow.xaml b/ClaudeRevit/UI/BenchmarkWindow.xaml
index e5e9624..791b4d5 100644
--- a/ClaudeRevit/UI/BenchmarkWindow.xaml
+++ b/ClaudeRevit/UI/BenchmarkWindow.xaml
@@ -43,6 +43,12 @@
             <TextBox x:Name="MaxMinutesBox" Text="5" Width="34" Height="24" VerticalContentAlignment="Center"
                      ToolTip="…or after this many minutes (0 = no limit)." />
             <TextBlock Text="min" VerticalAlignment="Center" Margin="4,0,0,0" />
+            <CheckBox x:Name="RunViaSubBox" Content="Run on subscription" IsChecked="False"
+                      VerticalAlignment="Center" Margin="16,0,0,0"
+                      ToolTip="Run the selected model through the Claude Code CLI (your subscription) via --model, instead of the pay-per-token API. Zero API cost. (Auto/Fable fall back to the CLI's default model; the advisor escalation does not apply.)" />
+            <CheckBox x:Name="JudgeViaCCBox" Content="Judge on subscription" IsChecked="True"
+                      VerticalAlignment="Center" Margin="16,0,0,0"
+                      ToolTip="Grade with the Claude Code CLI (your subscription) instead of the Opus 4.8 API, so the benchmark costs nothing on the API. The judge still grades only from the objective before/after probe. Needs the Claude Code CLI installed." />
         </StackPanel>
 
         <TextBlock DockPanel.Dock="Top" TextWrapping="Wrap" FontSize="11" Foreground="#B26A00" Margin="0,0,0,8"
diff --git a/ClaudeRevit/UI/BenchmarkWindow.xaml.cs b/ClaudeRevit/UI/BenchmarkWindow.xaml.cs
index 1922926..17e7dc2 100644
--- a/ClaudeRevit/UI/BenchmarkWindow.xaml.cs
+++ b/ClaudeRevit/UI/BenchmarkWindow.xaml.cs
@@ -85,6 +85,8 @@ await BenchmarkRunner.RunAsync(
                 model, tasks, judgeModel: "opus-4-8", runStamp: stamp,
                 resetBetweenTasks: ResetBox.IsChecked == true,
                 maxRoundsPerTask: maxRounds, maxSecondsPerTask: maxSeconds,
+                judgeViaClaudeCode: JudgeViaCCBox.IsChecked == true,
+                runViaSubscription: RunViaSubBox.IsChecked == true,
                 onStatus: SetStatus,
                 onResult: r =>
                 {
diff --git a/ClaudeRevit/UI/ChatPaneView.xaml b/ClaudeRevit/UI/ChatPaneView.xaml
index 9d01a75..cdb25b7 100644
--- a/ClaudeRevit/UI/ChatPaneView.xaml
+++ b/ClaudeRevit/UI/ChatPaneView.xaml
@@ -51,8 +51,13 @@
                     <ComboBoxItem Tag="haiku-4-5">Haiku 4.5 (fastest)</ComboBoxItem>
                     <ComboBoxItem Tag="sonnet-4-6">Sonnet 4.6</ComboBoxItem>
                     <ComboBoxItem Tag="opus-4-7">Opus 4.7</ComboBoxItem>
+                    <ComboBoxItem Tag="claudecode">Claude Code (subscription)</ComboBoxItem>
                     <ComboBoxItem Tag="alt" x:Name="AltModelItem">Alt model (set up in ⚙)</ComboBoxItem>
                 </ComboBox>
+                <CheckBox Grid.Column="1" x:Name="SubscriptionBox" Content="Subscription"
+                          VerticalAlignment="Center" Margin="10,0,0,0"
+                          Checked="SubscriptionBox_Changed" Unchecked="SubscriptionBox_Changed"
+                          ToolTip="Run the selected model through the Claude Code CLI on your Pro/Max subscription (via the MCP server) instead of the pay-per-token API — zero API cost. Needs the Claude Code CLI installed. Note: the Auto advisor/haiku→opus escalation does not apply here — Claude Code runs its own loop with the one chosen model (Auto = its default model)." />
                 <Button Grid.Column="2" x:Name="ClearButton"
                         Content="Clear" Height="24" Padding="10,0" Margin="0,0,4,0"
                         Click="ClearButton_Click"
diff --git a/ClaudeRevit/UI/ChatPaneView.xaml.cs b/ClaudeRevit/UI/ChatPaneView.xaml.cs
index aa424e9..4a34f5d 100644
--- a/ClaudeRevit/UI/ChatPaneView.xaml.cs
+++ b/ClaudeRevit/UI/ChatPaneView.xaml.cs
@@ -286,11 +286,20 @@ private void ModelPicker_SelectionChanged(object sender, SelectionChangedEventAr
         }
     }
 
+    // "Subscription" toggle: route the selected model through the Claude Code CLI (subscription)
+    // instead of the API. Applies in both chat and — via its own checkbox — the benchmark.
+    private void SubscriptionBox_Changed(object sender, RoutedEventArgs e)
+    {
+        _service.SubscriptionMode = SubscriptionBox.IsChecked == true;
+        UpdateAssistantLabel();
+    }
+
     // Keep the assistant name shown in the chat in sync with the selected model, so an
     // alt-provider reply (Grok, Gemini, a local model…) isn't labelled "Claude".
     private void UpdateAssistantLabel() =>
-        ChatMessage.AssistantLabel = _selectedModel == "alt"
-            ? (SettingsStore.AltModel.Length > 0 ? SettingsStore.AltModel : "Assistant")
+        ChatMessage.AssistantLabel =
+            (SubscriptionBox?.IsChecked == true || _selectedModel == "claudecode") ? "Claude Code"
+            : _selectedModel == "alt" ? (SettingsStore.AltModel.Length > 0 ? SettingsStore.AltModel : "Assistant")
             : "Claude";
 
     private async Task SendAsync()
@@ -315,6 +324,7 @@ private async Task SendAsync()
 
         Messages.Add(new ChatMessage { Role = "user", Text = image != null ? text + "  📎" : text });
 
+        _service.SubscriptionMode = SubscriptionBox.IsChecked == true;
         _cts = new CancellationTokenSource();
         try
         {
diff --git a/ClaudeRevit/UI/HelpWindow.xaml b/ClaudeRevit/UI/HelpWindow.xaml
index ba2fee7..fc3dd9a 100644
--- a/ClaudeRevit/UI/HelpWindow.xaml
+++ b/ClaudeRevit/UI/HelpWindow.xaml
@@ -62,6 +62,38 @@
                             • <Bold>Локальные модели</Bold> — упираются в вашу видеокарту и медленнее; для стабильной работы с большим числом инструментов подходят хуже всего.
                         </TextBlock>
 
+                        <TextBlock FontWeight="SemiBold" Text="Режим подписки (MCP / Claude Code)" Margin="0,12,0,4" />
+                        <TextBlock TextWrapping="Wrap">
+                            <Bold>Зачем:</Bold> гонять Revit не через потокенный API, а через вашу подписку Claude
+                            Pro/Max — тогда работа <Bold>ничего не стоит на API</Bold>. Плагин поднимает локальный
+                            MCP-сервер (только 127.0.0.1, с токеном), а Claude Code запускается в фоне и рулит
+                            инструментами Revit через него.&#10;&#10;
+                            <Bold>Как включить:</Bold>&#10;
+                            1. Установите Claude Code CLI: в PowerShell выполните <Bold>irm https://claude.ai/install.ps1 | iex</Bold>, затем запустите <Bold>claude</Bold> и войдите своей подпиской (нужен VPN, если claude.ai недоступен в вашем регионе). Это отдельная консольная программа — приложение Claude Desktop ею не является.&#10;
+                            2. В настройках включите «MCP-сервер» (можно задать порт; путь к claude плагин находит сам, иначе впишите его вручную).&#10;
+                            3. В списке моделей над чатом поставьте галочку <Bold>Subscription</Bold> — выбранная модель (Opus / Sonnet / Haiku) пойдёт через подписку. Либо выберите пункт «Claude Code (subscription)» — это модель CLI по умолчанию.&#10;&#10;
+                            <Bold>Важно:</Bold> «умная» связка Auto (Sonnet + advisor Opus, авто-переключение haiku→opus) работает
+                            только на API — это наш цикл. В режиме подписки Claude Code ведёт <Bold>свой</Bold> цикл одной
+                            выбранной моделью, advisor туда не переносится (Auto = модель CLI по умолчанию).&#10;
+                            Диалог продолжается между сообщениями; кнопка Clear сбрасывает сессию. VPN нужен и на прогон,
+                            а не только на установку. Наш MCP-сервер можно также подключить к приложению Claude Desktop —
+                            готовый конфиг лежит в настройках.
+                        </TextBlock>
+
+                        <TextBlock FontWeight="SemiBold" Text="Бенчмарк моделей (кнопка 📊)" Margin="0,12,0,4" />
+                        <TextBlock TextWrapping="Wrap">
+                            Прогоняет набор одинаковых задач на выбранной модели и сравнивает их. Оценивает
+                            <Bold>независимый судья</Bold> строго по объективному «зонду» (probe) — счётчикам до/после
+                            (стены с длинами, полы с площадями, уровни, колонны, арматура, узлы, DirectShape…), а не по
+                            словам модели. Модель исправляется сама, судья только оценивает (без подсказок).&#10;
+                            • Наборы задач: Basics (простые), Composite (составные), арматура/сталь, «hard».&#10;
+                            • Лимиты по раундам и времени, сброс модели между задачами (честный старт).&#10;
+                            • «Run on subscription» — гонять тестируемую модель через подписку; «Judge on subscription» — и судью тоже (тогда бенчмарк <Bold>ничего не стоит на API</Bold>).&#10;
+                            • Результаты пишутся в benchmark_results.jsonl (в %AppData%\ClaudeRevit).&#10;
+                            Отдельно: галочка «Показывать диагностику по задаче» в настройках выводит после каждого
+                            ответа строку — модель, раунды, токены, время — чтобы сравнивать эффективность.
+                        </TextBlock>
+
                         <TextBlock FontWeight="SemiBold" Text="Эффективные приёмы" Margin="0,12,0,4" />
                         <TextBlock TextWrapping="Wrap">
                             • Начинайте сессию с фразы «изучи проект» — ассистент вызовет get_project_catalog и за один запрос узнает все уровни, семейства, типы, шаблоны видов и арматурный каталог.&#10;
@@ -147,6 +179,38 @@
                             • <Bold>Local models</Bold> — limited by your GPU and slower; the weakest fit for reliable work across many tools.
                         </TextBlock>
 
+                        <TextBlock FontWeight="SemiBold" Text="Subscription mode (MCP / Claude Code)" Margin="0,12,0,4" />
+                        <TextBlock TextWrapping="Wrap">
+                            <Bold>Why:</Bold> drive Revit through your Claude Pro/Max subscription instead of the
+                            pay-per-token API — so the work <Bold>costs nothing on the API</Bold>. The plugin runs a
+                            local MCP server (127.0.0.1 only, token-protected) and the Claude Code CLI runs in the
+                            background, driving the Revit tools through it.&#10;&#10;
+                            <Bold>How to enable:</Bold>&#10;
+                            1. Install the Claude Code CLI: in PowerShell run <Bold>irm https://claude.ai/install.ps1 | iex</Bold>, then run <Bold>claude</Bold> and log in with your subscription (you need a VPN if claude.ai is blocked in your region). This is a separate terminal program — the Claude Desktop app is not it.&#10;
+                            2. In Settings enable “MCP server” (you can set the port; the plugin finds claude automatically, otherwise enter its full path).&#10;
+                            3. In the model dropdown above the chat tick <Bold>Subscription</Bold> — the selected model (Opus / Sonnet / Haiku) then runs on the subscription. Or pick “Claude Code (subscription)” to use the CLI's default model.&#10;&#10;
+                            <Bold>Note:</Bold> the smart Auto path (Sonnet + Opus advisor, haiku→opus escalation) is an API-loop
+                            feature only. In subscription mode Claude Code runs its <Bold>own</Bold> loop with the one chosen
+                            model — the advisor does not carry over (Auto = the CLI's default model).&#10;
+                            The conversation continues between messages; Clear resets the session. The VPN is needed for
+                            runs too, not just install. You can also connect our MCP server to the Claude Desktop app —
+                            a ready-to-paste config is in Settings.
+                        </TextBlock>
+
+                        <TextBlock FontWeight="SemiBold" Text="Model benchmark (the 📊 button)" Margin="0,12,0,4" />
+                        <TextBlock TextWrapping="Wrap">
+                            Runs a set of identical tasks on the chosen model and compares them. An
+                            <Bold>independent judge</Bold> grades strictly from the objective probe — before/after counts
+                            (walls with lengths, floors with areas, levels, columns, rebar, connections, DirectShapes…),
+                            not the model's own words. The model self-corrects; the judge only grades (no hints).&#10;
+                            • Task sets: Basics, Composite, rebar/steel, “hard”.&#10;
+                            • Round and time budgets, model reset between tasks (a fair start).&#10;
+                            • “Run on subscription” runs the tested model on the subscription; “Judge on subscription” does the same for the judge (so the benchmark <Bold>costs nothing on the API</Bold>).&#10;
+                            • Results are appended to benchmark_results.jsonl (in %AppData%\ClaudeRevit).&#10;
+                            Separately: the “Show per-task diagnostics” setting prints a line after each answer — model,
+                            rounds, tokens, time — to compare efficiency.
+                        </TextBlock>
+
                         <TextBlock FontWeight="SemiBold" Text="Effective habits" Margin="0,12,0,4" />
                         <TextBlock TextWrapping="Wrap">
                             • Start a session with “survey the project” — the assistant calls get_project_catalog and learns all levels, families, types, view templates and the rebar catalog in one request.&#10;
diff --git a/ClaudeRevit/UI/SettingsWindow.xaml b/ClaudeRevit/UI/SettingsWindow.xaml
index e0e175f..cd459ac 100644
--- a/ClaudeRevit/UI/SettingsWindow.xaml
+++ b/ClaudeRevit/UI/SettingsWindow.xaml
@@ -186,6 +186,13 @@
                          FontFamily="Consolas" FontSize="11" Height="120"
                          VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" />
 
+                <TextBlock x:Name="ClaudeCodeExeLabel" Margin="0,10,0,0" FontWeight="SemiBold"
+                           Text="Claude Code executable (for the in-pane / benchmark subscription path)" />
+                <TextBox x:Name="ClaudeCodeExeBox" Margin="0,4,0,0" Height="26" Padding="4"
+                         VerticalContentAlignment="Center" FontFamily="Consolas" FontSize="11" />
+                <TextBlock x:Name="ClaudeCodeExeNote" Margin="0,4,0,0" FontSize="11" Foreground="#888" TextWrapping="Wrap"
+                           Text="Leave as &quot;claude&quot; if it is on PATH. Revit’s process often can’t see it — if the benchmark says “Claude Code CLI not found”, put the full path here (run &quot;where claude&quot; in a terminal; usually %APPDATA%\npm\claude.cmd)." />
+
             </StackPanel>
         </ScrollViewer>
     </DockPanel>
diff --git a/ClaudeRevit/UI/SettingsWindow.xaml.cs b/ClaudeRevit/UI/SettingsWindow.xaml.cs
index d900d3f..ba93f55 100644
--- a/ClaudeRevit/UI/SettingsWindow.xaml.cs
+++ b/ClaudeRevit/UI/SettingsWindow.xaml.cs
@@ -56,6 +56,7 @@ public SettingsWindow()
         TaskDiagBox.IsChecked = SettingsStore.ShowTaskDiagnostics;
         McpBox.IsChecked = SettingsStore.McpEnabled;
         McpPortBox.Text = SettingsStore.McpPort.ToString();
+        ClaudeCodeExeBox.Text = SettingsStore.ClaudeCodeExe;
         UpdateMcpConfig();
         AltCompactToolsBox.IsChecked = SettingsStore.AltCompactTools;
 
@@ -206,6 +207,12 @@ private void ApplyLanguage()
             "Exposes the Revit tools over a local MCP server so Claude Code / Claude Desktop — authenticated with your Claude Pro/Max subscription — can drive Revit, putting cost on the subscription instead of the pay-per-token API. The in-Revit chat pane still uses your API key. Security: the server listens only on 127.0.0.1 and requires the token below; anyone who has it can edit your model (and run C# if code execution is on). Paste the config below into Claude Code’s MCP settings.",
             "Выставляет инструменты Revit через локальный MCP-сервер, чтобы Claude Code / Claude Desktop (авторизованные вашей подпиской Pro/Max) могли рулить Revit — стоимость идёт на подписку, а не на потокенный API. Панель чата в Revit по-прежнему на API-ключе. Безопасность: сервер слушает только 127.0.0.1 и требует токен ниже; у кого он есть — тот может править вашу модель (и запускать C#, если включено выполнение кода). Вставьте конфиг ниже в настройки MCP в Claude Code.");
         McpPortLabel.Text = L("Port:", "Порт:");
+        ClaudeCodeExeLabel.Text = L(
+            "Claude Code executable (for the in-pane / benchmark subscription path)",
+            "Путь к Claude Code (для панели / бенчмарка по подписке)");
+        ClaudeCodeExeNote.Text = L(
+            "Leave as \"claude\" if it is on PATH. Revit’s process often can’t see it — if the benchmark says “Claude Code CLI not found”, put the full path here (run \"where claude\" in a terminal; usually %APPDATA%\\npm\\claude.cmd).",
+            "Оставьте \"claude\", если он в PATH. Процесс Revit часто его не видит — если бенчмарк пишет «Claude Code CLI not found», впишите полный путь (в терминале выполните \"where claude\"; обычно %APPDATA%\\npm\\claude.cmd).");
 
         ToolGroupsHeader.Text = L("Active tool groups (fewer = fewer tokens per request)", "Активные группы инструментов (меньше = меньше токенов на запрос)");
         ToolGroupsNote.Text = L(
@@ -365,6 +372,7 @@ private void SaveButton_Click(object sender, RoutedEventArgs e)
         if (int.TryParse(McpPortBox.Text, out var mcpPort) && mcpPort is > 0 and < 65536)
             SettingsStore.McpPort = mcpPort;
         SettingsStore.McpEnabled = McpBox.IsChecked == true;
+        SettingsStore.ClaudeCodeExe = ClaudeCodeExeBox.Text?.Trim() ?? "";
         try { McpServer.ApplyFromSettings(); } catch (Exception ex) { Log.Error("MCP apply failed", ex); }
         SettingsStore.AltCompactTools = AltCompactToolsBox.IsChecked == true;
         SettingsStore.UiLanguage = _lang;
diff --git a/README.md b/README.md
index 90dea76..0db0041 100644
--- a/README.md
+++ b/README.md
@@ -2,15 +2,21 @@
 
 **English** | [Русский](README.ru.md)
 
-Claude AI in Autodesk Revit — a dockable chat pane with **153 tools** that let Claude inspect and modify your model directly. Ask it to create walls, generate schedules, place families, dimension grids, reinforce structural elements, author parametric families, draft sketches, and more. Runs on **Revit 2025, 2026 and 2027**.
+Claude AI in Autodesk Revit — a dockable chat pane with **180+ tools** that let Claude inspect and modify your model directly. Ask it to create walls, generate schedules, place families, dimension grids, reinforce structural elements, author parametric families, draft sketches, and more. Runs on **Revit 2025, 2026 and 2027**.
+
+Run it on the pay-per-token **Anthropic API**, on your **Claude Pro/Max subscription** (via a built-in MCP server + the Claude Code CLI — zero API cost), or on any **OpenAI-compatible** provider (DeepSeek, Gemini, OpenRouter, Groq, local Ollama…).
 
 ---
 
 ## Features
 
 - **Dockable chat pane** in Revit, with streaming responses
-- **153 tools** spanning modeling, views, sheets, annotation, schedules, filters, families, the Family Editor, and reinforcement
+- **180+ tools** spanning modeling, views, sheets, annotation, schedules, filters, families, the Family Editor, and reinforcement
 - **Multiple AI providers** — Claude (Sonnet 5 / Opus 4.8 / Fable 5 / Haiku 4.5, + legacy Sonnet 4.6 / Opus 4.7) **or** any OpenAI-compatible endpoint: DeepSeek, Google Gemini, ChatGPT/OpenAI, Qwen, OpenRouter, Groq, and local **Ollama** / **LM Studio**. Pick "Alt" in the model dropdown; free and local models need no Anthropic key.
+- **Auto (cost-optimized) mode** — the default: a cheap model (Sonnet 5) runs every turn and consults a stronger advisor (Opus 4.8, or Fable 5) mid-turn *only when it needs a plan*, via Anthropic's advisor tool. The cheap model's prompt cache stays warm all session; the advisor is billed only for the short consult. A legacy whole-turn model-switch is available in Settings.
+- **Subscription mode (MCP / Claude Code)** — drive Revit on your **Claude Pro/Max subscription** instead of the pay-per-token API. The plugin runs a local **MCP server** (127.0.0.1, token-protected) exposing the Revit tools; the **Claude Code CLI** runs headless in the background and drives them. Tick **Subscription** in the model dropdown (or connect the MCP server to the Claude Desktop app with the ready-made config in Settings). Zero API cost.
+- **Model benchmark (📊)** — run a graded task set (basics, composite, rebar, steel) on any model and compare pass rate, rounds, tokens and time. An independent judge grades strictly from an objective before/after probe (never the model's own claims); both the tested model and the judge can run on the subscription for a zero-API-cost benchmark.
+- **Lazy-loaded toolset** — only a core set of tools rides in each request; specialised groups (rebar, MEP, schedules, sheets, annotation, sections, family editing, export) are revealed on demand via `find_tools`, cutting the per-request tool-schema cost by ~⅔ (a big saving on non-caching alt models). `run_batch` repeats one tool over many items in a single transaction.
 - **Single-undo per prompt** — Ctrl+Z reverts everything Claude did in one turn
 - **Selection awareness** — green pill shows what's selected; Claude knows what "this" means
 - **Markdown rendering** + **selectable text** in messages
@@ -57,6 +63,34 @@ To update later, re-run the installer or the one-liner — both pick up the late
 
 ---
 
+## Running on your Claude subscription (MCP)
+
+Instead of paying per token on the Anthropic API, you can drive Revit with your **Claude
+Pro/Max subscription**. The plugin runs a local **MCP server** that exposes the Revit tools,
+and the **Claude Code CLI** connects to it and does the work — the cost lands on your
+subscription, not the API.
+
+1. **Install the Claude Code CLI** (a terminal program, separate from the Claude Desktop app).
+   In PowerShell:
+   ```powershell
+   irm https://claude.ai/install.ps1 | iex
+   ```
+   Then run `claude` once and log in with your subscription. (A VPN is required if `claude.ai`
+   is blocked in your region — for install *and* for every run.)
+2. **Enable the MCP server** in Settings → MCP (set a port if you like; the plugin locates
+   `claude` automatically, or enter its full path).
+3. **In the chat**, tick **Subscription** in the model dropdown — the selected model
+   (Opus / Sonnet / Haiku) then runs on the subscription via the CLI. Or pick
+   **Claude Code (subscription)** to use the CLI's default model.
+
+You can also point the **Claude Desktop app** (or any MCP client) at the server — a
+ready-to-paste config is shown in Settings → MCP.
+
+> Note: the Auto advisor / haiku→opus escalation is an API-loop feature and does **not** apply
+> in subscription mode — Claude Code runs its own agent loop with the one chosen model.
+
+---
+
 ## Build from source (for developers)
 
 You need:
@@ -124,7 +158,7 @@ Users get the new version with the same installer / `install.ps1` one-liner.
 
 ## Tools
 
-The plugin exposes **153 tools** to Claude across these categories:
+The plugin exposes **180+ tools** to Claude across these categories:
 
 - **Inspection** — get/list elements, parameters, levels, materials, phases, families, project info, warnings, batch element locations/bounding boxes (mm)
 - **Geometry creation** — walls, floors, roofs, rooms, levels, grids, doors, windows, columns, beams, foundations, MEP (ducts/pipes), topography, curtain walls
diff --git a/README.ru.md b/README.ru.md
index 4458392..1c98293 100644
--- a/README.ru.md
+++ b/README.ru.md
@@ -2,15 +2,21 @@
 
 [English](README.md) | **Русский**
 
-Claude AI внутри Autodesk Revit — закрепляемая панель чата со **153 инструментами**, через которые Claude напрямую читает и изменяет вашу модель. Попросите его построить стены, создать спецификации, расставить семейства, образмерить оси, заармировать конструкции, собрать параметрическое семейство, оформить листы — и он сделает это сам. Работает на **Revit 2025, 2026 и 2027**.
+Claude AI внутри Autodesk Revit — закрепляемая панель чата со **180+ инструментами**, через которые Claude напрямую читает и изменяет вашу модель. Попросите его построить стены, создать спецификации, расставить семейства, образмерить оси, заармировать конструкции, собрать параметрическое семейство, оформить листы — и он сделает это сам. Работает на **Revit 2025, 2026 и 2027**.
+
+Запускать можно на потокенном **Anthropic API**, на вашей **подписке Claude Pro/Max** (через встроенный MCP-сервер + Claude Code CLI — ноль расходов на API) или на любом **OpenAI-совместимом** провайдере (DeepSeek, Gemini, OpenRouter, Groq, локальные Ollama…).
 
 ---
 
 ## Возможности
 
 - **Закрепляемая панель чата** в Revit с потоковым выводом ответов
-- **153 инструмента**: моделирование, виды, листы, аннотации, спецификации, фильтры, семейства, редактор семейств, армирование
+- **180+ инструментов**: моделирование, виды, листы, аннотации, спецификации, фильтры, семейства, редактор семейств, армирование
 - **Несколько провайдеров ИИ** — Claude (Sonnet 5 / Opus 4.8 / Fable 5 / Haiku 4.5, + Sonnet 4.6 / Opus 4.7) **или** любой OpenAI-совместимый эндпоинт: DeepSeek, Google Gemini, ChatGPT/OpenAI, Qwen, OpenRouter, Groq, локальные **Ollama** / **LM Studio**. Выберите «Alt» в списке моделей; бесплатным и локальным моделям ключ Anthropic не нужен.
+- **Режим Auto (экономный)** — по умолчанию: дешёвая модель (Sonnet 5) ведёт весь ход и советуется с сильным advisor'ом (Opus 4.8 или Fable 5) только когда нужен план — через advisor-tool Anthropic. Кэш дешёвой модели остаётся горячим всю сессию, advisor оплачивается лишь за короткий совет. Старый режим (переключение всего хода на Opus) доступен в настройках.
+- **Режим подписки (MCP / Claude Code)** — рулить Revit на вашей **подписке Claude Pro/Max**, а не на потокенном API. Плагин поднимает локальный **MCP-сервер** (127.0.0.1, с токеном) с инструментами Revit, а **Claude Code CLI** в фоне ими управляет. Поставьте галочку **Subscription** в списке моделей (или подключите MCP-сервер к приложению Claude Desktop готовым конфигом из настроек). Ноль расходов на API.
+- **Бенчмарк моделей (📊)** — прогнать набор задач (базовые, составные, арматура, сталь) на любой модели и сравнить долю успеха, раунды, токены и время. Независимый судья оценивает строго по объективному «зонду» до/после (никогда по словам модели); и тестируемую модель, и судью можно гонять через подписку — тогда бенчмарк ничего не стоит на API.
+- **Ленивая загрузка инструментов** — в каждый запрос едет лишь базовый набор; специализированные группы (арматура, инженерка, спецификации, листы, аннотации, разрезы, редактор семейств, экспорт) раскрываются по требованию через `find_tools`, что срезает «налог на каталог инструментов» примерно на ⅔ (особенно заметно на альт-моделях без кэша). `run_batch` повторяет один инструмент по многим элементам в одной транзакции.
 - **Одна отмена на запрос** — Ctrl+Z откатывает всё, что Claude сделал за один ход
 - **Понимает выделение** — зелёная плашка показывает, что выделено; Claude знает, что значит «это»
 - **Markdown** и **выделяемый текст** в сообщениях
@@ -55,6 +61,33 @@ iwr https://raw.githubusercontent.com/debug23win/ClaudeRevit/main/install.ps1 |
 
 ---
 
+## Работа через подписку Claude (MCP)
+
+Вместо оплаты по токенам через Anthropic API можно рулить Revit на вашей **подписке Claude
+Pro/Max**. Плагин поднимает локальный **MCP-сервер** с инструментами Revit, а **Claude Code CLI**
+к нему подключается и выполняет работу — расходы идут на подписку, а не на API.
+
+1. **Установите Claude Code CLI** (консольная программа, это не приложение Claude Desktop).
+   В PowerShell:
+   ```powershell
+   irm https://claude.ai/install.ps1 | iex
+   ```
+   Затем запустите `claude` и войдите своей подпиской. (Нужен VPN, если `claude.ai` недоступен
+   в вашем регионе — и на установку, и на каждый прогон.)
+2. **Включите MCP-сервер** в Settings → MCP (можно задать порт; путь к `claude` плагин находит
+   сам, иначе впишите его вручную).
+3. **В чате** поставьте галочку **Subscription** в списке моделей — выбранная модель
+   (Opus / Sonnet / Haiku) пойдёт через подписку. Либо выберите **Claude Code (subscription)**
+   — модель CLI по умолчанию.
+
+MCP-сервер можно также подключить к приложению **Claude Desktop** (или любому MCP-клиенту) —
+готовый конфиг показан в Settings → MCP.
+
+> Важно: связка Auto (advisor, авто-переключение haiku→opus) работает только на API и **не**
+> действует в режиме подписки — Claude Code ведёт свой цикл одной выбранной моделью.
+
+---
+
 ## Сборка из исходников (для разработчиков)
 
 Понадобятся:
@@ -122,7 +155,7 @@ Workflow `.github/workflows/release.yml` собирает все три верс
 
 ## Инструменты
 
-Плагин даёт Claude **153 инструмента** по категориям:
+Плагин даёт Claude **180+ инструментов** по категориям:
 
 - **Чтение модели** — элементы, параметры, уровни, материалы, стадии, семейства, информация о проекте, предупреждения, пакетное чтение позиций и габаритов (мм)
 - **Создание геометрии** — стены, перекрытия, крыши, помещения, уровни, оси, двери, окна, колонны, балки, фундаменты, MEP (воздуховоды/трубы), топография, витражи
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index 06bd8f6..a6e6fb1 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -41,12 +41,34 @@ the user doesn't have to think about it. Premature now (we have dozens); impleme
   (Sonnet 5 / Haiku 4.5) and advisor (Opus 4.8 / Fable 5) are selectable in Settings. Per-task
   diagnostics (time/tokens/rounds) added alongside. Benchmark mode (v1.71) compares models on
   graded tasks with an impartial Opus judge.
-- ~~**Subscription-backed use.**~~ SHIPPED (v1.83) as the experimental MCP server. Direct
-  subscription OAuth in a third-party API call is banned by Anthropic and blocked server-side, so
-  the in-Revit pane stays on a pay-per-token API key; the MCP server lets Claude Code / Desktop
-  (subscription-authed) drive Revit instead, putting cost on the flat subscription. Tradeoff: the
-  client runs the loop, so our token machinery + pane don't apply in that mode. Needs field
-  validation (HttpListener URL-ACL on Windows; client handshake).
+- ~~**Subscription-backed use.**~~ SHIPPED and field-validated (v1.83 → v1.96). The MCP server lets
+  Claude Code / Desktop (subscription-authed) drive Revit, putting cost on the flat subscription
+  (direct subscription OAuth in a third-party API call is banned by Anthropic). Now driveable from
+  the in-Revit pane too (pick **Subscription** in the model dropdown → the local `claude` CLI runs
+  headless and streams into the pane), with model selection via `--model`, and the benchmark can run
+  both the tested model and the judge on the subscription. **Parity work done (v1.96):** MCP
+  `initialize` instructions carry the saved memory + proven-scripts digest; the pane prepends the
+  current document + selection; the CLI session id persists across Revit restarts; subscription usage
+  is shown in per-task diagnostics. Remaining gap vs the API path (inherent): the client runs its own
+  loop, so the Auto advisor / haiku→opus escalation and our token machinery don't apply there.
+  Field-validated on a real machine: benchmark passes B0–B6, L3, L4, plus the domain tasks R1 (rebar,
+  ✓90) and S1 (steel + connection, ✓95) on subscription Opus.
+
+## From the revit-mcp comparison (borrow)
+
+Compared our code to the `revit-mcp` project (Node/TS MCP server + separate C# plugin, socket bridge,
+26 tools; archived Feb 2026). We win on depth (180+ native tools, rebar/steel/family-editor),
+single-component design (in-process HTTP MCP server, no Node bridge), the learning layer, caching,
+and the benchmark. Two things they do better and worth borrowing:
+
+- **Dynamic tool loading (PRIMARY borrow).** revit-mcp loads command DLLs at runtime without
+  recompiling the core; we require a `.cs` + `App.cs` registration + rebuild. This is the same
+  mechanism the "lazy custom-tool library" section above needs — a plugin/DLL drop-in path so
+  third-party (and self-learned) tools join the catalogue without a core rebuild. Do this together
+  with the lazy-compile + find_tools work.
+- **stdio MCP adapter.** Our server is Streamable HTTP (Claude Code connects natively; Claude Desktop
+  needs the `mcp-remote` bridge). A tiny stdio shim (or a stdio transport option on the server) would
+  let Claude Desktop attach in one step, matching revit-mcp's out-of-the-box Desktop experience.
 
 - **Auto-update after Revit closes.** A background updater launched on shutdown: check GitHub
   releases, silently install a newer version, and pull the latest knowledge base (tools + patterns).