@@ -1,16 +1,17 @@
 # Changelog
 
-## 0.8.0 — unreleased
+## 0.8.0 — 2026-10-18
 
-Fewer tokens in every session: about 1.3k instead of 5.5–7k.
+Fewer tokens in every Claude Code session: about 1.6k instead of 5.5–7k.
 
 - Tool groups loaded on demand: a session starts with the core (`ado_status`, `ado_settings`, `ado_upgrade`,
   `ado_work_item`, `ado_query`, `ado_search`, `ado_trace` and the new `ado_tools`), and Claude loads a group with
   `ado_tools enable=write` (or `"write;boards"`) when the conversation needs it; the client is told about the new tools
   (MCP `tools/list_changed`). Groups: `write`, `boards`, `wiki`, `code`, `tests`, `recipes`, `pr`, `pipelines`. The mode
   says which groups may be loaded. Skills and prompts load the groups they use.
-- `adolens config --load-all-tools true` (or *Tools at start* in the settings menu): every group of the mode at start,
-  for a client that does not take new tools during a conversation.
+- `adolens config --tool-loading auto|demand|all` (or *Tools at start* in the settings menu). `auto`, the default: on
+  demand in Claude Code; every group of the mode at start in other clients (Claude Desktop), which may not take new
+  tools during a conversation. `demand`: on demand everywhere. `all`: everything at start.
 - Tool sets renamed to groups: `work` → `write`, `trace` → `code`, `test` → `tests` (old names in the settings still work).
 - Shorter descriptions of `ado_update`, `ado_create` and `ado_pr_update`.
 - Pull request tags (labels): `ado_pr_update action=tag tags="R349; -old"`, tags when creating a PR, and tags shown in
 
@@ -134,7 +134,7 @@ adolens config --connection contoso --project Demo --team "Demo Team"
 adolens config --default-connection fabrikam
 adolens config --mode dev                    # po | dev | full
 adolens config --add-toolset pipelines       # one more tool group on top of the mode
-adolens config --load-all-tools true         # every group of the mode at start (more tokens)
+adolens config --tool-loading auto           # auto | demand | all: when tool groups are loaded
 adolens config --confirm-above 3             # updates of more items are previewed first (0: always)
 adolens config --usage-log false
 adolens config --show-tokens true            # end every answer with [~N tokens]
@@ -171,7 +171,7 @@ Settings live in `%LOCALAPPDATA%\ado-lens\adolens.json` (no secrets) — they ca
 
 ### Modes and tool groups
 
-Every tool definition costs tokens in every session, so a session starts with a small core (about 1.3k tokens) and
+Every tool definition costs tokens in every session, so a session starts with a small core (about 1.5k tokens) and
 Claude loads a group with `ado_tools enable=<group>` when the conversation needs it — a question about the sprint
 loads `boards`, a new story loads `write`. The skills and prompts load what they use. A mode only chooses which groups
 may be loaded; it is never a permission (the PAT decides).
@@ -188,9 +188,13 @@ may be loaded; it is never a permission (the PAT decides).
 | `pr` | `ado_pr`, `ado_pr_update` | – | ✓ | ✓ |
 | `pipelines` | `ado_pipeline`, `ado_pipeline_run` | – | ✓ | ✓ |
 
-`adolens config --add-toolset <group>` allows one more group on top of the mode. A client that does not take new tools
-during a conversation can start with every group of the mode: `adolens config --load-all-tools true` (or *Tools at
-start* in the settings menu) — about 6k tokens per session instead of 1.3k.
+`adolens config --add-toolset <group>` allows one more group on top of the mode. When groups are loaded is
+`adolens config --tool-loading` (or *Tools at start* in the settings menu):
+
+- `auto` (default): on demand in Claude Code, which takes new tools during a conversation; every group of the mode
+  at start in other clients, Claude Desktop among them (about 6–7k tokens), so nothing is missing there;
+- `demand`: on demand in every client (about 1.3k tokens at start) — for a client known to take new tools;
+- `all`: every group of the mode at start everywhere.
 
 ## Tool map
 
 
