From ddc0c133ddbc13e729be1313302b5e8882ac8fc8 Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Fri, 16 Oct 2026 14:44:10 +0200
Subject: [PATCH 1/4] Pull request tags; Product Owner mode without pull
 request and pipeline tools or developer prompts

---
 CHANGELOG.md                         |  7 +++++
 src/AdoLens/McpTools.cs              | 18 ++++++------
 src/AdoLens/Program.cs               |  2 +-
 src/AdoLens/Prompts.cs               | 14 ++++++++++
 src/AdoLens/PullRequests.cs          | 42 +++++++++++++++++++++++++---
 tests/AdoLens.Tests/MergedPrTests.cs |  4 +--
 tests/AdoLens.Tests/PromptTests.cs   | 19 +++++++++----
 tests/AdoLens.Tests/SetupTests.cs    |  2 +-
 8 files changed, 86 insertions(+), 22 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38d05d8..100f699 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.8.0 — unreleased
+
+- Pull request tags (labels): `ado_pr_update action=tag tags="R349; -old"`, tags when creating a PR, and tags shown in
+  PR lists, details and merged PRs.
+- Product Owner mode: no pull request or pipeline tools and no developer prompts (`dev_*`); they stay in the dev and
+  full modes.
+
 ## 0.7.3 — 2026-10-16
 
 Fixes from a real question: "pull requests merged into staging after release X, with their work items and tags".
diff --git a/src/AdoLens/McpTools.cs b/src/AdoLens/McpTools.cs
index c0ea5a2..ab465ac 100644
--- a/src/AdoLens/McpTools.cs
+++ b/src/AdoLens/McpTools.cs
@@ -36,11 +36,12 @@ public static class McpTools
             """,
         [Toolsets.Trace] = """
             - Checking work against what was asked: ado_trace, then read the diffs with ado_changes - never assume.
-            - What went into a branch or an environment: ado_pr merged=<branch> since=<time> (with work items and tags); the time of a
-              deployment: ado_pipeline deployments=true; a branch's whole history: ado_file path=/ repo=<r> history=true version=<branch>.
+            - A branch's whole history: ado_file path=/ repo=<r> history=true version=<branch>.
             """,
         [Toolsets.Pr] = """
             - PR description: what and why with the work item, changes as bullets by area, how to check, risks only if any.
+            - What went into a branch or an environment: ado_pr merged=<branch> since=<time> (with work items and tags); the time of a
+              deployment: ado_pipeline deployments=true.
             """,
         [Toolsets.Pipelines] = """
             - A failed build: give the error lines from the log, not the whole log.
@@ -319,8 +320,8 @@ public static Task<string> ReadFile(Lens lens, string path,
             () => Knowledge.FileAsync(lens, connection, project, path, repo, version, part, history, top, detail, ct));
 }
 
