From 430f1a8c0913e404526c7aa47e091f72ff97d184 Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Fri, 16 Oct 2026 14:30:27 +0200
Subject: [PATCH 1/2] PR and pipeline reading in every mode, work items of a
 change, faster trace, history of a branch, clearer environment map

---
 CHANGELOG.md                           | 14 ++++
 README.md                              |  6 +-
 README.pl.md                           |  6 +-
 src/AdoLens/Knowledge.cs               | 17 +++++
 src/AdoLens/McpTools.cs                | 21 ++++--
 src/AdoLens/Queries.cs                 | 10 ++-
 src/AdoLens/Trace.cs                   | 91 +++++++++++++++++---------
 tests/AdoLens.Tests/KnowledgeTests.cs  |  9 +++
 tests/AdoLens.Tests/PrPipelineTests.cs |  2 +-
 tests/AdoLens.Tests/SetupFlowTests.cs  |  2 +-
 tests/AdoLens.Tests/SetupTests.cs      |  2 +-
 tests/AdoLens.Tests/TraceTests.cs      |  4 +-
 12 files changed, 134 insertions(+), 50 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c79c593..f017607 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.7.3 — unreleased
+
+Fixes from a real question: "pull requests merged into staging after release X, with their work items and tags".
+
+- `ado_pr` and `ado_pipeline` (reading: pull request lists and details, merged PRs, builds, deployments, artifacts) are
+  in every mode now, the Product Owner one too; creating and completing PRs and running pipelines stay for developers.
+- `ado_changes` of a pull request, changeset or commit lists its work items with type, state and tags.
+- `ado_trace` checks the release stages in parallel and skips deployments older than the change: it no longer runs
+  out of time on items with several pull requests.
+- `ado_file path=/ repo=<r> history=true version=<branch>`: the history of a whole repository or folder on a branch,
+  with pull requests and work items. An environment name given as the branch ("sbx03") is turned into its branch.
+- The environment map reads "UAT (sbx03) = branch staging" instead of "UAT (sbx03) [staging]".
+- The server instructions name the tools for "what went into a branch or an environment".
+
 ## 0.7.2 — 2026-10-16
 
 - `ado_pr merged=<branch>` (`adolens pr --merged staging --since 7d`): pull requests completed into a branch, newest
diff --git a/README.md b/README.md
index 1d2debe..728c8c2 100644
--- a/README.md
+++ b/README.md
@@ -177,11 +177,11 @@ never a permission.
 |---|---|:-:|:-:|:-:|
 | `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`, `ado_pr_update` | – | ✓ | ✓ |
-| `pipelines` | `ado_pipeline`, `ado_pipeline_run` | – | ✓ | ✓ |
+| `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` | ✓ | – | ✓ |
 | `wiki` | `ado_wiki`, `ado_wiki_write` | ✓ | ✓ | ✓ |
-| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review` | ✓ | ✓ | ✓ |
+| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_pr`, `ado_pipeline` | ✓ | ✓ | ✓ |
 | `recipes` | `ado_recipe` | ✓ | ✓ | ✓ |
 | `test` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
 | `test`, `recipes` | planned | ✓ | (recipes) | ✓ |
diff --git a/README.pl.md b/README.pl.md
index 33afb9f..fa1fc64 100644
--- a/README.pl.md
+++ b/README.pl.md
@@ -178,11 +178,11 @@ Nigdy nie jest uprawnieniem.
 |---|---|:-:|:-:|:-:|
 | `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`, `ado_pr_update` | – | ✓ | ✓ |
-| `pipelines` | `ado_pipeline`, `ado_pipeline_run` | – | ✓ | ✓ |
+| `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` | ✓ | – | ✓ |
 | `wiki` | `ado_wiki`, `ado_wiki_write` | ✓ | ✓ | ✓ |
-| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review` | ✓ | ✓ | ✓ |
+| `trace` | `ado_trace`, `ado_changes`, `ado_file`, `ado_label`, `ado_review`, `ado_pr`, `ado_pipeline` | ✓ | ✓ | ✓ |
 | `recipes` | `ado_recipe` | ✓ | ✓ | ✓ |
 | `test` | `ado_tests`, `ado_test_create` | ✓ | – | ✓ |
 | `test`, `recipes` | w planie | ✓ | (recipes) | ✓ |
diff --git a/src/AdoLens/Knowledge.cs b/src/AdoLens/Knowledge.cs
index 895ab29..bd10ce7 100644
--- a/src/AdoLens/Knowledge.cs
+++ b/src/AdoLens/Knowledge.cs
@@ -151,6 +151,18 @@ sealed record FileRef(bool Tfvc, string Path, string? RepoId, string? RepoName,
     {
         path = path.Trim().Replace('\\', '/');
         if (path.StartsWith("$/", StringComparison.Ordinal)) return (new FileRef(true, path, null, null, project), null);
+        // The whole repository ("/") or a folder ("src/"): no file search, the repository is needed.
+        if (path == "/" || path.EndsWith('/'))
+        {
+            if (repo is not null)
+            {
+                var r = await session.Code.RepoAsync(repo, project, ct);
+                return (new FileRef(false, "/" + path.Trim('/'), r.Id, r.Name, r.Project ?? project), null);
+            }
+            var all = await session.Client.GetListAsync($"{AdoClient.Scope(project)}_apis/git/repositories", ct);
+            if (all.Count == 1) return (new FileRef(false, "/" + path.Trim('/'), Json.Str(all[0], "id"), Json.Str(all[0], "name"), project), null);
+            return (null, $"{path} is a folder: give repo=<name> ({string.Join(", ", all.Select(x => Json.Str(x, "name")).Take(30))})");
+        }
         if (repo is not null && path.Contains('/'))
         {
             var r = await session.Code.RepoAsync(repo, project, ct);
@@ -190,7 +202,12 @@ public static async Task<string> FileAsync(Lens lens, string? connection, string
         var name = session.Project(project);
         var (file, choices) = await ResolveAsync(session, name, path, repo, ct);
         if (file is null) return choices!;
+        // An environment name ("sbx03", "UAT") instead of a branch: the branch of the environment map.
+        if (version is not null && session.Config.Environments.FirstOrDefault(e => !e.Key.Contains('/') &&
+                (e.Value.Equals(version, StringComparison.OrdinalIgnoreCase) || e.Value.Contains(version, StringComparison.OrdinalIgnoreCase))) is { Key: { } branch })
+            version = branch;
         if (history) return await HistoryAsync(session, file, version, top, ct);
+        if (path.Trim() == "/" || path.TrimEnd().EndsWith('/')) return $"{path} is a folder: history=true lists its changes";
 
         string? text;
         string where;
diff --git a/src/AdoLens/McpTools.cs b/src/AdoLens/McpTools.cs
index 80727e4..c0ea5a2 100644
--- a/src/AdoLens/McpTools.cs
+++ b/src/AdoLens/McpTools.cs
@@ -36,6 +36,8 @@ 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>.
             """,
         [Toolsets.Pr] = """
             - PR description: what and why with the work item, changes as bullets by area, how to check, risks only if any.
@@ -317,8 +319,9 @@ public static Task<string> ReadFile(Lens lens, string path,
             () => Knowledge.FileAsync(lens, connection, project, path, repo, version, part, history, top, detail, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Pr)]
-public static class PrTools
+// Reading pull requests and builds is part of checking work (PO mode too); changing them is for developers.
+[McpServerToolType, Toolset(Toolsets.Trace)]
+public static class PrReadTools
 {
     [McpServerTool(Name = "ado_pr", ReadOnly = true, Idempotent = true)]
     [Description("Pull requests: without id the ones waiting for my review and mine (list=active: all active); merged=<branch>: those completed into a branch (since, top), with their work items; with id: status, reviewers and votes, checks, work items, open comment threads.")]
@@ -338,6 +341,11 @@ public static Task<string> Pr(Lens lens,
                 : merged is not null ? PullRequestQueries.MergedAsync(lens, connection, project, merged, repo, since, top, ct)
                 : PullRequestQueries.ListAsync(lens, connection, project, list, ct));
 
+}
+
+[McpServerToolType, Toolset(Toolsets.Pr)]
+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.")]
     public static Task<string> PrUpdate(Lens lens,
@@ -369,8 +377,8 @@ public static Task<string> PrUpdate(Lens lens,
             }, ct));
 }
 
-[McpServerToolType, Toolset(Toolsets.Pipelines)]
-public static class PipelineTools
+[McpServerToolType, Toolset(Toolsets.Trace)]
+public static class PipelineReadTools
 {
     [McpServerTool(Name = "ado_pipeline", ReadOnly = true, Idempotent = true)]
     [Description("Builds: recent runs (optionally of one pipeline or branch); with build: why it failed - failed steps, errors and the error lines of the log; artifacts=true lists its artifacts, artifact=<name> its files (part=<file> reads one, save=true saves it to disk); deployments=true: recent release deployments (definition, stage) with dates.")]
@@ -396,6 +404,11 @@ public static Task<string> Pipeline(Lens lens,
                   : PipelineQueries.BuildAsync(lens, connection, project, b, detail, ct)
                 : PipelineQueries.ListAsync(lens, connection, project, definition, branch, top, ct));
 
+}
+
+[McpServerToolType, Toolset(Toolsets.Pipelines)]
+public static class PipelineTools
+{
     [McpServerTool(Name = "ado_pipeline_run")]
     [Description("Queues a run of a pipeline, optionally on a branch.")]
     public static Task<string> Run(Lens lens,
diff --git a/src/AdoLens/Queries.cs b/src/AdoLens/Queries.cs
index 876627b..b214b4c 100644
--- a/src/AdoLens/Queries.cs
+++ b/src/AdoLens/Queries.cs
@@ -62,7 +62,7 @@ public static string SettingsAnswer(Lens lens, string? connection, string? envir
         var sb = new StringBuilder(environments is null ? "" : "saved.\n");
         sb.AppendLine($"connection {cfg.Connection}: https://dev.azure.com/{conn.Organization}, project {conn.Project ?? "-"}, team {conn.Team ?? "-"}, mode {lens.Settings.Mode}");
         sb.Append(conn.Environments.Count == 0 ? "local environments: not set"
-            : "environments (in flow order): " + string.Join(" -> ", conn.Environments.Select(e => $"{e.Value} [{e.Key}]")));
+            : "environments (in flow order): " + string.Join(" -> ", conn.Environments.Select(e => Flow(e.Key, e.Value))));
         return sb.ToString();
     }
 
@@ -85,7 +85,7 @@ public static async Task<string> SettingsAsync(Lens lens, string? connection, st
             var map = ParseEnvironments(environments);
             var url = await session.Team.SaveAsync(name, map, ct);
             return $"saved for the whole team on the wiki page \"{TeamSettings.PagePath}\" of {name}: " +
-                   string.Join(" -> ", map.Select(e => $"{e.Value} [{e.Key}]")) + $"\n{url}";
+                   string.Join(" -> ", map.Select(e => Flow(e.Key, e.Value))) + $"\n{url}";
         }
         var text = SettingsAnswer(lens, connection, environments);
         if (environments is not null) return text;
@@ -94,7 +94,7 @@ public static async Task<string> SettingsAsync(Lens lens, string? connection, st
         var p = s.Project(project);
         var (effective, source) = await EnvironmentFlow.EffectiveAsync(s, p, ct);
         if (effective.Count > 0)
-            return text + $"\nin use for {p} ({source}): " + string.Join(" -> ", effective.Select(e => $"{e.Value} [{e.Key}]"));
+            return text + $"\nin use for {p} ({source}): " + string.Join(" -> ", effective.Select(e => Flow(e.Key, e.Value)));
         var detected = await EnvironmentFlow.DetectAsync(s, p, ct);
         return text + (detected.Count == 0
             ? $"\nno release stages or long-lived branches found in {p}"
@@ -103,6 +103,10 @@ public static async Task<string> SettingsAsync(Lens lens, string? connection, st
               "(scope=team for everyone, after the user agrees).");
     }
 
+    /// <summary>"UAT (sbx03) = branch staging", "UAT + SCM = release stage Main-Deploy/Stage 1": the name, then what it is.</summary>
+    internal static string Flow(string key, string name) =>
+        $"{name} = {(key.Contains('/') ? "release stage" : "branch")} {key}";
+
     static Dictionary<string, string> ParseEnvironments(string environments)
     {
         var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
diff --git a/src/AdoLens/Trace.cs b/src/AdoLens/Trace.cs
index 5b250d7..13e603a 100644
--- a/src/AdoLens/Trace.cs
+++ b/src/AdoLens/Trace.cs
@@ -206,25 +206,21 @@ string Label(string? branch, string def, string stage) =>
         var anyIn = false;
         // Git: a stage has the work when any of its changes (a PR merge, a commit) is in what was deployed. Changes that
         // are not there yet are named, unless a later change from the same source branch already is (it carries them).
-        var containsCache = new Dictionary<(string, string, bool), bool?>();
-        async Task<bool?> Contains(string repo, string commit, string target, bool isBranch)
-        {
-            if (!containsCache.TryGetValue((commit, target, isBranch), out var r))
-                containsCache[(commit, target, isBranch)] = r = await code.ContainsAsync(repo, commit, target, isBranch, ct);
-            return r;
-        }
-        async Task<(List<CodeChange> In, List<CodeChange> NotYet, bool Known)> GitStatus(string repo, string target, bool isBranch)
+        // Each answer is one Azure DevOps call: asked once, all at the same time (a sequential walk timed out on items
+        // with several PRs and many release stages).
+        var containsCache = new System.Collections.Concurrent.ConcurrentDictionary<(string, string, bool), Task<bool?>>();
+        Task<bool?> Contains(string repo, string commit, string target, bool isBranch) =>
+            containsCache.GetOrAdd((commit, target, isBranch), _ => code.ContainsAsync(repo, commit, target, isBranch, ct));
+        async Task<(List<CodeChange> In, List<CodeChange> NotYet, bool Known)> GitStatus(string repo, string target, bool isBranch, DateTime? deployedAt)
         {
             var git = changes.Select(x => x.Change).Where(x => x.Kind != "changeset" && string.Equals(x.RepoId, repo, StringComparison.OrdinalIgnoreCase)).ToList();
-            var inside = new List<CodeChange>();
-            var known = false;
-            foreach (var g in git)
-            {
-                if (g.LandedCommit is not { } commit) continue;
-                var r = await Contains(repo, commit, target, isBranch);
-                known |= r is not null;
-                if (r == true) inside.Add(g);
-            }
+            // A deployment that finished before a change was merged cannot contain it: no need to ask.
+            var answers = await Task.WhenAll(git.Select(async g =>
+                g.LandedCommit is not { } commit ? (bool?)null
+                : deployedAt is { } at && g.Date is { } merged && at < merged ? false
+                : await Contains(repo, commit, target, isBranch)));
+            var inside = git.Where((g, i) => answers[i] == true).ToList();
+            var known = answers.Any(a => a is not null);
             var notYet = git.Where(g => !inside.Contains(g) && !IsPromotion(g)
                 && !inside.Any(i => i.Branch is not null && i.Branch == g.Branch && i.Date >= g.Date)).ToList();
             return (inside, notYet, known);
@@ -232,6 +228,7 @@ string Label(string? branch, string def, string stage) =>
         static string Names(IEnumerable<CodeChange> list) =>
             string.Join(", ", list.Select(x => x.Kind == "pr" ? $"PR {x.Id} ({x.TargetBranch}, {x.Date?.ToLocalTime():MM-dd})" : $"commit {x.Id[..Math.Min(7, x.Id.Length)]}"));
 
+        var stageTasks = new List<Task<string?>>();
         foreach (var d in deployments.OrderBy(d => Order(d.Branch, d.Definition, d.Stage)).ThenBy(d => d.Definition).ThenBy(d => d.Stage))
         {
             // With an environment map, a stage outside it that has not deployed for half a year is an old pipeline.
@@ -246,21 +243,24 @@ static string Names(IEnumerable<CodeChange> list) =>
                 if (onBranch.Count == 0) continue;
                 bool? contains = int.TryParse(d.SourceVersion, out var v) ? v >= onBranch.Max() : null;
                 anyIn |= contains == true;
-                where.Add(label + contains switch
+                stageTasks.Add(Task.FromResult<string?>(label + contains switch
                 {
                     true => $"YES - deployed {deployed}",
                     false => $"NOT YET - last deployment {deployed} does not contain it",
                     _ => $"unknown - last deployment {deployed}",
-                });
+                }));
             }
             else if (d.SourceVersion is { } deployedCommit && d.Repository is { } repo
                      && changes.Any(x => x.Change.Kind != "changeset" && string.Equals(x.Change.RepoId, repo, StringComparison.OrdinalIgnoreCase)))
             {
-                var (inside, notYet, _) = await GitStatus(repo, deployedCommit, false);
-                anyIn |= inside.Count > 0;
-                where.Add(label + (inside.Count > 0
-                    ? $"YES - deployed {deployed}: {Names(inside.Where(x => !IsPromotion(x)).DefaultIfEmpty(inside[0]))}" + (notYet.Count > 0 ? $"; not yet: {Names(notYet)}" : "")
-                    : $"NOT YET - last deployment {deployed} has none of it"));
+                stageTasks.Add(Task.Run(async () =>
+                {
+                    var (inside, notYet, _) = await GitStatus(repo, deployedCommit, false, d.When);
+                    if (inside.Count > 0) anyIn = true;
+                    return (string?)(label + (inside.Count > 0
+                        ? $"YES - deployed {deployed}: {Names(inside.Where(x => !IsPromotion(x)).DefaultIfEmpty(inside[0]))}" + (notYet.Count > 0 ? $"; not yet: {Names(notYet)}" : "")
+                        : $"NOT YET - last deployment {deployed} has none of it"));
+                }, ct));
             }
         }
         // Git branches named in the environment map, even without release pipelines: is the work merged there?
@@ -268,13 +268,18 @@ static string Names(IEnumerable<CodeChange> list) =>
         foreach (var (branch, envLabel) in env.Where(e => !e.Key.Contains('/')))
             foreach (var group in changes.Select(x => x.Change).Where(x => x.Kind != "changeset" && x.RepoId is not null).GroupBy(x => x.RepoId!))
             {
-                var (inside, notYet, known) = await GitStatus(group.Key, branch, true);
-                if (!known) continue;
-                anyIn |= inside.Count > 0;
-                where.Add($"- {envLabel} branch {branch} ({group.First().Repo}): " + (inside.Count > 0
-                    ? $"merged: {Names(inside.Where(x => !IsPromotion(x)).DefaultIfEmpty(inside[0]))}" + (notYet.Count > 0 ? $"; not yet: {Names(notYet)}" : "")
-                    : "NOT merged yet"));
+                var repoName = group.First().Repo;
+                stageTasks.Add(Task.Run(async () =>
+                {
+                    var (inside, notYet, known) = await GitStatus(group.Key, branch, true, null);
+                    if (!known) return null;
+                    if (inside.Count > 0) anyIn = true;
+                    return (string?)($"- {envLabel} = branch {branch} ({repoName}): " + (inside.Count > 0
+                        ? $"merged: {Names(inside.Where(x => !IsPromotion(x)).DefaultIfEmpty(inside[0]))}" + (notYet.Count > 0 ? $"; not yet: {Names(notYet)}" : "")
+                        : "NOT merged yet"));
+                }, ct));
             }
+        where.AddRange((await Task.WhenAll(stageTasks)).Where(l => l is not null).Select(l => l!));
         if (where.Count > 0) sb.AppendLine("\nWHERE").AppendLine(string.Join('\n', where));
         else if (changes.Count > 0) sb.AppendLine("\nWHERE").AppendLine("no release stage deploys the branches of this change");
 
@@ -371,7 +376,7 @@ public static async Task<string> ChangesAsync(Lens lens, string? connection, str
     {
         var session = lens.For(connection);
         var (c, versions) = await ResolveAsync(session, change, repo, ct);
-        return await ChangesTextAsync(c, versions, file, detail);
+        return await ChangesTextAsync(session, c, versions, file, detail);
     }
 
     /// <summary>A changeset, pull request or commit, and how to read the two versions of each of its files.</summary>
@@ -407,7 +412,28 @@ public static async Task<string> ChangesAsync(Lens lens, string? connection, str
         return (c, versions);
     }
 
-    static async Task<string> ChangesTextAsync(CodeChange c, Func<FileChange, Task<(string? Before, string? After)>> versions, string? file, string? detail)
+    /// <summary>The work items linked to a change, with type, state and tags (a commit: the ids in its message).</summary>
+    internal static async Task<string?> WorkItemsOfAsync(Session session, CodeChange c, CancellationToken ct)
+    {
+        List<int> ids;
+        try
+        {
+            ids = c.Kind switch
+            {
+                "changeset" => (await session.Client.GetListAsync($"_apis/tfvc/changesets/{c.Id}/workItems", ct)).Select(w => w.TryGetProperty("id", out var i) ? i.GetInt32() : 0).ToList(),
+                "pr" => (await session.Client.GetListAsync($"_apis/git/repositories/{c.RepoId}/pullRequests/{c.Id}/workitems", ct)).Select(w => int.TryParse(Json.Str(w, "id"), out var i) ? i : 0).ToList(),
+                _ => System.Text.RegularExpressions.Regex.Matches(c.Message ?? "", @"#(\d{2,7})\b").Select(m => int.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture)).ToList(),
+            };
+        }
+        catch (AdoApiException) { return null; }
+        ids = ids.Where(i => i > 0).Distinct().ToList();
+        if (ids.Count == 0) return "work items: none linked";
+        var items = await session.Work.GetAsync(ids, relations: false, ["System.Id", "System.WorkItemType", "System.State", "System.Title", "System.Tags"], ct);
+        return "work items: " + string.Join("; ", items.Select(w => $"#{WorkItems.Id(w)} {WorkItems.Field(w, "System.WorkItemType")} {Formatting.Collapse(WorkItems.Field(w, "System.Title") ?? "", 50)} ({WorkItems.Field(w, "System.State")})" +
+            (WorkItems.Field(w, "System.Tags") is { Length: > 0 } t ? $" [tags: {t}]" : "")));
+    }
+
+    static async Task<string> ChangesTextAsync(Session session, CodeChange c, Func<FileChange, Task<(string? Before, string? After)>> versions, string? file, string? detail)
     {
         var ct = CancellationToken.None;
         var sb = new StringBuilder();
@@ -415,6 +441,7 @@ static async Task<string> ChangesTextAsync(CodeChange c, Func<FileChange, Task<(
             ? $"{c.Label} {c.State}: {c.TargetBranch} <- {c.Branch}, \"{c.Message}\", {c.Author}"
             : $"{c.Label} {Date(c.Date)} {c.Author}: \"{Formatting.Collapse(c.Message ?? "", 200)}\"";
         sb.AppendLine(head);
+        if (file is null && await WorkItemsOfAsync(session, c, ct) is { } linked) sb.AppendLine(linked);
 
         if (file is not null)
         {
diff --git a/tests/AdoLens.Tests/KnowledgeTests.cs b/tests/AdoLens.Tests/KnowledgeTests.cs
index 22d43e2..bb9256c 100644
--- a/tests/AdoLens.Tests/KnowledgeTests.cs
+++ b/tests/AdoLens.Tests/KnowledgeTests.cs
@@ -245,4 +245,13 @@ public async Task A_large_attachment_gets_a_link_and_is_not_downloaded()
         Assert.Contains("https://dev.azure.com/contoso/_apis/wit/attachments/big", text);
         Assert.Empty(images);
     }
+
+    [Fact]
+    public async Task The_history_of_a_whole_repository_or_folder()
+    {
+        var text = await Knowledge.FileAsync(lens, null, null, "/", "erp", null, null, true, 15, null);
+        Assert.Contains("history of erp: /: 2 changes", text);
+        Assert.Contains("PR 482: Credit limit check -> #1 Login page (New)", text);
+        Assert.Contains("is a folder", await Knowledge.FileAsync(lens, null, null, "/", "erp", null, null, false, 15, null));
+    }
 }
diff --git a/tests/AdoLens.Tests/PrPipelineTests.cs b/tests/AdoLens.Tests/PrPipelineTests.cs
index e23d514..ba16429 100644
--- a/tests/AdoLens.Tests/PrPipelineTests.cs
+++ b/tests/AdoLens.Tests/PrPipelineTests.cs
@@ -158,7 +158,7 @@ public async Task Pipelines_are_listed_and_run_by_name()
     public void Environments_are_saved_for_good_in_flow_order()
     {
         var answer = Queries.SettingsAnswer(lens, null, "dev=DEV (sbx01); staging=UAT (sbx03); master=PROD");
-        Assert.Contains("environments (in flow order): DEV (sbx01) [dev] -> UAT (sbx03) [staging] -> PROD [master]", answer);
+        Assert.Contains("environments (in flow order): DEV (sbx01) = branch dev -> UAT (sbx03) = branch staging -> PROD = branch master", answer);
         var saved = Settings.Load(lens.SettingsPath);
         Assert.Equal(["dev", "staging", "master"], saved.Connections["contoso"].Environments.Keys);
         Assert.Throws<ArgumentException>(() => Queries.SettingsAnswer(lens, null, "staging"));
diff --git a/tests/AdoLens.Tests/SetupFlowTests.cs b/tests/AdoLens.Tests/SetupFlowTests.cs
index bf1132d..a9b7f50 100644
--- a/tests/AdoLens.Tests/SetupFlowTests.cs
+++ b/tests/AdoLens.Tests/SetupFlowTests.cs
@@ -111,7 +111,7 @@ public async Task Without_any_map_the_flow_is_detected_from_releases_and_branche
     public async Task The_team_map_is_saved_on_the_wiki_and_used_by_everyone_unless_overridden_locally()
     {
         var saved = await Queries.SettingsAsync(lens, null, null, "dev=DEV (sbx01); staging=UAT (sbx03); master=PROD", "team");
-        Assert.StartsWith("saved for the whole team on the wiki page \"/ADO Lens\" of Demo: DEV (sbx01) [dev] -> UAT (sbx03) [staging] -> PROD [master]", saved);
+        Assert.StartsWith("saved for the whole team on the wiki page \"/ADO Lens\" of Demo: DEV (sbx01) = branch dev -> UAT (sbx03) = branch staging -> PROD = branch master", saved);
         Assert.Null(puts.Single().IfMatch); // a new page
         Assert.Contains("| staging | UAT (sbx03) |", page);
 
diff --git a/tests/AdoLens.Tests/SetupTests.cs b/tests/AdoLens.Tests/SetupTests.cs
index 04b3d4b..4ce964b 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",
+        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",
             "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);
diff --git a/tests/AdoLens.Tests/TraceTests.cs b/tests/AdoLens.Tests/TraceTests.cs
index 1003e80..7e39d5e 100644
--- a/tests/AdoLens.Tests/TraceTests.cs
+++ b/tests/AdoLens.Tests/TraceTests.cs
@@ -172,8 +172,8 @@ public async Task Trace_puts_the_criteria_next_to_the_code_and_says_where_it_is(
                     && text.IndexOf("- PROD (Shop master", StringComparison.Ordinal) < text.IndexOf("- UAT + SCM (Main release", StringComparison.Ordinal), text);
         Assert.Contains("- UAT (Shop staging / lcs): YES - deployed 2026-10-04 (build 2026.10.4.1): PR 482 (dev, 10-02)", text);
         Assert.Contains("- PROD (Shop master / lcs): NOT YET - last deployment 2026-09-20 (build 2026.9.20.1) has none of it", text);
-        Assert.Contains("- UAT branch staging (portal): merged: PR 482 (dev, 10-02)", text);
-        Assert.Contains("- PROD branch master (portal): NOT merged yet", text);
+        Assert.Contains("- UAT = branch staging (portal): merged: PR 482 (dev, 10-02)", text);
+        Assert.Contains("- PROD = branch master (portal): NOT merged yet", text);
         Assert.DoesNotContain("Other / x", text); // a stage of a branch this change is not on
         Assert.Contains("acceptance criteria changed after the first code change (2026-10-05 Anna Nowak)", text);
         Assert.Contains("TASKS\n- #2 Task [To Do] Build the form", text);

From 557924fe43ad8b024d6c138efcf3d347eb6820e3 Mon Sep 17 00:00:00 2001
From: WillowDev <216433317+willowdev-code@users.noreply.github.com>
Date: Fri, 16 Oct 2026 14:30:45 +0200
Subject: [PATCH 2/2] ADO Lens 0.7.3

Fixes from a real question: "pull requests merged into staging after release X, with their work items and tags".

- `ado_pr` and `ado_pipeline` (reading: pull request lists and details, merged PRs, builds, deployments, artifacts) are
  in every mode now, the Product Owner one too; creating and completing PRs and running pipelines stay for developers.
- `ado_changes` of a pull request, changeset or commit lists its work items with type, state and tags.
- `ado_trace` checks the release stages in parallel and skips deployments older than the change: it no longer runs
  out of time on items with several pull requests.
- `ado_file path=/ repo=<r> history=true version=<branch>`: the history of a whole repository or folder on a branch,
  with pull requests and work items. An environment name given as the branch ("sbx03") is turned into its branch.
- The environment map reads "UAT (sbx03) = branch staging" instead of "UAT (sbx03) [staging]".
- The server instructions name the tools for "what went into a branch or an environment".
---
 CHANGELOG.md               | 2 +-
 src/AdoLens/AdoLens.csproj | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f017607..38d05d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.7.3 — unreleased
+## 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/AdoLens.csproj b/src/AdoLens/AdoLens.csproj
index 97a0339..5465e6f 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.2</Version>
+    <Version>0.7.3</Version>
   </PropertyGroup>
 
   <ItemGroup>