@@ -137,7 +137,7 @@ adolens config --connection contoso --project Demo --team "Demo Team"
 adolens config --default-connection fabrikam
 adolens config --mode dev                    # po | dev | full
 adolens config --add-toolset pipelines       # dodatkowa grupa narzędzi ponad tryb
-adolens config --load-all-tools true         # wszystkie grupy trybu od startu (więcej tokenów)
+adolens config --tool-loading auto           # auto | demand | all: kiedy ładować grupy narzędzi
 adolens config --confirm-above 3             # zmiany większej liczby elementów najpierw jako podgląd (0: zawsze)
 adolens config --usage-log false
 adolens config --show-tokens true            # każda odpowiedź kończy się [~N tokens]
@@ -172,7 +172,7 @@ Ustawienia siedzą w `%LOCALAPPDATA%\ado-lens\adolens.json` (bez sekretów) —
 
 ### Tryby i grupy narzędzi
 
-Każda definicja narzędzia kosztuje tokeny w każdej sesji, więc sesja startuje z małym rdzeniem (ok. 1,3 tys. tokenów),
+Każda definicja narzędzia kosztuje tokeny w każdej sesji, więc sesja startuje z małym rdzeniem (ok. 1,5 tys. tokenów),
 a Claude dociąga grupę przez `ado_tools enable=<grupa>`, gdy rozmowa jej potrzebuje — pytanie o sprint ładuje `boards`,
 nowa historyjka `write`. Skille i prompty same ładują to, czego używają. Tryb wybiera tylko, które grupy wolno załadować;
 nigdy nie jest uprawnieniem (o tym decyduje PAT).
@@ -189,9 +189,13 @@ nigdy nie jest uprawnieniem (o tym decyduje PAT).
 | `pr` | `ado_pr`, `ado_pr_update` | – | ✓ | ✓ |
 | `pipelines` | `ado_pipeline`, `ado_pipeline_run` | – | ✓ | ✓ |
 
-`adolens config --add-toolset <grupa>` dopuszcza jeszcze jedną grupę ponad tryb. Klient, który nie przyjmuje nowych
-narzędzi w trakcie rozmowy, może startować ze wszystkimi grupami trybu: `adolens config --load-all-tools true` (albo
-*Narzędzia na start* w menu ustawień) — ok. 6 tys. tokenów na sesję zamiast 1,3 tys.
+`adolens config --add-toolset <grupa>` dopuszcza jeszcze jedną grupę ponad tryb. Kiedy ładować grupy, ustawia
+`adolens config --tool-loading` (albo *Narzędzia na start* w menu ustawień):
+
+- `auto` (domyślnie): na żądanie w Claude Code, który przyjmuje nowe narzędzia w trakcie rozmowy; w innych klientach,
+  także w Claude Desktop, wszystkie grupy trybu od startu (ok. 6–7 tys. tokenów), żeby niczego tam nie brakowało;
+- `demand`: na żądanie w każdym kliencie (ok. 1,3 tys. tokenów na start) — dla klienta, o którym wiadomo, że przyjmuje nowe narzędzia;
+- `all`: wszystkie grupy trybu od startu wszędzie.
 
 ## Mapa narzędzi
 
 
@@ -23,7 +23,7 @@
     <AssemblyTitle>ADO Lens for Azure DevOps</AssemblyTitle>
     <Description>Azure DevOps (work items, boards, wiki, Git and TFVC, pipelines) served to AI assistants over MCP</Description>
     <Copyright>Copyright © 2026 WillowDev</Copyright>
-    <Version>0.8.0-beta.1</Version>
+    <Version>0.8.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
 
@@ -28,7 +28,7 @@ connections     list the connections
           config          show or change settings
                             --connection <name> --project <name> --team <name>   (defaults of a connection)
                             --default-connection <name>  --mode po|dev|full  --usage-log true|false