-// Reading pull requests and builds is part of checking work (PO mode too); changing them is for developers.
-[McpServerToolType, Toolset(Toolsets.Trace)]
+// Pull requests and pipelines are for developers: the Product Owner mode leaves them out.
+[McpServerToolType, Toolset(Toolsets.Pr)]
 public static class PrReadTools
 {
     [McpServerTool(Name = "ado_pr", ReadOnly = true, Idempotent = true)]
@@ -347,7 +348,7 @@ public static Task<string> Pr(Lens lens,
 public static class PrTools
 {
     [McpServerTool(Name = "ado_pr_update")]
-    [Description("Acts on pull requests: create (repo, source, target, title, text, workItems, reviewers, draft), comment (text, optional file and line), reply (thread, text), resolve (thread, status), vote (approve|suggestions|wait|reject|reset), publish, complete, abandon. @[name] in text notifies.")]
+    [Description("Acts on pull requests: create (repo, source, target, title, text, workItems, reviewers, draft), comment (text, optional file and line), reply (thread, text), resolve (thread, status), vote (approve|suggestions|wait|reject|reset), tag (tags), publish, complete, abandon. @[name] in text notifies.")]
     public static Task<string> PrUpdate(Lens lens,
         string action,
         int? id = null,
@@ -364,20 +365,21 @@ public static Task<string> PrUpdate(Lens lens,
         [Description("Work item ids: 123;456.")] string? workItems = null,
         [Description("Names or e-mails separated by ';'.")] string? reviewers = null,
         bool draft = false,
+        [Description("For tag and create: 'a; b' adds, '-c' removes.")] string? tags = null,
         bool deleteSourceBranch = false,
         [Description("noFastForward | squash | rebase | rebaseMerge.")] string? mergeStrategy = null,
         string? connection = null,
         CancellationToken ct = default)
-        => McpTools.Run("ado_pr_update", new { action, id, repo, thread, file, line, vote, status, source, target, title, workItems, reviewers, draft, deleteSourceBranch, mergeStrategy, connection },
+        => McpTools.Run("ado_pr_update", new { action, id, repo, thread, file, line, vote, status, source, target, title, workItems, reviewers, draft, tags, deleteSourceBranch, mergeStrategy, connection },
             () => PullRequestQueries.ActAsync(lens, connection, new PullRequestQueries.PrAction
             {
                 Action = action, Id = id, Repo = repo, Text = text, Thread = thread, File = file, Line = line, Vote = vote, Status = status,
                 Source = source, Target = target, Title = title, WorkItems = workItems, Reviewers = reviewers, Draft = draft,
-                DeleteSourceBranch = deleteSourceBranch, MergeStrategy = mergeStrategy,
+                DeleteSourceBranch = deleteSourceBranch, MergeStrategy = mergeStrategy, Tags = tags,
             }, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Trace)]
+[McpServerToolType, Toolset(Toolsets.Pipelines)]
 public static class PipelineReadTools
 {
     [McpServerTool(Name = "ado_pipeline", ReadOnly = true, Idempotent = true)]
diff --git a/src/AdoLens/Program.cs b/src/AdoLens/Program.cs
index c296f9a..a3b1fc1 100644
--- a/src/AdoLens/Program.cs
+++ b/src/AdoLens/Program.cs
@@ -162,7 +162,7 @@ async Task<int> RunServerAsync()
         })
         .WithStdioServerTransport()
         .WithActiveTools(lens.Settings)
-        .WithPrompts([typeof(Prompts)]);
+        .WithPrompts(Prompts.TypesFor(lens.Settings));
     await builder.Build().RunAsync();
     return 0;
 }
diff --git a/src/AdoLens/Prompts.cs b/src/AdoLens/Prompts.cs
index a3a5fe3..98631ee 100644
--- a/src/AdoLens/Prompts.cs
+++ b/src/AdoLens/Prompts.cs
@@ -12,6 +12,11 @@ namespace AdoLens;
 [McpServerPromptType]
 public static class Prompts
 {
+    /// <summary>The prompt classes of a mode: developer prompts (dev_*) only in the dev and full modes.</summary>
+    /// IEnumerable on purpose: an array would bind to the generic WithPrompts&lt;T&gt;(target) and register nothing.
+    public static IEnumerable<Type> TypesFor(Settings settings) =>
+        settings.Mode == "po" ? [typeof(Prompts)] : [typeof(Prompts), typeof(DevPrompts)];
+
     /// <summary>The installed skills: …\ADO Lens\skills (the program is in …\ADO Lens\bin); in a source tree, skills\ above.</summary>
     internal static string? SkillsDir()
     {
@@ -34,6 +39,8 @@ internal static string Skill(string name, string fallback)
         return fallback;
     }
 
+    internal static string AskSkill(string skill, string fallback, string request) => Ask(skill, fallback, request);
+
     static string Ask(string skill, string fallback, string request) =>
         $"{Skill(skill, fallback)}\n\n---\nRequest: {request.Trim()}\nAnswer in the language of the request (Polish request → Polish answer).";
 
@@ -84,6 +91,13 @@ public static string Wiki([Description("What the page is about.")] string topic)
     [Description("A D365 message pasted as seen on screen: its label, translations, and where and in which process it appears.")]
     public static string Label([Description("The message text as seen (values in it are fine).")] string text) =>
         $"Use ado_label with this text, then read the method that shows it (ado_file part=<method>) and explain in plain language when the user sees this message and what to do about it.\n\nMessage: {text.Trim()}\nAnswer in the language of the message.";
+}
+
+/// <summary>Prompts for developers: registered in the dev and full modes only.</summary>
+[McpServerPromptType]
+public static class DevPrompts
+{
+    static string Ask(string skill, string fallback, string request) => Prompts.AskSkill(skill, fallback, request);
 
     [McpServerPrompt(Name = "dev_start", Title = "Start work on a work item")]
     [Description("Developer: what to do, where in the code, a plan from the acceptance criteria.")]
diff --git a/src/AdoLens/PullRequests.cs b/src/AdoLens/PullRequests.cs
index 223d22b..b3e9fb5 100644
--- a/src/AdoLens/PullRequests.cs
+++ b/src/AdoLens/PullRequests.cs
@@ -8,7 +8,7 @@ namespace AdoLens;
 /// <summary>Pull requests: lists, one PR with reviewers, policies, work items and human comment threads, and actions.</summary>
 public static partial class PullRequestQueries
 {
-    public static readonly string[] Actions = ["create", "comment", "reply", "resolve", "vote", "publish", "complete", "abandon"];
+    public static readonly string[] Actions = ["create", "comment", "reply", "resolve", "vote", "tag", "publish", "complete", "abandon"];
 
     static readonly Dictionary<string, int> Votes = new(StringComparer.OrdinalIgnoreCase)
     {
@@ -37,7 +37,7 @@ static string Line(JsonElement pr)
         return $"PR {pr.GetProperty("pullRequestId").GetInt32()} [{Json.Str(Json.Obj(pr, "repository"), "name")}] {Json.Str(pr, "title")}: " +
                $"{Code.Short(Json.Str(pr, "targetRefName"))} <- {Code.Short(Json.Str(pr, "sourceRefName"))} " +
                $"({Json.Str(Json.Obj(pr, "createdBy"), "displayName")}, {Ago(Json.Str(pr, "creationDate"))})" +
-               (votes.Any() ? $"; {string.Join(", ", votes)}" : "") + (flags.Count > 0 ? $"; {string.Join(", ", flags)}" : "");
+               (votes.Any() ? $"; {string.Join(", ", votes)}" : "") + (flags.Count > 0 ? $"; {string.Join(", ", flags)}" : "") + Tags(pr);
     }
 
     public static async Task<string> ListAsync(Lens lens, string? connection, string? project, string? list, CancellationToken ct = default)
@@ -106,7 +106,7 @@ public static async Task<string> MergedAsync(Lens lens, string? connection, stri
             var wi = items[i].Where(heads.ContainsKey).Select(x => heads[x]).ToList();
             sb.AppendLine($"- PR {pr.GetProperty("pullRequestId").GetInt32()} {Closed(pr):yyyy-MM-dd} {Json.Str(Json.Obj(pr, "repository"), "name")}: " +
                           $"{Formatting.Collapse(Json.Str(pr, "title") ?? "", 70)} ({Json.Str(Json.Obj(pr, "createdBy"), "displayName")}, from {Formatting.Collapse(Code.Short(Json.Str(pr, "sourceRefName")) ?? "", 40)})" +
-                          (wi.Count > 0 ? " -> " + string.Join("; ", wi) : " - no work item"));
+                          Tags(pr) + (wi.Count > 0 ? " -> " + string.Join("; ", wi) : " - no work item"));
         }
         if (list.Count >= (from is null ? top : 500) && prs.Count == top) sb.Append($"(top={top}; more with a higher top or a later since)");
         return sb.ToString().TrimEnd();
@@ -229,6 +229,32 @@ public sealed record PrAction
         public bool Draft { get; init; }
         public bool DeleteSourceBranch { get; init; }
         public string? MergeStrategy { get; init; }
+        /// <summary>"a; b" adds, "-c" removes (pull request labels).</summary>
+        public string? Tags { get; init; }
+    }
+
+    /// <summary>The active labels (tags) of a pull request as "[tags: a; b]", or "".</summary>
+    internal static string Tags(JsonElement pr)
+    {
+        var names = Json.Arr(pr, "labels").Where(l => !l.TryGetProperty("active", out var a) || a.ValueKind != JsonValueKind.False)
+            .Select(l => Json.Str(l, "name")).Where(n => !string.IsNullOrEmpty(n)).ToList();
+        return names.Count == 0 ? "" : $" [tags: {string.Join("; ", names)}]";
+    }
+
+    /// <summary>Adds and removes labels: "a; b" adds, "-c" removes; returns the labels after the change.</summary>
+    static async Task<List<string>> SetTagsAsync(AdoClient client, string baseUrl, string tags, CancellationToken ct)
+    {
+        foreach (var t in tags.Split([';', ','], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+        {
+            if (t.StartsWith('-'))
+            {
+                try { await client.SendAsync(HttpMethod.Delete, $"{baseUrl}/labels/{Uri.EscapeDataString(t[1..].Trim())}", null, null, ct); }
+                catch (AdoApiException ex) when (ex.Status == System.Net.HttpStatusCode.NotFound) { }
+            }
+            else await client.PostAsync($"{baseUrl}/labels", new { name = t.TrimStart('+').Trim() }, ct);
+        }
+        return (await client.GetListAsync($"{baseUrl}/labels", ct)).Where(l => !l.TryGetProperty("active", out var a) || a.ValueKind != JsonValueKind.False)
+            .Select(l => Json.Str(l, "name")).Where(n => n is not null).Select(n => n!).ToList();
     }
 
     public static async Task<string> ActAsync(Lens lens, string? connection, PrAction a, CancellationToken ct = default)
@@ -257,8 +283,10 @@ public static async Task<string> ActAsync(Lens lens, string? connection, PrActio
                 ["reviewers"] = reviewers,
             };
             var pr = await client.PostAsync($"_apis/git/repositories/{repo.Id}/pullrequests", body, ct);
+            if (!string.IsNullOrWhiteSpace(a.Tags))
+                await SetTagsAsync(client, $"_apis/git/repositories/{repo.Id}/pullrequests/{pr.GetProperty("pullRequestId").GetInt32()}", a.Tags, ct);
             var words = Html.Words(a.Text);
-            return $"created {Line(pr)}" + (WorkQueries.ParseIds(a.WorkItems).Count == 0 ? "\nnote: no work item linked (branch policies often require one)" : "")
+            return $"created {Line(pr)}{(string.IsNullOrWhiteSpace(a.Tags) ? "" : $" [tags: {a.Tags}]")}" + (WorkQueries.ParseIds(a.WorkItems).Count == 0 ? "\nnote: no work item linked (branch policies often require one)" : "")
                    + (words > 150 ? $"\nnote: description has {words} words; usually ≤ 150 - what and why, changes, how to check" : "");
         }
 
@@ -306,6 +334,12 @@ public static async Task<string> ActAsync(Lens lens, string? connection, PrActio
                 await client.SendAsync(HttpMethod.Put, $"{baseUrl}/reviewers/{me}", new { vote }, "application/json", ct);
                 return $"voted on PR {id}: {VoteText(vote)}";
             }
+            case "tag":
+            {
+                if (string.IsNullOrWhiteSpace(a.Tags)) throw new ArgumentException("tag needs tags: \"a; b\" adds, \"-c\" removes");
+                var now = await SetTagsAsync(client, baseUrl, a.Tags, ct);
+                return $"PR {id} tags: {(now.Count == 0 ? "none" : string.Join("; ", now))}";
+            }
             case "publish":
                 await client.SendAsync(HttpMethod.Patch, baseUrl, new { isDraft = false }, "application/json", ct);
                 return $"PR {id} is published (no longer a draft)";
diff --git a/tests/AdoLens.Tests/MergedPrTests.cs b/tests/AdoLens.Tests/MergedPrTests.cs
index ac676fd..8153e41 100644
--- a/tests/AdoLens.Tests/MergedPrTests.cs
+++ b/tests/AdoLens.Tests/MergedPrTests.cs
@@ -12,7 +12,7 @@ public MergedPrTests()
             .On("/contoso/Demo/_apis/git/pullrequests", """
                 {"value":[
                   {"pullRequestId":12,"title":"Login form","closedDate":"2026-10-14T10:00:00Z","repository":{"id":"r1","name":"portal"},
-                   "createdBy":{"displayName":"Anna Nowak"},"sourceRefName":"refs/heads/feature/login"},
+                   "createdBy":{"displayName":"Anna Nowak"},"sourceRefName":"refs/heads/feature/login","labels":[{"name":"R349","active":true},{"name":"old","active":false}]},
                   {"pullRequestId":11,"title":"Old change","closedDate":"2026-09-01T10:00:00Z","repository":{"id":"r1","name":"portal"},
                    "createdBy":{"displayName":"Ben Kowalski"},"sourceRefName":"refs/heads/feature/old"}]}
                 """)
@@ -34,7 +34,7 @@ public async Task Pull_requests_merged_into_a_branch_come_with_their_work_items(
     {
         var all = await PullRequestQueries.MergedAsync(lens, null, null, "staging", null, null, 30);
         Assert.Contains("2 pull request(s) completed into staging in Demo", all);
-        Assert.Contains("- PR 12 2026-10-14 portal: Login form (Anna Nowak, from feature/login) -> #1 Product Backlog Item Login page (New) [tags: UAT]", all);
+        Assert.Contains("- PR 12 2026-10-14 portal: Login form (Anna Nowak, from feature/login) [tags: R349] -> #1 Product Backlog Item Login page (New) [tags: UAT]", all);
         Assert.Contains("- PR 11 2026-09-01 portal: Old change (Ben Kowalski, from feature/old) - no work item", all);
         Assert.Contains(ado.Requests, r => r.Contains("searchCriteria.status=completed") && r.Contains("searchCriteria.targetRefName=refs/heads/staging"));
 
diff --git a/tests/AdoLens.Tests/PromptTests.cs b/tests/AdoLens.Tests/PromptTests.cs
index 375a844..d83d626 100644
--- a/tests/AdoLens.Tests/PromptTests.cs
+++ b/tests/AdoLens.Tests/PromptTests.cs
@@ -18,7 +18,7 @@ public void Prompts_carry_the_skill_and_the_request()
         Assert.Contains("# Checking work for a Product Owner", text); // read from skills/po-verify/SKILL.md, front matter left out
         Assert.DoesNotContain("name: po-verify", text);
         Assert.Contains("Request: Was work item #37 done as asked", text);
-        Assert.Contains("Request: Pull request for PR 12.", Prompts.DevPr("PR 12"));
+        Assert.Contains("Request: Pull request for PR 12.", DevPrompts.DevPr("PR 12"));
     }
 
     [Fact]
@@ -29,15 +29,22 @@ public void Every_prompt_has_its_skill_in_the_repository()
             Assert.True(File.Exists(Path.Combine(skills, name, "SKILL.md")), name);
     }
 
-    [Fact]
-    public void The_server_registers_the_prompts()
+    static List<string> PromptNames(string mode)
     {
         var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
         Microsoft.Extensions.DependencyInjection.McpServerBuilderExtensions.WithPrompts(
-            Microsoft.Extensions.DependencyInjection.McpServerServiceCollectionExtensions.AddMcpServer(services), [typeof(Prompts)]);
+            Microsoft.Extensions.DependencyInjection.McpServerServiceCollectionExtensions.AddMcpServer(services), Prompts.TypesFor(new Settings { Mode = mode }));
         var sp = Microsoft.Extensions.DependencyInjection.ServiceCollectionContainerBuilderExtensions.BuildServiceProvider(services);
-        var names = Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetServices<McpServerPrompt>(sp).Select(p => p.ProtocolPrompt.Name).Order().ToList();
-        Assert.Equal(["dev_build", "dev_pr", "dev_start", "dev_why", "explain", "label", "refine", "sprint", "story", "test", "verify", "wiki"], names);
+        return Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetServices<McpServerPrompt>(sp).Select(p => p.ProtocolPrompt.Name).Order().ToList();
+    }
+
+    [Fact]
+    public void The_server_registers_the_prompts_of_the_mode()
+    {
+        // A Product Owner gets no developer prompts (pull requests, builds, code history).
+        Assert.Equal(["explain", "label", "refine", "sprint", "story", "test", "verify", "wiki"], PromptNames("po"));
+        Assert.Equal(["dev_build", "dev_pr", "dev_start", "dev_why", "explain", "label", "refine", "sprint", "story", "test", "verify", "wiki"], PromptNames("full"));
+        Assert.Contains("dev_pr", PromptNames("dev"));
     }
 
     [Fact]
diff --git a/tests/AdoLens.Tests/SetupTests.cs b/tests/AdoLens.Tests/SetupTests.cs
index 4ce964b..04b3d4b 100644
--- a/tests/AdoLens.Tests/SetupTests.cs
+++ b/tests/AdoLens.Tests/SetupTests.cs
@@ -287,7 +287,7 @@ public void Tool_definitions_do_not_grow_by_accident(string mode, int maxTokens)
     public void The_server_really_registers_the_tools_of_the_mode()
     {
         var names = RegisteredTools(new Settings { Mode = "po" }).Select(t => t.ProtocolTool.Name).Order().ToList();
-        Assert.Equal(["ado_attachments", "ado_backlog", "ado_board", "ado_changes", "ado_comment", "ado_create", "ado_create_tree", "ado_fields", "ado_file", "ado_health", "ado_label", "ado_link", "ado_metrics", "ado_my_day", "ado_pipeline", "ado_pr",
+        Assert.Equal(["ado_attachments", "ado_backlog", "ado_board", "ado_changes", "ado_comment", "ado_create", "ado_create_tree", "ado_fields", "ado_file", "ado_health", "ado_label", "ado_link", "ado_metrics", "ado_my_day",
             "ado_query", "ado_recipe", "ado_release_notes", "ado_review", "ado_search", "ado_settings", "ado_sprint", "ado_status", "ado_test_create", "ado_tests",
             "ado_trace", "ado_undo", "ado_update",
             "ado_upgrade", "ado_wiki", "ado_wiki_write", "ado_work_item"], names);

From 4cec8f7510413407ab7b6973ddbe2637f89753b8 Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Fri, 16 Oct 2026 14:59:20 +0200
Subject: [PATCH 2/4] ADO Lens 0.8.0-beta.1 (test release)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fewer tokens in every session: about 1.3k 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.
- 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
  PR lists, details and merged PRs.
- Product Owner mode: no pull request or pipeline tools and no developer prompts (`dev_*`); they stay in the dev and
  full modes.
---
 CHANGELOG.md                      | 11 ++++
 README.md                         | 37 +++++++------
 README.pl.md                      | 37 +++++++------
 skills/dev-build/SKILL.md         |  2 +
 skills/dev-pr/SKILL.md            |  2 +
 skills/dev-start/SKILL.md         |  2 +
 skills/dev-why/SKILL.md           |  2 +
 skills/po-explain/SKILL.md        |  2 +
 skills/po-refine/SKILL.md         |  2 +
 skills/po-sprint/SKILL.md         |  2 +
 skills/po-story/SKILL.md          |  2 +
 skills/po-test/SKILL.md           |  2 +
 skills/po-verify/SKILL.md         |  2 +
 skills/po-wiki/SKILL.md           |  2 +
 src/AdoLens/AdoLens.csproj        |  2 +-
 src/AdoLens/Cli.cs                | 22 +++++++-
 src/AdoLens/CommandLine.cs        |  2 +-
 src/AdoLens/McpTools.cs           | 63 +++++++++++++--------
 src/AdoLens/Program.cs            |  4 +-
 src/AdoLens/Prompts.cs            |  2 +-
 src/AdoLens/Settings.cs           |  6 ++
 src/AdoLens/ToolGroups.cs         | 59 ++++++++++++++++++++
 src/AdoLens/Toolsets.cs           | 92 +++++++++++++++++++++++--------
 tests/AdoLens.Tests/SetupTests.cs | 43 +++++++++++----
 24 files changed, 305 insertions(+), 97 deletions(-)
 create mode 100644 src/AdoLens/ToolGroups.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 100f699..d01d8da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,17 @@
 
 ## 0.8.0 — unreleased
 
+Fewer tokens in every session: about 1.3k 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.
+- 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
   PR lists, details and merged PRs.
 - Product Owner mode: no pull request or pipeline tools and no developer prompts (`dev_*`); they stay in the dev and
diff --git a/README.md b/README.md
index 728c8c2..3c8e2a4 100644
--- a/README.md
+++ b/README.md
@@ -133,7 +133,8 @@ adolens config                               # show settings
 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 set on top of the mode
+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 --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]
@@ -168,24 +169,28 @@ staging → UAT, master → PROD). Claude asks the user once how they call these
 
 Settings live in `%LOCALAPPDATA%\ado-lens\adolens.json` (no secrets) — they can be edited by hand too.
 
-### Modes and tool sets
+### Modes and tool groups
 
-A mode only chooses which tools Claude sees: fewer tools mean better choices and fewer tokens in every session. It is
-never a permission.
+Every tool definition costs tokens in every session, so a session starts with a small core (about 1.3k 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).
 
-| Tool set | Tools | po | dev | full |
+| Group | Tools | po | dev | full |
 |---|---|:-:|:-:|:-:|
-| `core` | `ado_status`, `ado_settings`, `ado_upgrade`, `ado_fields` | ✓ | ✓ | ✓ |
-| `work` | `ado_work_item`, `ado_query`, `ado_create`, `ado_update`, `ado_comment`, `ado_link`, `ado_search`, `ado_undo`, `ado_attachments`, `ado_create_tree` | ✓ | ✓ | ✓ |
-| `pr` | `ado_pr_update` | – | ✓ | ✓ |
-| `pipelines` | `ado_pipeline_run` | – | ✓ | ✓ |
-| `boards` | `ado_sprint`, `ado_board`, `ado_backlog`, `ado_my_day`, `ado_health`, `ado_release_notes`, `ado_metrics` | ✓ | – | ✓ |
+| `core` (always) | `ado_status`, `ado_settings`, `ado_upgrade`, `ado_tools`, `ado_work_item`, `ado_query`, `ado_search`, `ado_trace` | ✓ | ✓ | ✓ |
+| `write` | `ado_fields`, `ado_create`, `ado_update`, `ado_comment`, `ado_link`, `ado_create_tree`, `ado_undo` | ✓ | ✓ | ✓ |
+| `boards` | `ado_sprint`, `ado_board`, `ado_backlog`, `ado_my_day`, `ado_health`, `ado_metrics`, `ado_release_notes` | ✓ | – | ✓ |
 | `wiki` | `ado_wiki`, `ado_wiki_write` | ✓ | ✓ | ✓ |
-| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_pr`, `ado_pipeline` | ✓ | ✓ | ✓ |
+| `code` | `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_attachments` | ✓ | ✓ | ✓ |
+| `tests` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
 | `recipes` | `ado_recipe` | ✓ | ✓ | ✓ |
-| `test` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
-| `test`, `recipes` | planned | ✓ | (recipes) | ✓ |
-| `code` | planned | – | ✓ | ✓ |
+| `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.
 
 ## Tool map
 
@@ -342,7 +347,7 @@ regular expression per line, `!word` for allowed words. Without a list the relea
 
 | File | What it checks |
 |---|---|
-| `SetupTests.cs` | settings, connections and PAT order (Credential Manager first), command line, Claude configuration edits, Credential Manager, HTTP retries and errors, tool definition budget per mode |
+| `SetupTests.cs` | settings, connections and PAT order (Credential Manager first), command line, Claude configuration edits, Credential Manager, HTTP retries and errors, tool definition budget at start and per mode, the session core, tool groups |
 | `MetadataTests.cs` | fetching the structure (levels, inherited process name, bugs on the requirement backlog), change history, compact `ado_fields` answers |
 | `BoardTests.cs` | sprint progress, capacity left with days off, attention list, picking sprints, ended sprints, board columns and WIP, moving cards with the state mapping, backlog order and reordering, my day |
 | `SetupFlowTests.cs` | release versions and packages for updates, the team's wiki table (round trip, hand-edited pages), detecting the flow from releases and branches, the team map on the wiki with its version, local map over the team's |
@@ -375,7 +380,7 @@ issues or commits.
 | rich text | `Html.cs` |
 | people | `Identities.cs` |
 | connections, PAT, Claude registration | `Settings.cs`, `CredentialStore.cs`, `ClaudeConfigs.cs`, `Cli.cs` |
-| modes and tool sets | `Toolsets.cs` |
+| modes and tool groups, loading them | `Toolsets.cs`, `ToolGroups.cs` |
 | HTTP, retries, errors | `AdoClient.cs` |
 
 Documentation is bilingual: every change to `README.md` goes to `README.pl.md` in the same commit.
diff --git a/README.pl.md b/README.pl.md
index fa1fc64..d6e9c77 100644
--- a/README.pl.md
+++ b/README.pl.md
@@ -136,7 +136,8 @@ adolens config                               # pokaż ustawienia
 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       # dodatkowy zestaw narzędzi ponad tryb
+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 --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]
@@ -169,24 +170,28 @@ staging → UAT, master → PROD). Claude raz pyta użytkownika, jak nazywa te 
 
 Ustawienia siedzą w `%LOCALAPPDATA%\ado-lens\adolens.json` (bez sekretów) — można je też edytować ręcznie.
 
-### Tryby i zestawy narzędzi
+### Tryby i grupy narzędzi
 
-Tryb wybiera tylko, które narzędzia widzi Claude: mniej narzędzi to trafniejszy wybór i mniej tokenów w każdej sesji.
-Nigdy nie jest uprawnieniem.
+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),
+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).
 