-                            --show-tokens true|false  --load-all-tools true|false  --add-toolset <set>  --remove-toolset <set>  --confirm-above <n>
+                            --show-tokens true|false  --tool-loading auto|demand|all  --add-toolset <set>  --remove-toolset <set>  --confirm-above <n>
                             --language pl|en|auto (settings console and installer texts)
                             --download-dir <folder>|default (where save=true puts files; default Downloads\ADO Lens)
                             --connection <c> --label-languages "en-US, pl"|all  (languages review and label require)
@@ -323,9 +323,9 @@ public int Config()
                 settings.ShowTokens = bool.TryParse(st, out var b) ? b : throw new ArgumentException("--show-tokens takes true or false");
                 changed = true;
             }
-            if (cl.Opt("load-all-tools") is { } la)
+            if (cl.Opt("tool-loading") is { } tl)
             {
-                settings.LoadAllTools = bool.TryParse(la, out var b) ? b : throw new ArgumentException("--load-all-tools takes true or false");
+                settings.ToolLoading = Settings.NormalizeToolLoading(tl);
                 changed = true;
             }
             if (cl.Opt("confirm-above") is { } ca)
@@ -342,7 +342,12 @@ public int Config()
         if (changed) settings.Save(SettingsPath);
         Console.WriteLine($"settings: {SettingsPath}{(changed ? " (saved)" : "")}");
         Console.WriteLine($"mode: {settings.Mode} (tool groups: {string.Join(", ", Toolsets.Active(settings).OrderBy(t => Array.IndexOf(Toolsets.All, t)))}; "
-                          + (settings.LoadAllTools ? "all loaded at start)" : "core at start, the rest when Claude needs them)"));
+                          + settings.ToolLoading switch
+                          {
+                              "all" => "all loaded at start)",
+                              "demand" => "core at start, the rest when Claude needs them)",
+                              _ => "auto: on demand in Claude Code, all at start in other clients)",
+                          });
         Console.WriteLine($"usage log: {(settings.UsageLog ? "on" : "off")}   token footer: {(settings.ShowTokens ? "on" : "off")}   preview updates of more than {settings.ConfirmBulkAbove} items   default connection: {settings.DefaultConnection ?? "-"}");
         return Connections();
     }
@@ -749,8 +754,7 @@ async Task<int> SetupMenuAsync()
             Console.WriteLine(Ui.T("  6. Language: Polish / English", "  6. Język: polski / angielski"));
             Console.WriteLine(Ui.T("  7. Required label languages (checks of D365 changes)", "  7. Wymagane języki etykiet (kontrola zmian D365)"));
             Console.WriteLine(Ui.T($"  8. Download folder: {Downloads.BaseDir(settings)}", $"  8. Folder pobierania: {Downloads.BaseDir(settings)}"));
-            Console.WriteLine(Ui.T($"  9. Tools at start: {(settings.LoadAllTools ? "all of the mode" : "core, the rest on demand")}",
-                                   $"  9. Narzędzia na start: {(settings.LoadAllTools ? "wszystkie z trybu" : "podstawowe, reszta na żądanie")}"));
+            Console.WriteLine(Ui.T($"  9. Tools at start: {settings.ToolLoading}", $"  9. Narzędzia na start: {settings.ToolLoading}"));
             var choice = Prompt(Ui.T("Choice (Enter = done): ", "Wybór (Enter = koniec): "));
             switch (choice?.Trim())
             {
@@ -791,12 +795,14 @@ async Task<int> SetupMenuAsync()
                     Ui.Polish = settings.Language == "pl" || settings.Language is null && Ui.Polish;
                     break;
                 case "9":
-                    Console.WriteLine(Ui.T("  1. Core only - Claude loads the other groups when the conversation needs them (fewer tokens)",
-                                           "  1. Tylko podstawowe - Claude dociąga pozostałe grupy, gdy rozmowa ich wymaga (mniej tokenów)"));
-                    Console.WriteLine(Ui.T("  2. All tools of the mode at start (for a client that does not take new tools during a conversation)",
-                                           "  2. Wszystkie narzędzia trybu od startu (dla klienta, który nie przyjmuje nowych narzędzi w trakcie rozmowy)"));
-                    var t = Prompt(Ui.T($"  choice [{(settings.LoadAllTools ? 2 : 1)}]: ", $"  wybór [{(settings.LoadAllTools ? 2 : 1)}]: "));
-                    settings.LoadAllTools = t?.Trim() switch { "1" => false, "2" => true, _ => settings.LoadAllTools };
+                    Console.WriteLine(Ui.T("  1. auto - on demand in Claude Code, all at start in other clients (Claude Desktop)",
+                                           "  1. auto - na żądanie w Claude Code, wszystkie od startu w innych klientach (Claude Desktop)"));
+                    Console.WriteLine(Ui.T("  2. demand - core at start, Claude loads the other groups when the conversation needs them (fewest tokens)",
+                                           "  2. demand - podstawowe na start, Claude dociąga pozostałe grupy, gdy rozmowa ich wymaga (najmniej tokenów)"));
+                    Console.WriteLine(Ui.T("  3. all - every tool of the mode at start", "  3. all - wszystkie narzędzia trybu od startu"));
+                    var cur = settings.ToolLoading switch { "demand" => "2", "all" => "3", _ => "1" };
+                    var t = Prompt(Ui.T($"  choice [{cur}]: ", $"  wybór [{cur}]: "));
+                    settings.ToolLoading = (string.IsNullOrWhiteSpace(t) ? cur : t.Trim()) switch { "2" => "demand", "3" => "all", _ => "auto" };
                     settings.Save(SettingsPath);
                     Console.WriteLine(Ui.T("  new Claude sessions use it", "  obowiązuje w nowych sesjach Claude'a"));
                     break;
 
@@ -23,7 +23,7 @@ public sealed partial class CommandLine
         ["pr"] = ["connection=", "project=", "repo=", "list=", "detail=", "merged=", "since=", "top="],
         ["pipeline"] = ["connection=", "project=", "definition=", "branch=", "top=", "detail=", "artifacts", "artifact=", "part=", "save", "to=", "deployments", "stage="],
         ["changes"] = ["connection=", "repo=", "file=", "detail="],
-        ["config"] = ["env=", "remove-env=", "connection=", "default-connection=", "project=", "team=", "mode=", "usage-log=", "add-toolset=", "remove-toolset=", "confirm-above=", "show-tokens=", "load-all-tools=", "language=", "label-languages=", "download-dir="],
+        ["config"] = ["env=", "remove-env=", "connection=", "default-connection=", "project=", "team=", "mode=", "usage-log=", "add-toolset=", "remove-toolset=", "confirm-above=", "show-tokens=", "tool-loading=", "language=", "label-languages=", "download-dir="],
         ["item"] = ["connection=", "include=", "detail="],
         ["query"] = ["connection=", "project=", "wiql=", "query=", "top="],
         ["create"] = ["connection=", "project=", "type=", "title=", "description=", "criteria=", "assign=", "parent=", "iteration=", "area=", "tags=", "state=", "field=", "template="],
 
@@ -56,11 +56,14 @@ public static class McpTools
           ado_tools enable=<group> (several: "write;boards"). ado_tools without arguments lists the groups.
         """;
 
-    /// <summary>Instructions of the groups loaded at start (with groups, the core only) and how to load the others.</summary>
+    /// <summary>
+    /// Instructions and how to load groups. They are sent before the server knows the client, so only demand keeps them
+    /// to the core lines (the others come with each loaded group); auto and all carry the lines of every group of the mode.
+    /// </summary>
     public static string Instructions(Settings settings)
     {
-        var loaded = Toolsets.Loaded(settings);
-        return Intro + (settings.LoadAllTools ? "" : Groups) + string.Concat(Lines.Where(l => loaded.Contains(l.Key)).Select(l => l.Value));
+        var groups = settings.ToolLoading == "demand" ? Toolsets.Loaded(settings) : Toolsets.Active(settings);
+        return Intro + (settings.ToolLoading == "all" ? "" : Groups) + string.Concat(Lines.Where(l => groups.Contains(l.Key)).Select(l => l.Value));
     }
 
     /// <summary>The writing and usage hints of a group, returned when the group is loaded during a conversation.</summary>
 
@@ -162,6 +162,11 @@ async Task<int> RunServerAsync()
         })
         .WithStdioServerTransport()
         .WithActiveTools(lens.Settings)
+        .WithRequestFilters(f => f.AddListToolsFilter(next => (context, ct) =>
+        {
+            ToolGroups.ForClient(lens.Settings, context.Server);
+            return next(context, ct);
+        }))
         .WithPrompts(Prompts.TypesFor(lens.Settings));
     await builder.Build().RunAsync();
     return 0;
 
@@ -49,11 +49,21 @@ public sealed partial class Settings
     /// <summary>Language of the settings console and installer texts: "pl", "en", or null for the language of Windows.</summary>
     public string? Language { get; set; }
 
+    public const string ToolLoadings = "auto, demand, all";
+
     /// <summary>
-    /// Start every session with all tool groups of the mode instead of the core only (for clients that do not take new
-    /// tools during a conversation; costs more tokens per session).
+    /// demand: a session starts with the core and Claude loads groups when it needs them; all: every group of the mode
+    /// from the start (more tokens); auto: demand for clients known to take new tools during a conversation, all for others.
     /// </summary>
-    public bool LoadAllTools { get; set; }
+    public string ToolLoading { get; set; } = "auto";
+
+    public static string NormalizeToolLoading(string value) => value.Trim().ToLowerInvariant() switch
+    {
+        "auto" or "" => "auto",
+        "demand" or "on-demand" or "core" => "demand",
+        "all" => "all",
+        _ => throw new ArgumentException($"unknown tool loading '{value}' (known: {ToolLoadings})"),
+    };
 
     /// <summary>Where files are saved (save=true); null: Downloads\ADO Lens.</summary>
     public string? DownloadDir { get; set; }
 
@@ -10,6 +10,28 @@ namespace AdoLens;
 /// </summary>
 public static class ToolGroups
 {
+    /// <summary>Clients known to take new tools during a conversation (MCP tools/list_changed), by their clientInfo name.</summary>
+    static readonly string[] TakeNewTools = ["claude-code"];
+
+    static int _clientChecked;
+
+    public static bool TakesNewTools(string? clientName) =>
+        clientName is { } n && TakeNewTools.Any(c => n.Contains(c, StringComparison.OrdinalIgnoreCase));
+
+    /// <summary>
+    /// ToolLoading=auto: before the first tool list, a client that is not known to take new tools gets every group of
+    /// the mode, so nothing is missing there; the others keep the core and load groups on demand.
+    /// </summary>
+    public static void ForClient(Settings settings, McpServer server)
+    {
+        if (Interlocked.Exchange(ref _clientChecked, 1) == 1) return;
+        if (settings.ToolLoading != "auto" || TakesNewTools(server.ClientInfo?.Name)) return;
+        if (server.ServerOptions.ToolCollection is not { } tools) return;
+        using (tools.DeferChangedEvents())
+            foreach (var method in Toolsets.Methods(Toolsets.Active(settings)))
+                tools.TryAdd(McpServerTool.Create(method, options: new McpServerToolCreateOptions { Services = server.Services }));
+    }
+
     public static string Load(Settings settings, McpServer server, string? enable)
     {
         var tools = server.ServerOptions.ToolCollection ?? throw new InvalidOperationException("this server has no tool collection");