-| Zestaw | Narzędzia | po | dev | full |
+| Grupa | Narzędzia | po | dev | full |
 |---|---|:-:|:-:|:-:|
-| `core` | `ado_status`, `ado_settings`, `ado_upgrade`, `ado_fields` | ✓ | ✓ | ✓ |
-| `work` | `ado_work_item`, `ado_query`, `ado_create`, `ado_update`, `ado_comment`, `ado_link`, `ado_search`, `ado_undo`, `ado_attachments`, `ado_create_tree` | ✓ | ✓ | ✓ |
-| `pr` | `ado_pr_update` | – | ✓ | ✓ |
-| `pipelines` | `ado_pipeline_run` | – | ✓ | ✓ |
-| `boards` | `ado_sprint`, `ado_board`, `ado_backlog`, `ado_my_day`, `ado_health`, `ado_release_notes`, `ado_metrics` | ✓ | – | ✓ |
+| `core` (zawsze) | `ado_status`, `ado_settings`, `ado_upgrade`, `ado_tools`, `ado_work_item`, `ado_query`, `ado_search`, `ado_trace` | ✓ | ✓ | ✓ |
+| `write` | `ado_fields`, `ado_create`, `ado_update`, `ado_comment`, `ado_link`, `ado_create_tree`, `ado_undo` | ✓ | ✓ | ✓ |
+| `boards` | `ado_sprint`, `ado_board`, `ado_backlog`, `ado_my_day`, `ado_health`, `ado_metrics`, `ado_release_notes` | ✓ | – | ✓ |
 | `wiki` | `ado_wiki`, `ado_wiki_write` | ✓ | ✓ | ✓ |
-| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_pr`, `ado_pipeline` | ✓ | ✓ | ✓ |
+| `code` | `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_attachments` | ✓ | ✓ | ✓ |
+| `tests` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
 | `recipes` | `ado_recipe` | ✓ | ✓ | ✓ |
-| `test` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
-| `test`, `recipes` | w planie | ✓ | (recipes) | ✓ |
-| `code` | w planie | – | ✓ | ✓ |
+| `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.
 
 ## Mapa narzędzi
 
@@ -342,7 +347,7 @@ i publikuje go razem z `.sha256` i opisem z `CHANGELOG.md` (podgląd: `.\release
 
 | Plik | Co sprawdza |
 |---|---|
-| `SetupTests.cs` | ustawienia, połączenia i kolejność PAT (najpierw Menedżer poświadczeń), linia poleceń, edycja konfiguracji Claude'a, Menedżer poświadczeń, ponawianie i błędy HTTP, budżet definicji narzędzi na tryb, faktyczna rejestracja narzędzi |
+| `SetupTests.cs` | ustawienia, połączenia i kolejność PAT (najpierw Menedżer poświadczeń), linia poleceń, edycja konfiguracji Claude'a, Menedżer poświadczeń, ponawianie i błędy HTTP, budżet definicji narzędzi na start i na tryb, rdzeń sesji, grupy narzędzi |
 | `MetadataTests.cs` | pobieranie struktury (poziomy, nazwa procesu dziedziczonego, bugi na backlogu wymagań), historia zmian, zwięzłe odpowiedzi `ado_fields` |
 | `BoardTests.cs` | postęp sprintu, pozostała pojemność z dniami wolnymi, lista do uwagi, wybór sprintu, zakończone sprinty, kolumny tablicy i WIP, przesuwanie kart z mapowaniem stanów, kolejność backlogu i jej zmiana, mój dzień |
 | `SetupFlowTests.cs` | wersje i paczki wydań do aktualizacji, tabela zespołu na wiki (w obie strony, strony poprawiane ręcznie), wykrywanie przepływu z release'ów i gałęzi, mapa zespołu na wiki z wersją, mapa lokalna ponad zespołową |
@@ -375,7 +380,7 @@ organizacji do testów, zgłoszeń ani commitów.
 | tekst sformatowany | `Html.cs` |
 | osoby | `Identities.cs` |
 | połączenia, PAT, rejestracja w Claude | `Settings.cs`, `CredentialStore.cs`, `ClaudeConfigs.cs`, `Cli.cs` |
-| tryby i zestawy narzędzi | `Toolsets.cs` |
+| tryby i grupy narzędzi, ich ładowanie | `Toolsets.cs`, `ToolGroups.cs` |
 | HTTP, ponawianie, błędy | `AdoClient.cs` |
 
 Dokumentacja jest w dwóch językach: każdą zmianę w `README.md` trzeba odzwierciedlić w `README.pl.md` w tym samym commicie.
diff --git a/skills/dev-build/SKILL.md b/skills/dev-build/SKILL.md
index 4f17f97..855fecb 100644
--- a/skills/dev-build/SKILL.md
+++ b/skills/dev-build/SKILL.md
@@ -5,6 +5,8 @@ description: Diagnoses a failed build or release for a developer - the failing s
 
 # A red build
 
+First load the tools this needs: `ado_tools enable="code;pipelines"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_pipeline` (recent runs; `definition` / `branch` to narrow) → the failed run; `ado_pipeline build=<id>` for the
diff --git a/skills/dev-pr/SKILL.md b/skills/dev-pr/SKILL.md
index bb29b9e..65754ae 100644
--- a/skills/dev-pr/SKILL.md
+++ b/skills/dev-pr/SKILL.md
@@ -5,6 +5,8 @@ description: Writes a pull request description from its work item, or reviews a
 
 # Pull requests
 
+First load the tools this needs: `ado_tools enable="code;pr"` (one call; skip it when they are already there).
+
 ## Writing a description (work item given)
 
 1. `ado_work_item ids=<id>` for the goal and criteria; `ado_changes` of the branch's commits or the PR for what
diff --git a/skills/dev-start/SKILL.md b/skills/dev-start/SKILL.md
index 45d86e4..1c6036a 100644
--- a/skills/dev-start/SKILL.md
+++ b/skills/dev-start/SKILL.md
@@ -7,6 +7,8 @@ description: Starts a developer's work on a work item - what is asked (criteria
 
 The reader is a developer: technical and short - objects, methods, paths, ids.
 
+First load the tools this needs: `ado_tools enable="code;write"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_work_item ids=<id> include=comments` and its parent (for a task the criteria are there); specifications,
diff --git a/skills/dev-why/SKILL.md b/skills/dev-why/SKILL.md
index 8f1c585..95655e5 100644
--- a/skills/dev-why/SKILL.md
+++ b/skills/dev-why/SKILL.md
@@ -5,6 +5,8 @@ description: Explains why a piece of code is the way it is - the history of a fi
 
 # Why the code is like this
 
+First load the tools this needs: `ado_tools enable="code"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_file path=<file or object name> history=true` - changes newest first, with pull requests and work items.
diff --git a/skills/po-explain/SKILL.md b/skills/po-explain/SKILL.md
index faf952c..fa1b732 100644
--- a/skills/po-explain/SKILL.md
+++ b/skills/po-explain/SKILL.md
@@ -8,6 +8,8 @@ description: Explains how a feature works and why it works that way, in business
 The reader is a Product Owner or a business user: answer in plain language, in the language the user writes in.
 Technical names (objects, methods, files) only in brackets, or when asked for "details".
 
+First load the tools this needs: `ado_tools enable="code;wiki"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_search text=<feature in the user's words>` — work items, wiki pages and code at once. Try a second wording
diff --git a/skills/po-refine/SKILL.md b/skills/po-refine/SKILL.md
index 2fe8841..657c22f 100644
--- a/skills/po-refine/SKILL.md
+++ b/skills/po-refine/SKILL.md
@@ -7,6 +7,8 @@ description: Prepares backlog refinement for a Product Owner - what is not ready
 
 The reader is a Product Owner: plain language, in the user's language; ids in brackets.
 
+First load the tools this needs: `ado_tools enable="write;boards;code"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_health` (the team's open backlog) — items without acceptance criteria, description, estimate or parent,
diff --git a/skills/po-sprint/SKILL.md b/skills/po-sprint/SKILL.md
index c5b082f..f508ee7 100644
--- a/skills/po-sprint/SKILL.md
+++ b/skills/po-sprint/SKILL.md
@@ -8,6 +8,8 @@ description: Summarizes a sprint or a period for a Product Owner and stakeholder
 The reader is a Product Owner or a stakeholder: plain business language, in the user's language; ids and technical
 names only in brackets.
 
+First load the tools this needs: `ado_tools enable="boards;wiki"` (one call; skip it when they are already there).
+
 ## How is the sprint going
 
 1. `ado_sprint` (the team's current sprint; `sprint=next|previous|<name>` when asked). If the sprint has ended, say so
diff --git a/skills/po-story/SKILL.md b/skills/po-story/SKILL.md
index 1bfd2ff..0d5686f 100644
--- a/skills/po-story/SKILL.md
+++ b/skills/po-story/SKILL.md
@@ -8,6 +8,8 @@ description: Writes a work item for a Product Owner - a requirement (user story,
 The reader of the item is a developer and a tester; the writer is a Product Owner. Goal: after reading it, everyone
 knows what to do and how to check it — nothing more. Write in the language the user writes in.
 
+First load the tools this needs: `ado_tools enable="write"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. Find out what is needed — ask only what is missing, at most 3 short questions at once:
diff --git a/skills/po-test/SKILL.md b/skills/po-test/SKILL.md
index 6a1ab29..e75c4ae 100644
--- a/skills/po-test/SKILL.md
+++ b/skills/po-test/SKILL.md
@@ -7,6 +7,8 @@ description: Writes acceptance test cases from a work item's acceptance criteria
 
 Plain language, in the user's language; steps a business tester can follow on UAT.
 
+First load the tools this needs: `ado_tools enable="tests;code"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_work_item ids=<id>` — the acceptance criteria (from the parent for a task). No criteria: look at the
diff --git a/skills/po-verify/SKILL.md b/skills/po-verify/SKILL.md
index 4c0349f..769d824 100644
--- a/skills/po-verify/SKILL.md
+++ b/skills/po-verify/SKILL.md
@@ -8,6 +8,8 @@ description: Checks whether a work item was done as asked and where the change i
 The reader is a Product Owner, not a developer: answer in plain business language, in the language the user writes in.
 Technical names (objects, methods, files, ids of commits) only in brackets or when asked for "details".
 
+First load the tools this needs: `ado_tools enable="code;write"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. `ado_trace id=<id>` — what was asked (acceptance criteria), what code is linked, builds, where it is deployed, signals.
diff --git a/skills/po-wiki/SKILL.md b/skills/po-wiki/SKILL.md
index 2649e2e..517f380 100644
--- a/skills/po-wiki/SKILL.md
+++ b/skills/po-wiki/SKILL.md
@@ -8,6 +8,8 @@ description: Writes or updates a documentation page on the project wiki for a Pr
 Write for the people who will read the page (users, testers, new colleagues): plain language, in the language the
 wiki is written in (look at its other pages), short sections, examples.
 
+First load the tools this needs: `ado_tools enable="wiki;code;boards"` (one call; skip it when they are already there).
+
 ## Steps
 
 1. Facts first:
diff --git a/src/AdoLens/AdoLens.csproj b/src/AdoLens/AdoLens.csproj
index 5465e6f..31da1e3 100644
--- a/src/AdoLens/AdoLens.csproj
+++ b/src/AdoLens/AdoLens.csproj
@@ -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.7.3</Version>
+    <Version>0.8.0-beta.1</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/AdoLens/Cli.cs b/src/AdoLens/Cli.cs
index 22d041f..1466323 100644
--- a/src/AdoLens/Cli.cs
+++ b/src/AdoLens/Cli.cs
@@ -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  --add-toolset <set>  --remove-toolset <set>  --confirm-above <n>
+                            --show-tokens true|false  --load-all-tools true|false  --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,6 +323,11 @@ 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)
+            {
+                settings.LoadAllTools = bool.TryParse(la, out var b) ? b : throw new ArgumentException("--load-all-tools takes true or false");
+                changed = true;
+            }
             if (cl.Opt("confirm-above") is { } ca)
             {
                 settings.ConfirmBulkAbove = int.TryParse(ca, out var n) && n >= 0 ? n : throw new ArgumentException("--confirm-above takes a number (0 previews every update)");
@@ -336,7 +341,8 @@ public int Config()
         }
         if (changed) settings.Save(SettingsPath);
         Console.WriteLine($"settings: {SettingsPath}{(changed ? " (saved)" : "")}");
-        Console.WriteLine($"mode: {settings.Mode} (tool sets: {string.Join(", ", Toolsets.Active(settings).OrderBy(t => Array.IndexOf(Toolsets.All, t)))})");
+        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)"));
         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();
     }
@@ -743,6 +749,8 @@ 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")}"));
             var choice = Prompt(Ui.T("Choice (Enter = done): ", "Wybór (Enter = koniec): "));
             switch (choice?.Trim())
             {
@@ -782,6 +790,16 @@ async Task<int> SetupMenuAsync()
                     settings.Save(SettingsPath);
                     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 };
+                    settings.Save(SettingsPath);
+                    Console.WriteLine(Ui.T("  new Claude sessions use it", "  obowiązuje w nowych sesjach Claude'a"));
+                    break;
                 case "8":
                     var folder = Prompt(Ui.T("  folder for saved files ('default' = Downloads\\ADO Lens, Enter = keep): ",
                                              "  folder na pobrane pliki ('default' = Pobrane\\ADO Lens, Enter = bez zmian): "));
diff --git a/src/AdoLens/CommandLine.cs b/src/AdoLens/CommandLine.cs
index e96dc3f..621200b 100644
--- a/src/AdoLens/CommandLine.cs
+++ b/src/AdoLens/CommandLine.cs
@@ -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=", "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=", "load-all-tools=", "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="],
diff --git a/src/AdoLens/McpTools.cs b/src/AdoLens/McpTools.cs
index ab465ac..8bd5f20 100644
--- a/src/AdoLens/McpTools.cs
+++ b/src/AdoLens/McpTools.cs
@@ -16,16 +16,17 @@ public static class McpTools
     static readonly Dictionary<string, string> Lines = new()
     {
         [Toolsets.Core] = """
-            - Field names, values and states differ per process and company: check them with ado_fields before writing.
+            - Checking work against what was asked: ado_trace, then read the diffs with ado_changes - never assume.
+            - "How does X work": ado_search, then read the sources; say what comes from code and what from documentation.
             """,
-        [Toolsets.Work] = """
+        [Toolsets.Write] = """
+            - Field names, values and states differ per process and company: check them with ado_fields before writing.
             - ado_update on many items returns a preview: show it, then repeat the call with confirm.
             - Writing: short and complete - what to do or what was done, no filler. Requirement: goal in 1-2 sentences,
               scope as bullets, testable acceptance criteria in their own field. Bug: what happens, what should, numbered
               steps, where. Task: one sentence. Comment: decision or question first.
-            - "How does X work": ado_search, then read the sources; say what comes from code and what from documentation.
             """,
-        [Toolsets.Test] = """
+        [Toolsets.Tests] = """
             - Test Cases from acceptance criteria: one case per criterion, short steps with an expected result each; show them before creating.
             """,
         [Toolsets.Recipes] = """
@@ -34,8 +35,7 @@ public static class McpTools
         [Toolsets.Boards] = """
             - Say plainly when a sprint has ended or a column is over its WIP limit.
             """,
-        [Toolsets.Trace] = """
-            - Checking work against what was asked: ado_trace, then read the diffs with ado_changes - never assume.
+        [Toolsets.Code] = """
             - A branch's whole history: ado_file path=/ repo=<r> history=true version=<branch>.
             """,
         [Toolsets.Pr] = """
@@ -51,12 +51,21 @@ public static class McpTools
             """,
     };
 
+    const string Groups = """
+        - The core tools are loaded; the others come in groups: before using a tool that is not there, load its group with
+          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>
     public static string Instructions(Settings settings)
     {
-        var active = Toolsets.Active(settings);
-        return Intro + string.Concat(Lines.Where(l => active.Contains(l.Key)).Select(l => l.Value));
+        var loaded = Toolsets.Loaded(settings);
+        return Intro + (settings.LoadAllTools ? "" : Groups) + string.Concat(Lines.Where(l => loaded.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>
+    public static string? Hints(string group) => Lines.GetValueOrDefault(group)?.Trim();
+
     /// <summary>
     /// Field values as Claude sends them: an object whose values are text, numbers or booleans, or that object as a JSON
     /// string, or "Name=Value; Name2=Value2". A strict Dictionary&lt;string,string&gt; would reject {"Priority": 2} before the
@@ -138,6 +147,12 @@ internal static async Task<string> Run(string tool, object args, Func<Task<strin
 [McpServerToolType, Toolset(Toolsets.Core)]
 public static class CoreTools
 {
+    [McpServerTool(Name = "ado_tools")]
+    [Description("Loads a group of ADO Lens tools into this conversation: write (create/change/comment/link work items, fields), boards (sprint, board, backlog, metrics, release notes), wiki, code (changes, files, history, D365 labels, checks, attachments), tests, recipes, pr (pull requests), pipelines (builds, deployments, artifacts). Without enable: the groups and what is loaded.")]
+    public static Task<string> Tools(Lens lens, McpServer server,
+        [Description("Group(s) to load: write or \"write;boards\".")] string? enable = null)
+        => McpTools.Run("ado_tools", new { enable }, () => Task.FromResult(ToolGroups.Load(lens.Settings, server, enable)));
+
     [McpServerTool(Name = "ado_status", ReadOnly = true, Idempotent = true)]
     [Description("ADO Lens version, connection, signed-in user, PAT source and metadata age.")]
     public static Task<string> Status(Lens lens,
@@ -164,7 +179,7 @@ public static Task<string> Upgrade(Lens lens, bool install = false, Cancellation
             return failed ? throw new InvalidOperationException(text) : text;
         });
 
-    [McpServerTool(Name = "ado_fields", ReadOnly = true, Idempotent = true)]
+    [McpServerTool(Name = "ado_fields", ReadOnly = true, Idempotent = true), Toolset(Toolsets.Write)]
     [Description("Work item structure of the project: types by backlog level; with type: states, transitions, fields, required flags, allowed values; with field: one field across types; with changes: what changed in the structure.")]
     public static Task<string> Fields(Lens lens,
         [Description("Work item type, e.g. Bug or Product Backlog Item.")] string? type = null,
@@ -262,10 +277,10 @@ public static Task<string> MyDay(Lens lens,
             () => BoardQueries.MyDayAsync(lens, connection, project, since, null, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Trace)]
+[McpServerToolType, Toolset(Toolsets.Code)]
 public static class TraceTools
 {
-    [McpServerTool(Name = "ado_trace", ReadOnly = true, Idempotent = true)]
+    [McpServerTool(Name = "ado_trace", ReadOnly = true, Idempotent = true), Toolset(Toolsets.Core)]
     [Description("Was a work item done as asked and where is it: acceptance criteria and their changes, linked code (item and tasks), builds, each release stage YES / NOT YET, tests, signals.")]
     public static Task<string> Trace(Lens lens, int id,
         [Description("summary | normal | full.")] string? detail = null,
@@ -348,7 +363,7 @@ public static Task<string> Pr(Lens lens,
 public static class PrTools
 {
     [McpServerTool(Name = "ado_pr_update")]
-    [Description("Acts on pull requests: create (repo, source, target, title, text, workItems, reviewers, draft), comment (text, optional file and line), reply (thread, text), resolve (thread, status), vote (approve|suggestions|wait|reject|reset), tag (tags), publish, complete, abandon. @[name] in text notifies.")]
+    [Description("Pull request actions: create (repo, source, target, title, text, workItems, reviewers, draft), comment (text, file, line), reply (thread, text), resolve (thread, status), vote (approve|suggestions|wait|reject|reset), tag, publish, complete, abandon. @[name] notifies.")]
     public static Task<string> PrUpdate(Lens lens,
         string action,
         int? id = null,
@@ -365,7 +380,7 @@ public static Task<string> PrUpdate(Lens lens,
         [Description("Work item ids: 123;456.")] string? workItems = null,
         [Description("Names or e-mails separated by ';'.")] string? reviewers = null,
         bool draft = false,
-        [Description("For tag and create: 'a; b' adds, '-c' removes.")] string? tags = null,
+        [Description("'a; b' adds, '-c' removes.")] string? tags = null,
         bool deleteSourceBranch = false,
         [Description("noFastForward | squash | rebase | rebaseMerge.")] string? mergeStrategy = null,
         string? connection = null,
@@ -457,10 +472,10 @@ public static Task<string> WikiWrite(Lens lens,
             () => WikiQueries.WriteAsync(lens, connection, project, wiki, path, content, mode, version, comment, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Work)]
+[McpServerToolType, Toolset(Toolsets.Write)]
 public static class WorkTools
 {
-    [McpServerTool(Name = "ado_work_item", ReadOnly = true, Idempotent = true)]
+    [McpServerTool(Name = "ado_work_item", ReadOnly = true, Idempotent = true), Toolset(Toolsets.Core)]
     [Description("Work items by id: state, people, paths, filled fields, description and acceptance criteria as markdown, parent/children/related, linked code and builds.")]
     public static Task<string> WorkItem(Lens lens,
         [Description("One or more ids: 123 or 123;456.")] string ids,
@@ -471,7 +486,7 @@ public static Task<string> WorkItem(Lens lens,
         => McpTools.Run("ado_work_item", new { ids, include, detail, connection },
             () => WorkQueries.ItemAsync(lens, connection, ids, include, detail, ct));
 
-    [McpServerTool(Name = "ado_query", ReadOnly = true, Idempotent = true)]
+    [McpServerTool(Name = "ado_query", ReadOnly = true, Idempotent = true), Toolset(Toolsets.Core)]
     [Description("Work items found by WIQL or by a saved query (path like 'Shared Queries/Open bugs' or id), one line each.")]
     public static Task<string> Query(Lens lens,
         [Description("WIQL; use reference names from ado_fields. Macros like @Me and @CurrentIteration work.")] string? wiql = null,
@@ -496,8 +511,8 @@ public static Task<string> Create(Lens lens,
         string? area = null,
         [Description("Tags separated by ';'.")] string? tags = null,
         string? state = null,
-        [Description("Other fields by name or reference name: {\"Priority\": 2}.")] System.Text.Json.JsonElement? fields = null,
-        [Description("A team template (ado_fields type=… lists them) for the values not given.")] string? template = null,
+        [Description("Other fields by name: {\"Priority\": 2}.")] System.Text.Json.JsonElement? fields = null,
+        [Description("Team template for values not given (ado_fields type=… lists them).")] string? template = null,
         string? project = null,
         string? connection = null,
         CancellationToken ct = default)
@@ -509,7 +524,7 @@ public static Task<string> Create(Lens lens,
             }, ct));
 
     [McpServerTool(Name = "ado_update")]
-    [Description("Changes one or many work items (ids or WIQL): state only along the process transitions, people by name; several items are previewed first and written with confirm=<token from the preview>.")]
+    [Description("Changes work items (ids or WIQL): state along the process transitions, people by name; several items are previewed first, then written with confirm=<token>.")]
     public static Task<string> Update(Lens lens,
         [Description("Ids: 123 or 123;456.")] string? ids = null,
         [Description("WIQL selecting the items instead of ids.")] string? wiql = null,
@@ -522,8 +537,8 @@ public static Task<string> Update(Lens lens,
         [Description("Iteration path, 'current' or 'next'.")] string? iteration = null,
         string? area = null,
         [Description("'a; b' replaces, '+a; -b' adds and removes.")] string? tags = null,
-        [Description("Other fields by name or reference name; empty value clears.")] System.Text.Json.JsonElement? fields = null,
-        [Description("Markdown comment for each item, alone or with changes; @[name or e-mail] notifies a person.")] string? comment = null,
+        [Description("Other fields by name; empty value clears.")] System.Text.Json.JsonElement? fields = null,
+        [Description("Markdown comment for each item; @[name] notifies.")] string? comment = null,
         [Description("Token from the preview.")] string? confirm = null,
         string? connection = null,
         CancellationToken ct = default)
@@ -563,7 +578,7 @@ public static Task<string> CreateTree(Lens lens, string items,
         => McpTools.Run("ado_create_tree", new { parent, iteration, area, confirm, project, connection },
             () => WorkTree.CreateAsync(lens, connection, project, parent, items, iteration, area, confirm, ct));
 
-    [McpServerTool(Name = "ado_attachments")]
+    [McpServerTool(Name = "ado_attachments"), Toolset(Toolsets.Code)]
     [Description("Files of a work item and screenshots pasted into it: the list; file=<name or number> gives a document's text (PDF, Word, Excel, PowerPoint, e-mail, ZIP list, text) or shows images and scanned pages; save=true streams it to disk (any size) and returns the path; add=<local path> attaches a file.")]
     public static async Task<IEnumerable<ModelContextProtocol.Protocol.ContentBlock>> AttachmentsTool(Lens lens, int id,
         string? file = null,
@@ -589,7 +604,7 @@ public static Task<string> CreateTree(Lens lens, string items,
         return blocks;
     }
 
-    [McpServerTool(Name = "ado_search", ReadOnly = true, Idempotent = true)]
+    [McpServerTool(Name = "ado_search", ReadOnly = true, Idempotent = true), Toolset(Toolsets.Core)]
     [Description("One search over work items, wiki pages and code of the project, grouped - the start for \"how does X work\".")]
     public static Task<string> Search(Lens lens, string text,
         [Description("work;wiki;code (default all).")] string? scope = null,
@@ -606,7 +621,7 @@ public static Task<string> Undo(Lens lens, string? confirm = null, bool list = f
             () => list ? Task.FromResult(Audit.List(lens, connection, 10)) : Audit.UndoAsync(lens, connection, confirm, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Test)]
+[McpServerToolType, Toolset(Toolsets.Tests)]
 public static class TestTools
 {
     [McpServerTool(Name = "ado_tests", ReadOnly = true, Idempotent = true)]
diff --git a/src/AdoLens/Program.cs b/src/AdoLens/Program.cs
index a3b1fc1..4cee3f6 100644
--- a/src/AdoLens/Program.cs
+++ b/src/AdoLens/Program.cs
@@ -149,9 +149,9 @@ async Task<int> RunServerAsync()
     builder.Logging.AddConsole(o => o.LogToStandardErrorThreshold = LogLevel.Trace);
     builder.Logging.SetMinimumLevel(LogLevel.Warning);
 
-    var toolTypes = Toolsets.TypesFor(lens.Settings);
+    var startTools = Toolsets.Methods(Toolsets.Loaded(lens.Settings)).Select(Toolsets.ToolName).ToList();
     if (Environment.GetEnvironmentVariable("ADOLENS_VERBOSE") == "1")
-        Console.Error.WriteLine($"ado-lens: mode {lens.Settings.Mode}, tool classes: {string.Join(", ", toolTypes.Select(t => t.Name))}");
+        Console.Error.WriteLine($"ado-lens: mode {lens.Settings.Mode}, groups {string.Join(", ", Toolsets.Loaded(lens.Settings))}, tools: {string.Join(", ", startTools)}");
 
     builder.Services.AddSingleton(lens);
     builder.Services
diff --git a/src/AdoLens/Prompts.cs b/src/AdoLens/Prompts.cs
index 98631ee..401f07a 100644
--- a/src/AdoLens/Prompts.cs
+++ b/src/AdoLens/Prompts.cs
@@ -90,7 +90,7 @@ public static string Wiki([Description("What the page is about.")] string topic)
     [McpServerPrompt(Name = "label", Title = "Where does this message come from")]
     [Description("A D365 message pasted as seen on screen: its label, translations, and where and in which process it appears.")]
     public static string Label([Description("The message text as seen (values in it are fine).")] string text) =>
-        $"Use ado_label with this text, then read the method that shows it (ado_file part=<method>) and explain in plain language when the user sees this message and what to do about it.\n\nMessage: {text.Trim()}\nAnswer in the language of the message.";
+        $"Load the code tools if they are not there (ado_tools enable=code), then use ado_label with this text, then read the method that shows it (ado_file part=<method>) and explain in plain language when the user sees this message and what to do about it.\n\nMessage: {text.Trim()}\nAnswer in the language of the message.";
 }
 
 /// <summary>Prompts for developers: registered in the dev and full modes only.</summary>
diff --git a/src/AdoLens/Settings.cs b/src/AdoLens/Settings.cs
index 25125e5..3e6a3e2 100644
--- a/src/AdoLens/Settings.cs
+++ b/src/AdoLens/Settings.cs
@@ -49,6 +49,12 @@ 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; }
 
+    /// <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).
+    /// </summary>
+    public bool LoadAllTools { get; set; }
+
     /// <summary>Where files are saved (save=true); null: Downloads\ADO Lens.</summary>
     public string? DownloadDir { get; set; }
 
diff --git a/src/AdoLens/ToolGroups.cs b/src/AdoLens/ToolGroups.cs
new file mode 100644
index 0000000..2750bf0
--- /dev/null
+++ b/src/AdoLens/ToolGroups.cs
@@ -0,0 +1,59 @@
+using System.Text;
+using ModelContextProtocol.Server;
+
+namespace AdoLens;
+
+/// <summary>
+/// Loading tool groups during a conversation: the tools are added to the server's tool collection, which sends the
+/// client a tools/list_changed notification, and from then on Claude can call them. Each process serves one session,
+/// so what is loaded stays loaded for that conversation only.
+/// </summary>
+public static class ToolGroups
+{
+    public static string Load(Settings settings, McpServer server, string? enable)
+    {
+        var tools = server.ServerOptions.ToolCollection ?? throw new InvalidOperationException("this server has no tool collection");
+        var allowed = Toolsets.Active(settings);
+        var loaded = new HashSet<string>(Toolsets.Catalog().Where(c => tools.TryGetPrimitive(Toolsets.ToolName(c.Method), out _)).Select(c => c.Group),
+            StringComparer.OrdinalIgnoreCase);
+
+        if (string.IsNullOrWhiteSpace(enable))
+        {
+            var sb = new StringBuilder($"tool groups (mode {settings.Mode}):\n");
+            foreach (var g in Toolsets.All.Where(g => g != Toolsets.Core))
+            {
+                var state = loaded.Contains(g) ? "loaded" : allowed.Contains(g) ? "available" : "not in this mode";
+                sb.AppendLine($"- {g} ({state}): {Toolsets.About[g]}");
+            }
+            return sb.Append("enable=<group> loads one; enable=\"write;boards\" several.").ToString();
+        }
+
+        var result = new StringBuilder();
+        // One change notification for all the tools of the request, not one per tool.
+        using (tools.DeferChangedEvents())
+            foreach (var name in enable.Split([';', ',', ' '], StringSplitOptions.RemoveEmptyEntries))
+            {
+                if (Toolsets.TryNormalize(name) is not { } group || group == Toolsets.Core)
+                {
+                    result.AppendLine($"no group '{name}'; groups: {string.Join(", ", Toolsets.All.Where(g => g != Toolsets.Core))}");
+                    continue;
+                }
+                if (!allowed.Contains(group))
+                {
+                    result.AppendLine($"{group} is not part of the {settings.Mode} mode (change the mode in the ADO Lens settings to use it)");
+                    continue;
+                }
+                var added = new List<string>();
+                foreach (var method in Toolsets.Methods([group]))
+                {
+                    var tool = McpServerTool.Create(method, options: new McpServerToolCreateOptions { Services = server.Services });
+                    if (tools.TryAdd(tool)) added.Add(Toolsets.ToolName(method));
+                }
+                result.AppendLine(added.Count == 0
+                    ? $"{group}: already loaded"
+                    : $"{group} loaded: {string.Join(", ", added)}");
+                if (added.Count > 0 && McpTools.Hints(group) is { Length: > 0 } hints) result.AppendLine(hints);
+            }
+        return result.ToString().TrimEnd();
+    }
+}
diff --git a/src/AdoLens/Toolsets.cs b/src/AdoLens/Toolsets.cs
index cb3d5b6..b1a5fca 100644
--- a/src/AdoLens/Toolsets.cs
+++ b/src/AdoLens/Toolsets.cs
@@ -1,56 +1,100 @@
+using System.Reflection;
+using ModelContextProtocol.Server;
+
 namespace AdoLens;
 
-/// <summary>Marks a tool class with the tool set it belongs to.</summary>
-[AttributeUsage(AttributeTargets.Class)]
+/// <summary>Marks a tool class (or one tool method, which then overrides its class) with the group it belongs to.</summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
 public sealed class ToolsetAttribute(string name) : Attribute
 {
     public string Name { get; } = name;
 }
 
 /// <summary>
-/// Tool sets and modes. A mode is only a choice of which tools Claude sees (fewer tools: better choices and fewer
-/// tokens per session) — never a permission; the PAT decides what is allowed.
+/// Tool groups and modes. Every tool definition is paid in tokens in every session, so a session starts with the small
+/// core and Claude loads a group (ado_tools enable=…) when the conversation needs it. A mode only says which groups may
+/// be loaded - never a permission; the PAT decides what is allowed.
 /// </summary>
 public static class Toolsets
 {
-    public const string Core = "core", Work = "work", Boards = "boards", Wiki = "wiki", Trace = "trace", Code = "code",
-        Pr = "pr", Pipelines = "pipelines", Test = "test", Recipes = "recipes";
+    public const string Core = "core", Write = "write", Boards = "boards", Wiki = "wiki", Code = "code",
+        Tests = "tests", Recipes = "recipes", Pr = "pr", Pipelines = "pipelines";
+
+    public static readonly string[] All = [Core, Write, Boards, Wiki, Code, Tests, Recipes, Pr, Pipelines];
 
-    public static readonly string[] All = [Core, Work, Boards, Wiki, Trace, Code, Pr, Pipelines, Test, Recipes];
+    /// <summary>What a group is for, in one line (the ado_tools description and answer).</summary>
+    public static readonly Dictionary<string, string> About = new(StringComparer.OrdinalIgnoreCase)
+    {
+        [Write] = "create, change, comment, link, undo work items; fields and states of the process",
+        [Boards] = "sprint, board, backlog, my day, backlog health, metrics, release notes",
+        [Wiki] = "read, search and write wiki pages",
+        [Code] = "changes of a changeset/PR/commit, files and their history, D365 labels, checks before testing, attachments",
+        [Tests] = "test cases and their results",
+        [Recipes] = "saved repeatable changes",
+        [Pr] = "pull requests: lists, merged into a branch, details, create, comment, vote, tag, complete",
+        [Pipelines] = "builds, why they failed, deployments, artifacts, running a pipeline",
+    };
 
     public static readonly Dictionary<string, string[]> Modes = new(StringComparer.OrdinalIgnoreCase)
     {
-        ["po"] = [Core, Work, Boards, Wiki, Trace, Test, Recipes],
-        ["dev"] = [Core, Work, Wiki, Trace, Code, Pr, Pipelines, Recipes],
+        ["po"] = [Core, Write, Boards, Wiki, Code, Tests, Recipes],
+        ["dev"] = [Core, Write, Wiki, Code, Pr, Pipelines, Recipes],
         ["full"] = All,
     };
 
+    /// <summary>Old tool set names (before 0.8) still read from settings.</summary>
+    static readonly Dictionary<string, string> Renamed = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["work"] = Write, ["trace"] = Code, ["test"] = Tests,
+    };
+
+    /// <summary>The groups the mode allows (plus extra ones from the settings).</summary>
     public static HashSet<string> Active(Settings settings)
     {
         var set = new HashSet<string>(Modes.GetValueOrDefault(settings.Mode) ?? Modes["po"], StringComparer.OrdinalIgnoreCase);
-        set.UnionWith(settings.ExtraToolsets);
+        foreach (var extra in settings.ExtraToolsets)
+            if (TryNormalize(extra) is { } n) set.Add(n);
         set.Add(Core);
         return set;
     }
 
-    /// <summary>Tool classes of the active tool sets.</summary>
-    public static List<Type> TypesFor(Settings settings)
+    /// <summary>The groups a session starts with: only the core, or every allowed group when the settings say so.</summary>
+    public static HashSet<string> Loaded(Settings settings) =>
+        settings.LoadAllTools ? Active(settings) : new HashSet<string>([Core], StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>Every tool method with its group: the method's own attribute, else its class's.</summary>
+    public static IEnumerable<(string Group, MethodInfo Method)> Catalog() =>
+        typeof(Toolsets).Assembly.GetTypes()
+            .Where(t => t.GetCustomAttribute<McpServerToolTypeAttribute>() is not null)
+            .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .Where(m => m.GetCustomAttribute<McpServerToolAttribute>() is not null)
+                .Select(m => ((m.GetCustomAttribute<ToolsetAttribute>() ?? t.GetCustomAttribute<ToolsetAttribute>())?.Name ?? Core, m)));
+
+    public static IEnumerable<MethodInfo> Methods(IEnumerable<string> groups)
     {
-        var active = Active(settings);
-        return typeof(Toolsets).Assembly.GetTypes()
-            .Where(t => t.GetCustomAttributes(typeof(ToolsetAttribute), false) is [ToolsetAttribute a] && active.Contains(a.Name))
-            .ToList();
+        var set = new HashSet<string>(groups, StringComparer.OrdinalIgnoreCase);
+        return Catalog().Where(c => set.Contains(c.Group)).Select(c => c.Method);
     }
 
-    /// <summary>
-    /// Registers the tools of the active tool sets. The cast matters: a List&lt;Type&gt; would bind to the generic
-    /// WithTools&lt;T&gt;(target) overload and register the list's own (no) methods.
-    /// </summary>
+    public static string ToolName(MethodInfo m) => m.GetCustomAttribute<McpServerToolAttribute>()?.Name ?? m.Name;
+
+    /// <summary>Registers the tools a session starts with.</summary>
     public static Microsoft.Extensions.DependencyInjection.IMcpServerBuilder WithActiveTools(
-        this Microsoft.Extensions.DependencyInjection.IMcpServerBuilder builder, Settings settings) =>
-        Microsoft.Extensions.DependencyInjection.McpServerBuilderExtensions.WithTools(builder, (IEnumerable<Type>)TypesFor(settings));
+        this Microsoft.Extensions.DependencyInjection.IMcpServerBuilder builder, Settings settings)
+    {
+        foreach (var method in Methods(Loaded(settings)))
+            Microsoft.Extensions.DependencyInjection.ServiceCollectionServiceExtensions.AddSingleton(builder.Services,
+                sp => McpServerTool.Create(method, options: new McpServerToolCreateOptions { Services = sp }));
+        return builder;
+    }
+
+    public static string? TryNormalize(string name)
+    {
+        var n = name.Trim();
+        if (Renamed.TryGetValue(n, out var renamed)) return renamed;
+        return All.FirstOrDefault(t => t.Equals(n, StringComparison.OrdinalIgnoreCase));
+    }
 
     public static string Normalize(string name) =>
-        All.FirstOrDefault(t => t.Equals(name.Trim(), StringComparison.OrdinalIgnoreCase))
-        ?? throw new ArgumentException($"unknown tool set '{name}' (known: {string.Join(", ", All)})");
+        TryNormalize(name) ?? throw new ArgumentException($"unknown tool group '{name}' (known: {string.Join(", ", All)})");
 }
diff --git a/tests/AdoLens.Tests/SetupTests.cs b/tests/AdoLens.Tests/SetupTests.cs
index 04b3d4b..b20b01d 100644
--- a/tests/AdoLens.Tests/SetupTests.cs
+++ b/tests/AdoLens.Tests/SetupTests.cs
@@ -269,11 +269,13 @@ static List<McpServerTool> RegisteredTools(Settings settings)
     /// Raise the limit on purpose when new tools need it.
     /// </summary>
     [Theory]
-    [InlineData("po", 8000)]
-    [InlineData("dev", 8000)]
-    public void Tool_definitions_do_not_grow_by_accident(string mode, int maxTokens)
+    [InlineData("po", false, 3000)]
+    [InlineData("po", true, 8000)]
+    [InlineData("dev", true, 8000)]
+    [InlineData("full", true, 9000)]
+    public void Tool_definitions_do_not_grow_by_accident(string mode, bool loadAll, int maxTokens)
     {
-        var settings = new Settings { Mode = mode };
+        var settings = new Settings { Mode = mode, LoadAllTools = loadAll };
         // What a client gets per tool: its name, description and input schema (plus a few annotation flags).
         var chars = McpTools.Instructions(settings).Length
                     + RegisteredTools(settings).Sum(t => t.ProtocolTool.Name.Length + (t.ProtocolTool.Description?.Length ?? 0)
@@ -283,26 +285,47 @@ public void Tool_definitions_do_not_grow_by_accident(string mode, int maxTokens)
         Assert.True(chars / 4 < maxTokens, $"mode {mode}: tool definitions take ~{chars / 4} tokens ({chars} characters): {detail}");
     }
 
+    [Fact]
+    public void A_session_starts_with_the_core_and_loads_groups_on_demand()
+    {
+        Assert.Equal(["ado_query", "ado_search", "ado_settings", "ado_status", "ado_tools", "ado_trace", "ado_upgrade", "ado_work_item"],
+            RegisteredTools(new Settings { Mode = "po" }).Select(t => t.ProtocolTool.Name).Order().ToList());
+        Assert.Contains("ado_tools enable=", McpTools.Instructions(new Settings { Mode = "po" }));
+        Assert.DoesNotContain("ado_tools enable=", McpTools.Instructions(new Settings { Mode = "po", LoadAllTools = true }));
+    }
+
     [Fact]
     public void The_server_really_registers_the_tools_of_the_mode()
     {
-        var names = RegisteredTools(new Settings { Mode = "po" }).Select(t => t.ProtocolTool.Name).Order().ToList();
+        var names = RegisteredTools(new Settings { Mode = "po", LoadAllTools = true }).Select(t => t.ProtocolTool.Name).Order().ToList();
         Assert.Equal(["ado_attachments", "ado_backlog", "ado_board", "ado_changes", "ado_comment", "ado_create", "ado_create_tree", "ado_fields", "ado_file", "ado_health", "ado_label", "ado_link", "ado_metrics", "ado_my_day",
             "ado_query", "ado_recipe", "ado_release_notes", "ado_review", "ado_search", "ado_settings", "ado_sprint", "ado_status", "ado_test_create", "ado_tests",
-            "ado_trace", "ado_undo", "ado_update",
+            "ado_tools", "ado_trace", "ado_undo", "ado_update",
             "ado_upgrade", "ado_wiki", "ado_wiki_write", "ado_work_item"], names);
+        Assert.Contains("ado_pr", RegisteredTools(new Settings { Mode = "dev", LoadAllTools = true }).Select(t => t.ProtocolTool.Name));
+    }
+
+    [Fact]
+    public void Every_tool_is_in_a_known_group_and_every_group_has_tools()
+    {
+        var catalog = Toolsets.Catalog().ToList();
+        Assert.All(catalog, c => Assert.Contains(c.Group, Toolsets.All));
+        Assert.All(Toolsets.All, g => Assert.Contains(catalog, c => c.Group == g));
+        Assert.Equal(catalog.Count, catalog.Select(c => Toolsets.ToolName(c.Method)).Distinct().Count());
+        Assert.All(Toolsets.All.Where(g => g != Toolsets.Core), g => Assert.True(Toolsets.About.ContainsKey(g), g));
     }
 
     [Fact]
     public void Modes_choose_tool_sets_and_extras_are_added()
     {
         var po = Toolsets.Active(new Settings { Mode = "po" });
-        var devPlus = Toolsets.Active(new Settings { Mode = "dev", ExtraToolsets = ["boards"] });
+        var devPlus = Toolsets.Active(new Settings { Mode = "dev", ExtraToolsets = ["boards", "test"] });
         Assert.Contains(Toolsets.Boards, po);
         Assert.DoesNotContain(Toolsets.Pr, po);
+        Assert.DoesNotContain(Toolsets.Pipelines, po);
         Assert.Contains(Toolsets.Boards, devPlus);
-        Assert.Contains(typeof(CoreTools), Toolsets.TypesFor(new Settings { Mode = "po" }));
-        Assert.Contains(typeof(WorkTools), Toolsets.TypesFor(new Settings { Mode = "dev" }));
+        Assert.Contains(Toolsets.Tests, devPlus); // the name before 0.8
+        Assert.Equal(Toolsets.Write, Toolsets.Normalize("work"));
+        Assert.Equal([Toolsets.Core], Toolsets.Loaded(new Settings { Mode = "full" }));
     }
 }
-

From f3c95e119f17a5b65f173a3c45288222fc172b50 Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Fri, 16 Oct 2026 15:04:58 +0200
Subject: [PATCH 3/4] ADO Lens 0.8.0-beta.1 (test release)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fewer tokens in every session: about 1.3k 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.
- 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
  PR lists, details and merged PRs.
- Product Owner mode: no pull request or pipeline tools and no developer prompts (`dev_*`); they stay in the dev and
  full modes.
---
 packaging/inno/ado-lens.iss | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packaging/inno/ado-lens.iss b/packaging/inno/ado-lens.iss
index 24b5832..f364d55 100644
--- a/packaging/inno/ado-lens.iss
+++ b/packaging/inno/ado-lens.iss
@@ -14,6 +14,8 @@
 #ifndef OutDir
   #define OutDir "..\..\dist"
 #endif
+; The file version is numbers only: 0.8.0 for a test release 0.8.0-beta.1.
+#define FileVersion Copy(Version, 1, Pos("-", Version + "-") - 1)
 
 [Setup]
 AppId={{6F1C2B9E-4D7A-4E21-9B8C-3A5D0E7F1A42}
@@ -45,7 +47,7 @@ LicenseFile={#Source}\LICENSE
 ; Users choose: Polish or English (the choice is kept for the settings console too).
 ShowLanguageDialog=yes
 CloseApplications=no
-VersionInfoVersion={#Version}
+VersionInfoVersion={#FileVersion}
 
 [Languages]
 Name: "en"; MessagesFile: "compiler:Default.isl"

From 6fc174ba8e2eb19edb9c1cf5c33b968b398aa4bb Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Sun, 18 Oct 2026 22:38:26 +0200
Subject: [PATCH 4/4] ADO Lens 0.8.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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 --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
  PR lists, details and merged PRs.
- Product Owner mode: no pull request or pipeline tools and no developer prompts (`dev_*`); they stay in the dev and
  full modes.
---
 CHANGELOG.md                      |  9 +++++----
 README.md                         | 14 +++++++++-----
 README.pl.md                      | 14 +++++++++-----
 src/AdoLens/AdoLens.csproj        |  2 +-
 src/AdoLens/Cli.cs                | 30 ++++++++++++++++++------------
 src/AdoLens/CommandLine.cs        |  2 +-
 src/AdoLens/McpTools.cs           |  9 ++++++---
 src/AdoLens/Program.cs            |  5 +++++
 src/AdoLens/Settings.cs           | 16 +++++++++++++---
 src/AdoLens/ToolGroups.cs         | 22 ++++++++++++++++++++++
 src/AdoLens/Toolsets.cs           |  7 +++++--
 tests/AdoLens.Tests/SetupTests.cs | 24 +++++++++++++++---------
 12 files changed, 109 insertions(+), 45 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d01d8da..47045ea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -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
diff --git a/README.md b/README.md
index 3c8e2a4..70f96f5 100644
--- a/README.md
+++ b/README.md
@@ -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
 
diff --git a/README.pl.md b/README.pl.md
index d6e9c77..d16313f 100644
--- a/README.pl.md
+++ b/README.pl.md
@@ -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
 
diff --git a/src/AdoLens/AdoLens.csproj b/src/AdoLens/AdoLens.csproj
index 31da1e3..56b0a77 100644
--- a/src/AdoLens/AdoLens.csproj
+++ b/src/AdoLens/AdoLens.csproj
@@ -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>
diff --git a/src/AdoLens/Cli.cs b/src/AdoLens/Cli.cs
index 1466323..da20e41 100644
--- a/src/AdoLens/Cli.cs
+++ b/src/AdoLens/Cli.cs
@@ -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;
diff --git a/src/AdoLens/CommandLine.cs b/src/AdoLens/CommandLine.cs
index 621200b..6067b3a 100644
--- a/src/AdoLens/CommandLine.cs
+++ b/src/AdoLens/CommandLine.cs
@@ -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="],
diff --git a/src/AdoLens/McpTools.cs b/src/AdoLens/McpTools.cs
index 8bd5f20..4203c1a 100644
--- a/src/AdoLens/McpTools.cs
+++ b/src/AdoLens/McpTools.cs
@@ -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>
diff --git a/src/AdoLens/Program.cs b/src/AdoLens/Program.cs
index 4cee3f6..0118fc3 100644
--- a/src/AdoLens/Program.cs
+++ b/src/AdoLens/Program.cs
@@ -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;
diff --git a/src/AdoLens/Settings.cs b/src/AdoLens/Settings.cs
index 3e6a3e2..5680b4d 100644
--- a/src/AdoLens/Settings.cs
+++ b/src/AdoLens/Settings.cs
@@ -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; }
diff --git a/src/AdoLens/ToolGroups.cs b/src/AdoLens/ToolGroups.cs
index 2750bf0..71d3d05 100644
--- a/src/AdoLens/ToolGroups.cs
+++ b/src/AdoLens/ToolGroups.cs
@@ -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");
diff --git a/src/AdoLens/Toolsets.cs b/src/AdoLens/Toolsets.cs
index b1a5fca..d9d57b1 100644
--- a/src/AdoLens/Toolsets.cs
+++ b/src/AdoLens/Toolsets.cs
@@ -58,9 +58,12 @@ public static HashSet<string> Active(Settings settings)
         return set;
     }
 
-    /// <summary>The groups a session starts with: only the core, or every allowed group when the settings say so.</summary>
+    /// <summary>
+    /// The groups a session starts with: the core, or every allowed group with ToolLoading=all. With auto the rest is
+    /// added before the first tool list for a client that does not take new tools (see <see cref="ToolGroups.ForClient"/>).
+    /// </summary>
     public static HashSet<string> Loaded(Settings settings) =>
-        settings.LoadAllTools ? Active(settings) : new HashSet<string>([Core], StringComparer.OrdinalIgnoreCase);
+        settings.ToolLoading == "all" ? Active(settings) : new HashSet<string>([Core], StringComparer.OrdinalIgnoreCase);
 
     /// <summary>Every tool method with its group: the method's own attribute, else its class's.</summary>
     public static IEnumerable<(string Group, MethodInfo Method)> Catalog() =>
diff --git a/tests/AdoLens.Tests/SetupTests.cs b/tests/AdoLens.Tests/SetupTests.cs
index b20b01d..23b9df7 100644
--- a/tests/AdoLens.Tests/SetupTests.cs
+++ b/tests/AdoLens.Tests/SetupTests.cs
@@ -269,13 +269,14 @@ static List<McpServerTool> RegisteredTools(Settings settings)
     /// Raise the limit on purpose when new tools need it.
     /// </summary>
     [Theory]
-    [InlineData("po", false, 3000)]
-    [InlineData("po", true, 8000)]
-    [InlineData("dev", true, 8000)]
-    [InlineData("full", true, 9000)]
-    public void Tool_definitions_do_not_grow_by_accident(string mode, bool loadAll, int maxTokens)
+    [InlineData("po", "demand", 2000)]
+    [InlineData("full", "auto", 3000)]
+    [InlineData("po", "all", 8000)]
+    [InlineData("dev", "all", 8000)]
+    [InlineData("full", "all", 9000)]
+    public void Tool_definitions_do_not_grow_by_accident(string mode, string loading, int maxTokens)
     {
-        var settings = new Settings { Mode = mode, LoadAllTools = loadAll };
+        var settings = new Settings { Mode = mode, ToolLoading = loading };
         // What a client gets per tool: its name, description and input schema (plus a few annotation flags).
         var chars = McpTools.Instructions(settings).Length
                     + RegisteredTools(settings).Sum(t => t.ProtocolTool.Name.Length + (t.ProtocolTool.Description?.Length ?? 0)
@@ -291,18 +292,23 @@ public void A_session_starts_with_the_core_and_loads_groups_on_demand()
         Assert.Equal(["ado_query", "ado_search", "ado_settings", "ado_status", "ado_tools", "ado_trace", "ado_upgrade", "ado_work_item"],
             RegisteredTools(new Settings { Mode = "po" }).Select(t => t.ProtocolTool.Name).Order().ToList());
         Assert.Contains("ado_tools enable=", McpTools.Instructions(new Settings { Mode = "po" }));
-        Assert.DoesNotContain("ado_tools enable=", McpTools.Instructions(new Settings { Mode = "po", LoadAllTools = true }));
+        Assert.DoesNotContain("ado_tools enable=", McpTools.Instructions(new Settings { Mode = "po", ToolLoading = "all" }));
+        Assert.True(ToolGroups.TakesNewTools("claude-code"));
+        Assert.False(ToolGroups.TakesNewTools("claude-ai"));
+        Assert.False(ToolGroups.TakesNewTools(null));
+        Assert.Equal("demand", Settings.NormalizeToolLoading("on-demand"));
+        Assert.Equal("auto", new Settings().ToolLoading);
     }
 
     [Fact]
     public void The_server_really_registers_the_tools_of_the_mode()
     {
-        var names = RegisteredTools(new Settings { Mode = "po", LoadAllTools = true }).Select(t => t.ProtocolTool.Name).Order().ToList();
+        var names = RegisteredTools(new Settings { Mode = "po", ToolLoading = "all" }).Select(t => t.ProtocolTool.Name).Order().ToList();
         Assert.Equal(["ado_attachments", "ado_backlog", "ado_board", "ado_changes", "ado_comment", "ado_create", "ado_create_tree", "ado_fields", "ado_file", "ado_health", "ado_label", "ado_link", "ado_metrics", "ado_my_day",
             "ado_query", "ado_recipe", "ado_release_notes", "ado_review", "ado_search", "ado_settings", "ado_sprint", "ado_status", "ado_test_create", "ado_tests",
             "ado_tools", "ado_trace", "ado_undo", "ado_update",
             "ado_upgrade", "ado_wiki", "ado_wiki_write", "ado_work_item"], names);
-        Assert.Contains("ado_pr", RegisteredTools(new Settings { Mode = "dev", LoadAllTools = true }).Select(t => t.ProtocolTool.Name));
+        Assert.Contains("ado_pr", RegisteredTools(new Settings { Mode = "dev", ToolLoading = "all" }).Select(t => t.ProtocolTool.Name));
     }
 
     [Fact]