OPC # 0006: OPC Git Trunk-Based management

Co-authored-by: Copilot <copilot@github.com>

ControlPlane.Api/Endpoints/ImageBuildEndpoints.cs

@@ -2,6 +2,7 @@ using System.Diagnostics;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using ControlPlane.Api.Services;
+using ControlPlane.Core.Services;
 
 namespace ControlPlane.Api.Endpoints;
 
@@ -14,6 +15,7 @@ public static class ImageBuildEndpoints
         var group = app.MapGroup("/api/image").WithTags("Image");
 
         group.MapGet("/status",  GetStatus);
+        group.MapGet("/history", GetHistory);
         group.MapPost("/build",  TriggerBuild);
 
         // Post-provisioning verification helpers
@@ -28,6 +30,26 @@ public static class ImageBuildEndpoints
     private static async Task<IResult> GetStatus(ImageBuildService svc) =>
         Results.Ok(await svc.GetStatusAsync());
 
+    /// <summary>Returns recent DockerImage build records for the sparkline chart.</summary>
+    private static async Task<IResult> GetHistory(BuildHistoryService history, int limit = 30)
+    {
+        var all = await history.GetBuildsAsync();
+        var records = all
+            .Where(b => b.Kind == ControlPlane.Core.Models.BuildKind.DockerImage)
+            .Take(Math.Clamp(limit, 1, 100))
+            .Select(b => new
+            {
+                b.Id,
+                b.Status,
+                b.StartedAt,
+                b.DurationMs,
+                b.CommitSha,
+                b.ImageDigest,
+            })
+            .ToList();
+        return Results.Ok(records);
+    }
+
     /// <summary>
     /// Triggers a docker build and streams the output line-by-line as SSE.
     /// The build context is the repo root, which must be configured via

ControlPlane.Api/Endpoints/PromotionEndpoints.cs

@@ -1,5 +1,6 @@
 using ControlPlane.Api.Services;
 using ControlPlane.Core.Models;
+using ControlPlane.Core.Services;
 using System.Text.Json;
 
 namespace ControlPlane.Api.Endpoints;
@@ -12,9 +13,9 @@ public static class PromotionEndpoints
     {
         var g = app.MapGroup("/api/promotions").WithTags("Promotions");
 
-        // GET /api/promotions/ladder  — branch status for all 4 ladder branches
+        // GET /api/promotions/ladder?repo=Clarity  — branch status for all 4 ladder branches
-        g.MapGet("/ladder", async (PromotionService svc, CancellationToken ct) =>
+        g.MapGet("/ladder", async (PromotionService svc, CancellationToken ct, string repo = "Clarity") =>
-            Results.Ok(await svc.GetLadderStatusAsync(ct)));
+            Results.Ok(await svc.GetLadderStatusAsync(repo, ct)));
 
         // GET /api/promotions/history
         g.MapGet("/history", async (PromotionService svc) =>
@@ -50,7 +51,7 @@ public static class PromotionEndpoints
             void OnLine(string line) => channel.Writer.TryWrite(line);
 
             var promoteTask = Task.Run(() =>
-                svc.PromoteAsync(req.From, req.To, req.RequestedBy ?? "system", req.Note, OnLine, ct), ct)
+                svc.PromoteAsync(req.From, req.To, req.RequestedBy ?? "system", req.Note, OnLine, ct, req.Repo ?? "Clarity"), ct)
                 .ContinueWith(t => channel.Writer.TryComplete(t.Exception), TaskScheduler.Default);
 
             await foreach (var line in channel.Reader.ReadAllAsync(ct))
@@ -66,8 +67,144 @@ public static class PromotionEndpoints
             await ctx.Response.Body.FlushAsync(ct);
         });
 
+        // POST /api/promotions/reset  — body: { branch, toSha, repo }
+        // Force-resets a downstream branch to a specific SHA (e.g. to recover from a GitFlow merge commit).
+        // Only allowed for staging/uat — never develop or main.
+        g.MapPost("/reset", async (PromotionService svc, ResetBranchRequest req, CancellationToken ct) =>
+        {
+            var allowed = new[] { "staging", "uat" };
+            if (!allowed.Contains(req.Branch))
+                return Results.BadRequest(new { error = $"Reset is only allowed for: {string.Join(", ", allowed)}." });
+
+            try
+            {
+                await svc.ResetBranchAsync(req.Branch, req.ToSha, req.Repo ?? "Clarity", ct);
+                return Results.Ok(new { reset = req.Branch, toSha = req.ToSha });
+            }
+            catch (Exception ex)
+            {
+                return Results.BadRequest(new { error = ex.Message });
+            }
+        });
+
+        // POST /api/promotions/cherry-pick  — body: { shas, from, to, requestedBy, note, repo }
+        // Streams SSE log lines then sends {done, promotion} when complete.
+        // Unlike a full promote, cherry-pick applies selected commits as copies — branches will diverge.
+        g.MapPost("/cherry-pick", async (
+            HttpContext ctx,
+            PromotionService svc,
+            CherryPickRequest req,
+            CancellationToken ct) =>
+        {
+            var ladder = PromotionService.Ladder;
+            var fi = Array.IndexOf(ladder, req.From);
+            var ti = Array.IndexOf(ladder, req.To);
+            if (fi < 0 || ti < 0 || ti != fi + 1)
+            {
+                ctx.Response.StatusCode = 400;
+                await ctx.Response.WriteAsJsonAsync(
+                    new { error = $"Invalid cherry-pick target: {req.From} → {req.To}. Must be adjacent in ladder." }, ct);
+                return;
+            }
+
+            if (req.Shas is null || req.Shas.Length == 0)
+            {
+                ctx.Response.StatusCode = 400;
+                await ctx.Response.WriteAsJsonAsync(
+                    new { error = "No commits specified for cherry-pick." }, ct);
+                return;
+            }
+
+            ctx.Response.Headers.ContentType  = "text/event-stream";
+            ctx.Response.Headers.CacheControl = "no-cache";
+            ctx.Response.Headers.Connection   = "keep-alive";
+
+            var channel = System.Threading.Channels.Channel.CreateUnbounded<string?>(
+                new System.Threading.Channels.UnboundedChannelOptions { SingleWriter = true, SingleReader = true });
+
+            void OnLine(string line) => channel.Writer.TryWrite(line);
+
+            var cpTask = Task.Run(() =>
+                svc.CherryPickAsync(req.Shas, req.From, req.To, req.RequestedBy ?? "system", req.Note, OnLine, ct, req.Repo ?? "Clarity"), ct)
+                .ContinueWith(t => channel.Writer.TryComplete(t.Exception), TaskScheduler.Default);
+
+            await foreach (var line in channel.Reader.ReadAllAsync(ct))
+            {
+                var json = JsonSerializer.Serialize(new { line }, JsonOpts);
+                await ctx.Response.WriteAsync($"data: {json}\n\n", ct);
+                await ctx.Response.Body.FlushAsync(ct);
+            }
+
+            var promotion = await cpTask;
+            var doneJson  = JsonSerializer.Serialize(new { done = true, promotion }, JsonOpts);
+            await ctx.Response.WriteAsync($"data: {doneJson}\n\n", ct);
+            await ctx.Response.Body.FlushAsync(ct);
+        });
+
+        // GET /api/promotions/conformance?repo=Clarity
+        // Returns a full TBD conformance report: which branches are diverged, missing, or stale.
+        g.MapGet("/conformance", async (PromotionService svc, CancellationToken ct, string repo = "Clarity") =>
+            Results.Ok(await svc.GetConformanceAsync(repo, ct)));
+
+        // GET /api/promotions/conformance/all
+        // Returns conformance reports for all configured repos (Clarity, OPC, Gateway).
+        g.MapGet("/conformance/all", async (PromotionService svc, IConfiguration config, CancellationToken ct) =>
+        {
+            var allRepos = new[] { "Clarity", "OPC", "Gateway" };
+            var configured = allRepos
+                .Where(r => !string.IsNullOrWhiteSpace(config[$"Git:Repos:{r}"]))
+                .ToArray();
+
+            var tasks   = configured.Select(r => svc.GetConformanceAsync(r, ct));
+            var results = await Task.WhenAll(tasks);
+            return Results.Ok(results);
+        });
+
+        // POST /api/promotions/create-branch — body: { branch, fromSha, repo }
+        // Creates a missing ladder branch at the given SHA and pushes to origin.
+        g.MapPost("/create-branch", async (PromotionService svc, CreateLadderBranchRequest req, CancellationToken ct) =>
+        {
+            var allowed = new[] { "staging", "uat", "main" };
+            if (!allowed.Contains(req.Branch))
+                return Results.BadRequest(new { error = $"Create-branch is only allowed for: {string.Join(", ", allowed)}." });
+
+            try
+            {
+                await svc.CreateBranchAsync(req.Branch, req.FromSha, req.Repo ?? "Clarity", ct);
+                return Results.Ok(new { created = req.Branch, fromSha = req.FromSha });
+            }
+            catch (Exception ex)
+            {
+                return Results.BadRequest(new { error = ex.Message });
+            }
+        });
+
+        // GET /api/promotions/build-gate?sha={sha}
+        // Returns the build-gate status for the given commit SHA.
+        // If status is "Red", the promote button in the UI should be disabled.
+        g.MapGet("/build-gate", async (string sha, BuildHistoryService history, CancellationToken ct) =>
+        {
+            var builds = await history.GetBuildsByShaAsync(sha);
+            var latest = builds.MaxBy(b => b.StartedAt);
+            if (latest is null)
+                return Results.Ok(new { status = "Unknown", sha, buildId = (string?)null, buildStatus = (string?)null });
+
+            var gateStatus = latest.Status switch
+            {
+                BuildStatus.Succeeded => "Green",
+                BuildStatus.Failed    => "Red",
+                BuildStatus.Running   => "Running",
+                _                     => "Unknown",
+            };
+
+            return Results.Ok(new { status = gateStatus, sha, buildId = latest.Id, buildStatus = latest.Status.ToString() });
+        });
+
         return app;
     }
 }
 
-public record PromoteRequest(string From, string To, string? RequestedBy, string? Note);
+public record PromoteRequest(string From, string To, string? RequestedBy, string? Note, string? Repo);
+public record ResetBranchRequest(string Branch, string ToSha, string? Repo);
+public record CherryPickRequest(string[] Shas, string From, string To, string? RequestedBy, string? Note, string? Repo);
+public record CreateLadderBranchRequest(string Branch, string FromSha, string? Repo);

ControlPlane.Api/Program.cs

@@ -126,7 +126,48 @@ await using (var cmd = ds.CreateCommand("""
     CREATE INDEX IF NOT EXISTS ix_opc_artifact_opc_id    ON opc_artifact(opc_id);
     CREATE INDEX IF NOT EXISTS ix_opc_artifact_type      ON opc_artifact(opc_id, artifact_type);
     CREATE INDEX IF NOT EXISTS ix_opc_pinned_commit_opc_id ON opc_pinned_commit(opc_id);
+
+    -- ── Build + Release history ────────────────────────────────────────────
+    CREATE TABLE IF NOT EXISTS build_record (
+        id           VARCHAR(8)   PRIMARY KEY,
+        kind         VARCHAR(20)  NOT NULL,
+        target       VARCHAR(500) NOT NULL,
+        status       VARCHAR(20)  NOT NULL DEFAULT 'Running',
+        started_at   TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+        finished_at  TIMESTAMPTZ,
+        duration_ms  INTEGER,
+        image_digest VARCHAR(200),
+        commit_sha   VARCHAR(40),
+        log          TEXT         NOT NULL DEFAULT ''
+    );
+    CREATE TABLE IF NOT EXISTS release_record (
+        id          VARCHAR(8)   PRIMARY KEY,
+        environment VARCHAR(50)  NOT NULL,
+        image_name  VARCHAR(200) NOT NULL,
+        status      VARCHAR(20)  NOT NULL DEFAULT 'Running',
+        started_at  TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+        finished_at TIMESTAMPTZ
+    );
+    CREATE TABLE IF NOT EXISTS release_tenant_result (
+        id             UUID         PRIMARY KEY DEFAULT gen_random_uuid(),
+        release_id     VARCHAR(8)   NOT NULL REFERENCES release_record(id) ON DELETE CASCADE,
+        subdomain      VARCHAR(200) NOT NULL,
+        container_name VARCHAR(200) NOT NULL,
+        success        BOOLEAN      NOT NULL DEFAULT FALSE,
+        error          TEXT
+    );
+    CREATE INDEX IF NOT EXISTS ix_build_record_started_at    ON build_record(started_at DESC);
+    CREATE INDEX IF NOT EXISTS ix_build_record_kind          ON build_record(kind);
+    CREATE INDEX IF NOT EXISTS ix_release_record_started_at  ON release_record(started_at DESC);
+    CREATE INDEX IF NOT EXISTS ix_release_tenant_release_id  ON release_tenant_result(release_id);
     """))
     await cmd.ExecuteNonQueryAsync();
 
+// Idempotent column additions for schema migrations
+await using (var migCmd = ds.CreateCommand("""
+    ALTER TABLE release_record ADD COLUMN IF NOT EXISTS opc_numbers TEXT[] NOT NULL DEFAULT '{}';
+    ALTER TABLE release_record ADD COLUMN IF NOT EXISTS commit_sha  VARCHAR(40);
+    """))
+    await migCmd.ExecuteNonQueryAsync();
+
 app.Run();

ControlPlane.Api/Services/ImageBuildService.cs

@@ -2,6 +2,7 @@ using ControlPlane.Core.Models;
 using ControlPlane.Core.Services;
 using Docker.DotNet;
 using Docker.DotNet.Models;
+using LibGit2Sharp;
 
 namespace ControlPlane.Api.Services;
 
@@ -49,6 +50,14 @@ public class ImageBuildService(
 
         var record = await history.CreateBuildAsync(BuildKind.DockerImage, ImageName);
 
+        // Capture HEAD SHA so the build is traceable back to a specific commit
+        try
+        {
+            using var repo = new Repository(repoRoot);
+            record.CommitSha = repo.Head.Tip?.Sha;
+        }
+        catch { /* not a git repo or no commits yet — CommitSha stays null */ }
+
         try
         {
             var socketUri = config["Docker:Socket"] ?? "npipe://./pipe/docker_engine";

ControlPlane.Api/Services/ProjectBuildService.cs

@@ -1,5 +1,6 @@
 using ControlPlane.Core.Models;
 using ControlPlane.Core.Services;
+using LibGit2Sharp;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System.Diagnostics;
@@ -24,9 +25,14 @@ public class ProjectBuildService(
 
         return
         [
-            new("Clarity.Server",           BuildKind.DotnetProject, "Clarity.Server/Clarity.Server.csproj"),
+            // ── Solution-level builds (primary targets) ──────────────────────
-            new("Clarity.ServiceDefaults",   BuildKind.DotnetProject, "Clarity.ServiceDefaults/Clarity.ServiceDefaults.csproj"),
+            new("Clarity Solution",          BuildKind.SolutionBuild,  "Clarity/Clarity.slnx"),
-            new("frontend (Clarity.Server)", BuildKind.NpmProject,    "frontend"),
+            new("ControlPlane Solution",     BuildKind.SolutionBuild,  "OPC/ControlPlane.slnx"),
+
+            // ── Individual Clarity projects ───────────────────────────────────
+            new("Clarity.Server",            BuildKind.DotnetProject,  "Clarity/Clarity.Server/Clarity.Server.csproj"),
+            new("Clarity.ServiceDefaults",   BuildKind.DotnetProject,  "Clarity/Clarity.ServiceDefaults/Clarity.ServiceDefaults.csproj"),
+            new("frontend (Clarity.Server)", BuildKind.NpmProject,     "Clarity/frontend"),
         ];
     }
 
@@ -53,6 +59,16 @@ public class ProjectBuildService(
         record.Log.Add("──────────────────────────────────────");
         onLine($"▶ Building {def.Name}");
 
+        // Capture HEAD SHA so the build is traceable to a specific commit
+        try
+        {
+            using var gitRepo = new Repository(RepoRoot);
+            record.CommitSha = gitRepo.Head.Tip?.Sha;
+            if (record.CommitSha is not null)
+                record.Log.Add($"  Commit: {record.CommitSha[..8]}");
+        }
+        catch { /* not a git repo or no commits yet */ }
+
         try
         {
             var (exe, args, workDir) = def.Kind == BuildKind.NpmProject

ControlPlane.Api/Services/PromotionService.cs

@@ -1,22 +1,25 @@
 using ControlPlane.Core.Models;
+using LibGit2Sharp;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
-using System.Diagnostics;
 using System.Text.Json;
 
 namespace ControlPlane.Api.Services;
 
 /// <summary>
-/// Handles all git operations for the promotion workflow:
+/// Handles all git operations for the promotion workflow using LibGit2Sharp.
-/// branch status, diff summaries, merge + push, and promotion history persistence.
+/// No git.exe subprocess is ever spawned — all operations run through the managed
-/// All git commands run against the repo root configured in Docker:RepoRoot.
+/// LibGit2Sharp API against the server's authoritative repository clone.
+/// HEAD is never mutated; merges are performed directly on the object database
+/// so the working tree always reflects the develop branch.
 /// </summary>
 public class PromotionService(IConfiguration config, ILogger<PromotionService> logger)
 {
-    // The ordered promotion ladder — each step is a valid promotion.
+    // The ordered promotion ladder — develop is trunk, main is production.
-    public static readonly string[] Ladder = ["develop", "staging", "uat", "master"];
+    public static readonly string[] Ladder = ["develop", "staging", "uat", "main"];
 
-    private string RepoRoot => config["Docker:RepoRoot"] ?? string.Empty;
+    private string GetRepoPath(string repoName) =>
+        config[$"Git:Repos:{repoName}"] ?? string.Empty;
 
     private static readonly SemaphoreSlim _lock = new(1, 1);
     private static readonly JsonSerializerOptions JsonOpts = new()
@@ -26,67 +29,147 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
         Converters           = { new System.Text.Json.Serialization.JsonStringEnumConverter() },
     };
 
+    // ── Credentials ──────────────────────────────────────────────────────────
+
+    private FetchOptions MakeFetchOptions() => new()
+    {
+        CredentialsProvider = (_, _, _) => new UsernamePasswordCredentials
+        {
+            Username = config["Gitea:Owner"] ?? "git",
+            Password = config["Gitea:Token"] ?? string.Empty,
+        },
+    };
+
+    private PushOptions MakePushOptions() => new()
+    {
+        CredentialsProvider = (_, _, _) => new UsernamePasswordCredentials
+        {
+            Username = config["Gitea:Owner"] ?? "git",
+            Password = config["Gitea:Token"] ?? string.Empty,
+        },
+    };
+
+    private static Signature MakeSig() =>
+        new("OPC Control Plane", "opc@clarity.internal", DateTimeOffset.UtcNow);
+
+    // ── Remote URL (config-driven, never reads .git/config URL) ──────────────
+
+    /// <summary>
+    /// Builds the HTTPS remote URL for a named repo entirely from Gitea config.
+    /// The local clone's .git/config remote URL is irrelevant — this is the authority.
+    /// </summary>
+    private string GetRemoteUrl(string repoName)
+    {
+        var baseUrl  = (config["Gitea:BaseUrl"]
+            ?? throw new InvalidOperationException("Gitea:BaseUrl is not configured.")).TrimEnd('/');
+        var owner    = config[$"Gitea:Repos:{repoName}:Owner"] ?? config["Gitea:Owner"]
+            ?? throw new InvalidOperationException($"Gitea owner not configured for '{repoName}'.");
+        var repoSlug = config[$"Gitea:Repos:{repoName}:Repo"] ?? repoName;
+        return $"{baseUrl}/{owner}/{repoSlug}.git";
+    }
+
+    /// <summary>
+    /// Returns the 'origin' remote after normalising its URL to the config-driven HTTPS URL.
+    /// If the clone was checked out with SSH (e.g. on a dev machine), this corrects it silently
+    /// so that LibGit2Sharp — which has no SSH support — always uses HTTPS.
+    /// </summary>
+    private Remote EnsureRemote(Repository repo, string repoName)
+    {
+        var url    = GetRemoteUrl(repoName);
+        var remote = repo.Network.Remotes["origin"];
+        if (remote is null)
+            return repo.Network.Remotes.Add("origin", url);
+        if (remote.Url != url)
+            repo.Network.Remotes.Update("origin", r => r.Url = url);
+        return repo.Network.Remotes["origin"]!;
+    }
+
     // ── Branch status ────────────────────────────────────────────────────────
 
     /// <summary>
     /// Returns status for all ladder branches: last commit info + ahead/behind counts vs next branch.
+    /// Runs on a thread-pool thread because LibGit2Sharp network operations are synchronous.
     /// </summary>
-    public async Task<List<BranchStatus>> GetLadderStatusAsync(CancellationToken ct = default)
+    public Task<List<BranchStatus>> GetLadderStatusAsync(string repoName = "Clarity", CancellationToken ct = default) =>
+        Task.Run(() => GetLadderStatusCore(repoName, ct), ct);
+
+    private List<BranchStatus> GetLadderStatusCore(string repoName, CancellationToken ct)
     {
+        var repoPath = GetRepoPath(repoName);
+        if (string.IsNullOrWhiteSpace(repoPath) || !Directory.Exists(repoPath))
+            return Ladder.Select(b => new BranchStatus(b, false, null, null, 0, 0, [])).ToList();
+
+        using var repo = new Repository(repoPath);
+
+        // Fetch to get up-to-date remote refs; swallow network errors so status still works offline.
+        try
+        {
+            var remote   = EnsureRemote(repo, repoName);
+            var refSpecs = remote.FetchRefSpecs.Select(r => r.Specification).ToList();
+            repo.Network.Fetch(remote.Name, refSpecs, MakeFetchOptions());
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Fetch during ladder status failed — continuing with cached refs");
+        }
+
         var result = new List<BranchStatus>();
 
-        // Fetch to get up-to-date remote state, but don't fail if we're offline
+        for (var i = 0; i < Ladder.Length; i++)
-        await RunGitAsync("fetch --all --quiet", ct, swallowErrors: true);
+        {
+            ct.ThrowIfCancellationRequested();
 
-        foreach (var branch in Ladder)
+            var branchName  = Ladder[i];
+            // Always read from the remote tracking ref so the status reflects what is on origin,
+            // not the server's potentially-stale local branch pointer.
+            var branch      = repo.Branches[$"origin/{branchName}"];
+
+            if (branch?.Tip is null)
             {
-            var exists = await BranchExistsAsync(branch, ct);
+                result.Add(new BranchStatus(branchName, false, null, null, 0, 0, []));
-            if (!exists)
-            {
-                result.Add(new BranchStatus(branch, false, null, null, 0, 0, []));
                 continue;
             }
 
-            // Last commit on this branch
+            var tip     = branch.Tip;
-            var lastCommit = await GitOutputAsync($"log {branch} -1 --format=%h|%an|%ad|%s --date=short", ct);
+            var when    = tip.Author.When;
-            string? shortHash = null, author = null, date = null, subject = null;
+            var summary = $"{tip.Author.Name} · {when:yyyy-MM-dd} · {tip.MessageShort}";
-            if (!string.IsNullOrWhiteSpace(lastCommit))
-            {
-                var p = lastCommit.Trim().Split('|', 4);
-                if (p.Length == 4) (shortHash, author, date, subject) = (p[0], p[1], p[2], p[3]);
-            }
 
-            // Ahead/behind vs the NEXT branch in the ladder
+            // Ahead/behind vs the next branch in the ladder
-            int ahead = 0, behind = 0;
+            int          ahead            = 0;
-            var nextIdx = Array.IndexOf(Ladder, branch) + 1;
+            int          behind           = 0;
-            if (nextIdx < Ladder.Length)
+            CommitInfo[] unreleasedCommits = [];
+
+            if (i + 1 < Ladder.Length)
             {
-                var next = Ladder[nextIdx];
+                var nextBranch = repo.Branches[$"origin/{Ladder[i + 1]}"];
-                if (await BranchExistsAsync(next, ct))
+                if (nextBranch?.Tip is not null)
                 {
-                    var counts = await GitOutputAsync($"rev-list --left-right --count {next}...{branch}", ct);
+                    var div = repo.ObjectDatabase.CalculateHistoryDivergence(tip, nextBranch.Tip);
-                    if (!string.IsNullOrWhiteSpace(counts))
+                    ahead  = div.AheadBy  ?? 0;
+                    behind = div.BehindBy ?? 0;
+
+                    if (ahead > 0)
                     {
-                        var parts = counts.Trim().Split('\t');
+                        unreleasedCommits = repo.Commits
-                        if (parts.Length == 2)
+                            .QueryBy(new CommitFilter
                             {
-                            int.TryParse(parts[0], out behind);
+                                IncludeReachableFrom = tip,
-                            int.TryParse(parts[1], out ahead);
+                                ExcludeReachableFrom = nextBranch.Tip,
-                        }
+                                SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Time,
+                            })
+                            .Select(c => new CommitInfo(
+                                c.Sha,
+                                c.Sha[..7],
+                                c.MessageShort,
+                                c.Author.Name,
+                                c.Author.When.ToString("yyyy-MM-dd")))
+                            .ToArray();
                     }
                 }
             }
 
-            // Unreleased commit summaries (commits in this branch not yet in next)
+            result.Add(new BranchStatus(branchName, true, tip.Sha[..7], summary,
-            string[] unreleasedLines = [];
+                ahead, behind, unreleasedCommits, tip.Sha));
-            if (ahead > 0 && nextIdx < Ladder.Length && await BranchExistsAsync(Ladder[nextIdx], ct))
-            {
-                var log = await GitOutputAsync($"log {Ladder[nextIdx]}..{branch} --oneline --no-decorate", ct);
-                unreleasedLines = log.Split('\n', StringSplitOptions.RemoveEmptyEntries);
-            }
-
-            result.Add(new BranchStatus(branch, true, shortHash, $"{author} · {date} · {subject}",
-                ahead, behind, unreleasedLines));
         }
 
         return result;
@@ -96,7 +179,8 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
 
     /// <summary>
     /// Merges <paramref name="from"/> into <paramref name="to"/> with a no-fast-forward merge commit,
-    /// then pushes. Streams progress lines to <paramref name="onLine"/>.
+    /// then pushes. HEAD is never mutated — the working tree stays on develop throughout.
+    /// Streams progress lines to <paramref name="onLine"/>.
     /// </summary>
     public async Task<PromotionRequest> PromoteAsync(
         string from,
@@ -104,7 +188,8 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
         string requestedBy,
         string? note,
         Action<string> onLine,
-        CancellationToken ct)
+        CancellationToken ct,
+        string repoName = "Clarity")
     {
         if (!await _lock.WaitAsync(TimeSpan.Zero, ct))
         {
@@ -126,57 +211,13 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
 
         try
         {
-            Log($"▶ Promoting {from} → {to}");
+            await Task.Run(() => PromoteCore(from, to, note, repoName, req, Log, ct), ct);
-            if (!string.IsNullOrWhiteSpace(note)) Log($"  Note: {note}");
-            Log("──────────────────────────────────────");
-
-            // 1. Fetch latest
-            Log("  git fetch --all");
-            await RunGitAsync("fetch --all --quiet", ct);
-
-            // 2. Checkout target branch
-            Log($"  git checkout {to}");
-            await RunGitAsync($"checkout {to}", ct);
-
-            // 3. Pull target to latest
-            Log($"  git pull origin {to}");
-            await RunGitAsync($"pull origin {to} --quiet", ct);
-
-            // 4. Count commits being promoted
-            var logOutput = await GitOutputAsync($"log {to}..{from} --oneline --no-decorate", ct);
-            var commitLines = logOutput.Split('\n', StringSplitOptions.RemoveEmptyEntries);
-            req.CommitCount = commitLines.Length;
-            req.CommitLines = commitLines;
-            Log($"  Merging {commitLines.Length} commit(s) from {from}:");
-            foreach (var cl in commitLines) Log($"    {cl}");
-
-            // 5. Merge with --no-ff for a clean promotion commit
-            var mergeMsg = $"chore: promote {from} → {to}" + (note != null ? $" — {note}" : "");
-            Log($"  git merge --no-ff {from}");
-            await RunGitAsync($"merge --no-ff {from} -m \"{mergeMsg}\"", ct);
-
-            // 6. Push
-            Log($"  git push origin {to}");
-            await RunGitAsync($"push origin {to}", ct);
-
-            // 7. Return to develop so the working tree stays clean
-            await RunGitAsync("checkout develop", ct, swallowErrors: true);
-
-            Log("──────────────────────────────────────");
-            Log($"✔ {from} → {to} promoted successfully at {DateTimeOffset.UtcNow:u}");
-            req.Status      = PromotionStatus.Succeeded;
-            req.CompletedAt = DateTimeOffset.UtcNow;
         }
         catch (Exception ex)
         {
             Log($"✖ Promotion failed: {ex.Message}");
             req.Status      = PromotionStatus.Failed;
             req.CompletedAt = DateTimeOffset.UtcNow;
-
-            // Try to abort any broken merge state
-            await RunGitAsync("merge --abort", ct, swallowErrors: true);
-            await RunGitAsync("checkout develop", ct, swallowErrors: true);
-
             logger.LogError(ex, "Promotion {From}→{To} failed", from, to);
         }
         finally
@@ -188,6 +229,479 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
         return req;
     }
 
+    private void PromoteCore(
+        string from,
+        string to,
+        string? note,
+        string repoName,
+        PromotionRequest req,
+        Action<string> Log,
+        CancellationToken ct)
+    {
+        Log($"▶ Promoting {from} → {to} [{repoName}]");
+        if (!string.IsNullOrWhiteSpace(note)) Log($"  Note: {note}");
+        Log("──────────────────────────────────────");
+
+        using var repo = new Repository(GetRepoPath(repoName));
+
+        // 1. Fetch latest remote state for all branches
+        Log("  Fetching origin...");
+        var remote   = EnsureRemote(repo, repoName);
+        var refSpecs = remote.FetchRefSpecs.Select(r => r.Specification).ToList();
+        repo.Network.Fetch(remote.Name, refSpecs, MakeFetchOptions());
+
+        // 2. Resolve branches — always read from origin/ so we reflect what is actually on the remote,
+        //    never the server's potentially-stale local branch pointers.
+        var fromBranch = repo.Branches[$"origin/{from}"]
+            ?? throw new InvalidOperationException($"Remote branch 'origin/{from}' not found.");
+        // `to` is read locally because we need to mutate its ref and push — it is immediately
+        // fast-forwarded to origin/{to} in the next step so it is never stale when used.
+        var toBranch = repo.Branches[to]
+            ?? throw new InvalidOperationException($"Branch '{to}' not found.");
+
+        // 3. Fast-forward local `to` to its remote tracking branch (equivalent to git pull --ff-only)
+        var remoteTracking = repo.Branches[$"origin/{to}"];
+        if (remoteTracking?.Tip is not null && toBranch.Tip.Sha != remoteTracking.Tip.Sha)
+        {
+            Log($"  Fast-forwarding {to} to origin/{to}...");
+            repo.Refs.UpdateTarget(toBranch.Reference.CanonicalName, remoteTracking.Tip.Sha);
+            toBranch = repo.Branches[to]!; // refresh after update
+        }
+
+        ct.ThrowIfCancellationRequested();
+
+        var fromTip = fromBranch.Tip;
+        var toTip   = toBranch.Tip;
+
+        // 4. Enumerate commits being promoted
+        var pendingCommits = repo.Commits.QueryBy(new CommitFilter
+        {
+            IncludeReachableFrom = fromTip,
+            ExcludeReachableFrom = toTip,
+            SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Time,
+        }).ToList();
+
+        if (pendingCommits.Count == 0)
+        {
+            Log($"  ℹ {to} is already up-to-date with {from}. Nothing to promote.");
+            req.Status      = PromotionStatus.Succeeded;
+            req.CommitCount = 0;
+            req.CommitLines = [];
+            req.CompletedAt = DateTimeOffset.UtcNow;
+            return;
+        }
+
+        req.CommitCount = pendingCommits.Count;
+        req.CommitLines = pendingCommits.Select(c => $"{c.Sha[..7]} {c.MessageShort}").ToArray();
+        Log($"  {pendingCommits.Count} commit(s) to promote:");
+        foreach (var cl in req.CommitLines) Log($"    {cl}");
+
+        ct.ThrowIfCancellationRequested();
+
+        // 5. Safety check: `from` must be a descendant of `to` (fast-forward is only possible
+        //    when the target branch has no commits that aren't already reachable from source).
+        //    This is the TBD invariant — staging/uat/main are always subsets of develop's linear history.
+        var isAncestor = repo.ObjectDatabase.FindMergeBase(fromTip, toTip)?.Sha == toTip.Sha;
+        if (!isAncestor)
+        {
+            throw new InvalidOperationException(
+                $"'{to}' has commits not in '{from}' — fast-forward is not possible. " +
+                $"This means '{to}' diverged from trunk. " +
+                $"Check whether a hotfix was committed directly to '{to}' without being backported to '{from}'.");
+        }
+
+        // 6. Fast-forward: advance the local `to` ref to `from`'s tip — no merge commit, linear history.
+        //    Equivalent to: git push origin {from}:{to}
+        //    HEAD is never mutated, working tree is untouched.
+        var oldToSha = toTip.Sha;
+        repo.Refs.UpdateTarget(toBranch.Reference.CanonicalName, fromTip.Sha);
+        Log($"  Fast-forward: refs/heads/{to} {oldToSha[..7]} → {fromTip.Sha[..7]}");
+
+        ct.ThrowIfCancellationRequested();
+
+        // 7. Push to origin; roll back the local ref if push fails so nothing is left half-done
+        Log($"  Pushing {to} to origin...");
+        try
+        {
+            repo.Network.Push(remote, $"refs/heads/{to}:refs/heads/{to}", MakePushOptions());
+        }
+        catch
+        {
+            repo.Refs.UpdateTarget(toBranch.Reference.CanonicalName, oldToSha);
+            throw;
+        }
+
+        Log("──────────────────────────────────────");
+        Log($"✔ {from} → {to} promoted successfully ({pendingCommits.Count} commit(s)) at {DateTimeOffset.UtcNow:u}");
+        req.Status      = PromotionStatus.Succeeded;
+        req.CompletedAt = DateTimeOffset.UtcNow;
+    }
+
+    // ── Branch reset (recovery) ────────────────────────────────────────────────
+
+    /// <summary>
+    /// Force-resets <paramref name="branchName"/> to <paramref name="toSha"/> and force-pushes to origin.
+    /// Used to recover a downstream branch that has drifted from trunk (e.g. after an accidental merge commit).
+    /// </summary>
+    public Task ResetBranchAsync(string branchName, string toSha, string repoName, CancellationToken ct) =>
+        Task.Run(() =>
+        {
+            var repoPath = GetRepoPath(repoName);
+            using var repo = new Repository(repoPath);
+
+            var commit = repo.Lookup<Commit>(toSha)
+                ?? throw new InvalidOperationException($"SHA '{toSha}' not found in {repoName}.");
+
+            var branch = repo.Branches[branchName]
+                ?? throw new InvalidOperationException($"Branch '{branchName}' not found in {repoName}.");
+
+            var oldSha = branch.Tip.Sha;
+            repo.Refs.UpdateTarget(branch.Reference.CanonicalName, commit.Sha);
+
+            try
+            {
+                var remote = EnsureRemote(repo, repoName);
+                // Force push — "+" prefix overrides remote reflog
+                repo.Network.Push(remote, $"+refs/heads/{branchName}:refs/heads/{branchName}", MakePushOptions());
+            }
+            catch
+            {
+                repo.Refs.UpdateTarget(branch.Reference.CanonicalName, oldSha);
+                throw;
+            }
+
+            logger.LogInformation("Reset {Branch} from {Old} to {New} in {Repo}", branchName, oldSha[..7], commit.Sha[..7], repoName);
+        }, ct);
+
+    // ── Cherry-pick (partial promotion) ──────────────────────────────────────
+
+    /// <summary>
+    /// Cherry-picks the specified commits from <paramref name="from"/> onto <paramref name="to"/>
+    /// and pushes. Unlike a full fast-forward promotion, cherry-pick copies individual commits
+    /// as new commits — useful for promoting a subset of changes to a downstream environment.
+    /// Note: cherry-pick will cause the target branch to diverge from trunk.
+    /// </summary>
+    public async Task<PromotionRequest> CherryPickAsync(
+        string[]       shas,
+        string         from,
+        string         to,
+        string         requestedBy,
+        string?        note,
+        Action<string> onLine,
+        CancellationToken ct,
+        string         repoName = "Clarity")
+    {
+        if (!await _lock.WaitAsync(TimeSpan.Zero, ct))
+        {
+            var busy = new PromotionRequest { FromBranch = from, ToBranch = to, Status = PromotionStatus.Failed };
+            busy.Log.Add("⚠️  Another promotion or cherry-pick is already in progress.");
+            return busy;
+        }
+
+        var req = new PromotionRequest
+        {
+            FromBranch  = from,
+            ToBranch    = to,
+            RequestedBy = requestedBy,
+            Note        = note,
+            Status      = PromotionStatus.Running,
+        };
+
+        void Log(string line) { req.Log.Add(line); onLine(line); }
+
+        try
+        {
+            await Task.Run(() => CherryPickCore(shas, from, to, repoName, req, Log, ct), ct);
+        }
+        catch (Exception ex)
+        {
+            Log($"✖ Cherry-pick failed: {ex.Message}");
+            req.Status      = PromotionStatus.Failed;
+            req.CompletedAt = DateTimeOffset.UtcNow;
+            logger.LogError(ex, "Cherry-pick {From}→{To} failed", from, to);
+        }
+        finally
+        {
+            await SaveAsync(req);
+            _lock.Release();
+        }
+
+        return req;
+    }
+
+    private void CherryPickCore(
+        string[]       shas,
+        string         from,
+        string         to,
+        string         repoName,
+        PromotionRequest req,
+        Action<string> Log,
+        CancellationToken ct)
+    {
+        Log($"▶ Cherry-pick {shas.Length} commit(s): {from} → {to} [{repoName}]");
+        if (!string.IsNullOrWhiteSpace(req.Note)) Log($"  Note: {req.Note}");
+        Log("──────────────────────────────────────");
+
+        using var repo = new Repository(GetRepoPath(repoName));
+
+        if (repo.Info.IsBare)
+            throw new InvalidOperationException(
+                "Cherry-pick requires a non-bare repository clone. " +
+                "Ensure Git:Repos:{name} points to a standard (non-bare) clone.");
+
+        // 1. Fetch
+        Log("  Fetching origin...");
+        var remote   = EnsureRemote(repo, repoName);
+        var refSpecs = remote.FetchRefSpecs.Select(r => r.Specification).ToList();
+        repo.Network.Fetch(remote.Name, refSpecs, MakeFetchOptions());
+
+        // 2. Resolve target branch
+        var toBranch = repo.Branches[to]
+            ?? throw new InvalidOperationException($"Branch '{to}' not found.");
+
+        // 3. Fast-forward `to` to its remote tracking branch (sync with origin)
+        var remoteTracking = repo.Branches[$"origin/{to}"];
+        if (remoteTracking?.Tip is not null && toBranch.Tip.Sha != remoteTracking.Tip.Sha)
+        {
+            Log($"  Fast-forwarding {to} to origin/{to}...");
+            repo.Refs.UpdateTarget(toBranch.Reference.CanonicalName, remoteTracking.Tip.Sha);
+            toBranch = repo.Branches[to]!;
+        }
+
+        var savedToSha             = toBranch.Tip.Sha;
+        var originalHeadBranchName = repo.Head.FriendlyName;
+
+        // 4. Resolve commits — shas arrive newest-first from UI (topological order);
+        //    reverse so we apply oldest → newest (preserves logical order in history).
+        var commitsOrdered = shas
+            .Select(sha => repo.Lookup<Commit>(sha)
+                ?? throw new InvalidOperationException($"Commit '{sha}' not found in {repoName}."))
+            .Reverse()
+            .ToList();
+
+        req.CommitCount = commitsOrdered.Count;
+        req.CommitLines = commitsOrdered.Select(c => $"{c.Sha[..7]} {c.MessageShort}").ToArray();
+        Log($"  {commitsOrdered.Count} commit(s) to apply (oldest → newest):");
+        foreach (var c in commitsOrdered) Log($"    {c.Sha[..7]} {c.MessageShort}");
+
+        ct.ThrowIfCancellationRequested();
+
+        // 5. Force-checkout target branch — discards any dirty working tree state left by a
+        //    previous failed cherry-pick or interrupted operation. This is a server-only clone
+        //    managed exclusively by the control plane, so force is always safe here.
+        Log($"  Checking out {to} (force)...");
+        var forceCheckout = new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force };
+        Commands.Checkout(repo, toBranch, forceCheckout);
+
+        try
+        {
+            var sig = MakeSig();
+            foreach (var commit in commitsOrdered)
+            {
+                ct.ThrowIfCancellationRequested();
+                Log($"  Applying {commit.Sha[..7]} {commit.MessageShort}...");
+
+                var result = repo.CherryPick(commit, sig);
+                switch (result.Status)
+                {
+                    case CherryPickStatus.CherryPicked:
+                        Log($"    \u2714 \u2192 {result.Commit!.Sha[..7]}");
+                        break;
+                    case CherryPickStatus.Conflicts:
+                        Log($"    \u2716 Conflict \u2014 aborting and rolling back");
+                        repo.Reset(ResetMode.Hard, repo.Lookup<Commit>(savedToSha));
+                        throw new InvalidOperationException(
+                            $"Cherry-pick conflict on {commit.Sha[..7]}: {commit.MessageShort}. " +
+                            "Resolve conflicts manually or promote a different set of commits.");
+                    default:
+                        Log($"    \u2261 Already present or no changes \u2014 skipped");
+                        break;
+                }
+            }
+
+            // 6. Push
+            Log($"  Pushing {to} to origin...");
+            try
+            {
+                repo.Network.Push(remote, $"refs/heads/{to}:refs/heads/{to}", MakePushOptions());
+            }
+            catch
+            {
+                repo.Reset(ResetMode.Hard, repo.Lookup<Commit>(savedToSha));
+                throw;
+            }
+
+            Log("──────────────────────────────────────");
+            Log($"✔ Cherry-picked {commitsOrdered.Count} commit(s) to {to} at {DateTimeOffset.UtcNow:u}");
+            req.Status      = PromotionStatus.Succeeded;
+            req.CompletedAt = DateTimeOffset.UtcNow;
+        }
+        finally
+        {
+            // Always restore HEAD to the original branch regardless of outcome
+            try
+            {
+                var headBranch = repo.Branches[originalHeadBranchName];
+                if (headBranch is not null)
+                    Commands.Checkout(repo, headBranch, new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force });
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Could not restore HEAD to '{Branch}' after cherry-pick", originalHeadBranchName);
+            }
+        }
+    }
+
+    // ── Conformance check ────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Evaluates whether all branches in the TBD ladder are in conformance:
+    /// develop → staging → uat → main must form a strict linear ancestry chain with no divergence.
+    /// </summary>
+    public Task<ConformanceReport> GetConformanceAsync(string repoName = "Clarity", CancellationToken ct = default) =>
+        Task.Run(() => GetConformanceCore(repoName, ct), ct);
+
+    private ConformanceReport GetConformanceCore(string repoName, CancellationToken ct)
+    {
+        var repoPath = GetRepoPath(repoName);
+        var checks   = new List<BranchConformanceCheck>();
+
+        if (string.IsNullOrWhiteSpace(repoPath) || !Directory.Exists(repoPath))
+        {
+            foreach (var b in Ladder)
+                checks.Add(new BranchConformanceCheck(b, null, ConformanceViolation.Missing, ConformanceSeverity.Critical,
+                    $"Repository '{repoName}' is not configured or the path does not exist.", 0, 0, null));
+            return new ConformanceReport(repoName, false, checks.ToArray());
+        }
+
+        using var repo = new Repository(repoPath);
+
+        // Fetch latest remote refs — swallow network errors so status still works offline.
+        try
+        {
+            var remote   = EnsureRemote(repo, repoName);
+            var refSpecs = remote.FetchRefSpecs.Select(r => r.Specification).ToList();
+            repo.Network.Fetch(remote.Name, refSpecs, MakeFetchOptions());
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Fetch during conformance check failed — continuing with cached refs");
+        }
+
+        for (var i = 0; i < Ladder.Length; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var branchName = Ladder[i];
+            var srcName    = i > 0 ? Ladder[i - 1] : null; // predecessor branch (e.g. develop for staging)
+            // Always read from origin/ tracking refs — never local branch pointers.
+            var branch     = repo.Branches[$"origin/{branchName}"];
+
+            // ── Branch missing ──────────────────────────────────────────────
+            if (branch?.Tip is null)
+            {
+                var srcTip = srcName is not null ? repo.Branches[$"origin/{srcName}"]?.Tip?.Sha : null;
+                checks.Add(new BranchConformanceCheck(
+                    branchName, srcName,
+                    ConformanceViolation.Missing,
+                    srcName is null ? ConformanceSeverity.Critical : ConformanceSeverity.Info,
+                    srcName is not null
+                        ? $"Branch '{branchName}' does not exist. It should be created from '{srcName}'."
+                        : $"Trunk branch '{branchName}' does not exist — the repository may be empty.",
+                    0, 0, srcTip));
+                continue;
+            }
+
+            // ── Trunk (develop) — just needs to exist ───────────────────────
+            if (srcName is null)
+            {
+                checks.Add(new BranchConformanceCheck(
+                    branchName, null, ConformanceViolation.OK, ConformanceSeverity.OK,
+                    $"Trunk branch '{branchName}' exists.", 0, 0, null));
+                continue;
+            }
+
+            var srcBranch = repo.Branches[$"origin/{srcName}"];
+            if (srcBranch?.Tip is null)
+            {
+                // Source branch is itself missing — skip, it will be reported separately.
+                checks.Add(new BranchConformanceCheck(
+                    branchName, srcName, ConformanceViolation.OK, ConformanceSeverity.OK,
+                    $"Source branch '{srcName}' is missing — check skipped.", 0, 0, null));
+                continue;
+            }
+
+            // CalculateHistoryDivergence(srcTip, branchTip):
+            //   AheadBy  = commits srcBranch has that branch doesn't  → branch is pending promotion (stale)
+            //   BehindBy = commits branch has that srcBranch doesn't  → branch is DIVERGED (violation)
+            var div    = repo.ObjectDatabase.CalculateHistoryDivergence(srcBranch.Tip, branch.Tip);
+            var ahead  = div.AheadBy  ?? 0;
+            var behind = div.BehindBy ?? 0;
+
+            if (behind > 0)
+            {
+                // Downstream has commits the upstream doesn't — TBD violation (broken linear history).
+                checks.Add(new BranchConformanceCheck(
+                    branchName, srcName,
+                    ConformanceViolation.Diverged, ConformanceSeverity.Critical,
+                    $"'{branchName}' has {behind} commit(s) not reachable from '{srcName}'. " +
+                    $"This breaks TBD linear history. Likely caused by a commit made directly to '{branchName}' " +
+                    $"without backporting to trunk. Fix: reset '{branchName}' to '{srcName}' tip.",
+                    behind, ahead,
+                    srcBranch.Tip.Sha));
+            }
+            else if (ahead > 0)
+            {
+                // Upstream has unreleased commits — normal TBD state, but flag if count is high.
+                var sev = ahead > 10 ? ConformanceSeverity.Warning : ConformanceSeverity.Info;
+                checks.Add(new BranchConformanceCheck(
+                    branchName, srcName,
+                    ConformanceViolation.Stale, sev,
+                    $"'{branchName}' is {ahead} commit(s) behind '{srcName}'. " +
+                    (ahead > 10 ? "Large backlog — consider promoting soon." : "Pending promotion."),
+                    0, ahead, null));
+            }
+            else
+            {
+                checks.Add(new BranchConformanceCheck(
+                    branchName, srcName, ConformanceViolation.OK, ConformanceSeverity.OK,
+                    $"'{branchName}' is fully in sync with '{srcName}'.", 0, 0, null));
+            }
+        }
+
+        var isConformant = !checks.Any(c =>
+            c.Violation is ConformanceViolation.Diverged or ConformanceViolation.Missing);
+
+        return new ConformanceReport(repoName, isConformant, checks.ToArray());
+    }
+
+    // ── Create branch ─────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Creates a new branch at the given commit SHA and pushes it to origin.
+    /// Used to create missing ladder branches (e.g. staging, uat) from their source branch tip.
+    /// </summary>
+    public Task CreateBranchAsync(string branchName, string fromSha, string repoName, CancellationToken ct) =>
+        Task.Run(() =>
+        {
+            var repoPath = GetRepoPath(repoName);
+            using var repo = new Repository(repoPath);
+
+            if (repo.Branches[branchName] is not null)
+                throw new InvalidOperationException($"Branch '{branchName}' already exists in {repoName}.");
+
+            var commit = repo.Lookup<Commit>(fromSha)
+                ?? throw new InvalidOperationException($"SHA '{fromSha}' not found in {repoName}.");
+
+            repo.Refs.Add($"refs/heads/{branchName}", commit.Sha);
+
+            var remote = EnsureRemote(repo, repoName);
+
+            repo.Network.Push(remote, $"refs/heads/{branchName}:refs/heads/{branchName}", MakePushOptions());
+
+            logger.LogInformation("Created branch {Branch} at {Sha} in {Repo}", branchName, commit.Sha[..7], repoName);
+        }, ct);
+
     // ── History persistence ──────────────────────────────────────────────────
 
     private string HistoryPath
@@ -231,46 +745,111 @@ public class PromotionService(IConfiguration config, ILogger<PromotionService> l
         catch { return []; }
     }
 
-    // ── Git helpers ──────────────────────────────────────────────────────────
+    // ── OPC number extraction ─────────────────────────────────────────────
 
-    private async Task<bool> BranchExistsAsync(string branch, CancellationToken ct)
+    private static readonly System.Text.RegularExpressions.Regex OpcTagPattern =
+        new(@"OPC\s*#\s*(\d+)", System.Text.RegularExpressions.RegexOptions.IgnoreCase
+                              | System.Text.RegularExpressions.RegexOptions.Compiled);
+
+    /// <summary>
+    /// Scans the most recent <paramref name="limit"/> commits on <paramref name="branch"/> and
+    /// returns a distinct, sorted list of OPC numbers referenced in commit messages (e.g. "OPC # 0042").
+    /// Safe to call when git is not configured — returns an empty list on any error.
+    /// </summary>
+    public Task<List<string>> ExtractOpcNumbersAsync(
+        string repoName = "Clarity",
+        string branch   = "main",
+        int    limit    = 50,
+        CancellationToken ct = default) =>
+        Task.Run(() => ExtractOpcNumbersCore(repoName, branch, limit), ct);
+
+    private List<string> ExtractOpcNumbersCore(string repoName, string branch, int limit)
     {
-        var output = await GitOutputAsync($"branch --list {branch}", ct);
+        var repoPath = GetRepoPath(repoName);
-        return !string.IsNullOrWhiteSpace(output);
+        if (string.IsNullOrWhiteSpace(repoPath) || !Directory.Exists(repoPath))
+            return [];
+        try
+        {
+            using var repo = new Repository(repoPath);
+            var b = repo.Branches[branch] ?? repo.Branches[$"origin/{branch}"];
+            if (b is null) return [];
+
+            var set = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var commit in b.Commits.Take(limit))
+                foreach (System.Text.RegularExpressions.Match m in OpcTagPattern.Matches(commit.Message))
+                    set.Add($"OPC # {m.Groups[1].Value.PadLeft(4, '0')}");
+
+            return [.. set.OrderBy(x => x)];
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "ExtractOpcNumbers failed for {Repo}/{Branch}", repoName, branch);
+            return [];
+        }
     }
 
-    private async Task<string> GitOutputAsync(string args, CancellationToken ct)
+    /// <summary>
+    /// Returns distinct, sorted OPC numbers for commits reachable from <paramref name="toSha"/>
+    /// that are NOT reachable from <paramref name="fromSha"/> — i.e. the exact delta for this release.
+    /// Falls back to <see cref="ExtractOpcNumbersAsync"/> (last 50 commits) when <paramref name="fromSha"/>
+    /// is null (first-ever release for this environment).
+    /// </summary>
+    public Task<List<string>> ExtractOpcNumbersDeltaAsync(
+        string  repoName,
+        string  toSha,
+        string? fromSha,
+        CancellationToken ct = default) =>
+        fromSha is null
+            ? ExtractOpcNumbersAsync(repoName, ct: ct)
+            : Task.Run(() => ExtractOpcNumbersDeltaCore(repoName, toSha, fromSha), ct);
+
+    private List<string> ExtractOpcNumbersDeltaCore(string repoName, string toSha, string fromSha)
     {
-        var psi = MakePsi(args);
+        var repoPath = GetRepoPath(repoName);
-        using var proc = Process.Start(psi) ?? throw new InvalidOperationException("Failed to start git");
+        if (string.IsNullOrWhiteSpace(repoPath) || !Directory.Exists(repoPath))
-        var output = await proc.StandardOutput.ReadToEndAsync(ct);
+            return [];
-        await proc.WaitForExitAsync(ct);
+        try
-        return output;
+        {
+            using var repo = new Repository(repoPath);
+            var toCommit   = repo.Lookup<Commit>(toSha);
+            var fromCommit = repo.Lookup<Commit>(fromSha);
+            if (toCommit is null) return [];
+
+            var filter = fromCommit is null
+                ? new CommitFilter { IncludeReachableFrom = toCommit }
+                : new CommitFilter { IncludeReachableFrom = toCommit, ExcludeReachableFrom = fromCommit };
+
+            var set = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var commit in repo.Commits.QueryBy(filter))
+                foreach (System.Text.RegularExpressions.Match m in OpcTagPattern.Matches(commit.Message))
+                    set.Add($"OPC # {m.Groups[1].Value.PadLeft(4, '0')}");
+
+            return [.. set.OrderBy(x => x)];
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "ExtractOpcNumbersDelta failed for {Repo} {From}..{To}", repoName, fromSha[..7], toSha[..7]);
+            return [];
+        }
     }
 
-    private async Task RunGitAsync(string args, CancellationToken ct, bool swallowErrors = false)
+    /// <summary>Returns the full HEAD SHA of <paramref name="branch"/> in <paramref name="repoName"/>, or null.</summary>
+    public string? GetBranchTipSha(string repoName, string branch)
     {
-        var psi = MakePsi(args);
+        var repoPath = GetRepoPath(repoName);
-        using var proc = Process.Start(psi) ?? throw new InvalidOperationException("Failed to start git");
+        if (string.IsNullOrWhiteSpace(repoPath) || !Directory.Exists(repoPath)) return null;
-        var stderr = await proc.StandardError.ReadToEndAsync(ct);
+        try
-        await proc.WaitForExitAsync(ct);
+        {
-
+            using var repo = new Repository(repoPath);
-        if (!swallowErrors && proc.ExitCode != 0)
+            return (repo.Branches[$"origin/{branch}"] ?? repo.Branches[branch])?.Tip?.Sha;
-            throw new InvalidOperationException($"git {args} exited {proc.ExitCode}: {stderr.Trim()}");
+        }
-
+        catch { return null; }
-        logger.LogDebug("git {Args} → exit {Code}", args, proc.ExitCode);
     }
-
-    private ProcessStartInfo MakePsi(string args) => new("git", args)
-    {
-        WorkingDirectory       = RepoRoot,
-        RedirectStandardOutput = true,
-        RedirectStandardError  = true,
-        UseShellExecute        = false,
-        CreateNoWindow         = true,
-    };
 }
 
+/// <summary>A single unreleased commit — carries full SHA for cherry-pick operations.</summary>
+public record CommitInfo(string Sha, string ShortSha, string Message, string Author, string Date);
+
 /// <summary>Current status of a single branch in the promotion ladder.</summary>
 public record BranchStatus(
     string       Branch,
@@ -278,6 +857,7 @@ public record BranchStatus(
     string?      ShortHash,
     string?      LastCommitSummary,
     int          AheadOfNext,       // commits this branch has that the next doesn't
-    int      BehindNext,     // commits next has that this branch doesn't (shouldn't happen in clean flow)
+    int          BehindNext,        // commits next has that this branch doesn't (diverged)
-    string[] UnreleasedLines // oneline log of the ahead commits
+    CommitInfo[] UnreleasedCommits, // rich commit objects for cherry-pick UI
+    string?      TipSha = null      // full 40-char SHA for build-gate checks
 );

ControlPlane.Api/Services/ReleaseService.cs

@@ -17,6 +17,7 @@ public class ReleaseService(
     IConfiguration config,
     TenantRegistryService registry,
     BuildHistoryService history,
+    PromotionService promotions,
     ILogger<ReleaseService> logger)
 {
     private static readonly SemaphoreSlim _lock = new(1, 1);
@@ -50,7 +51,12 @@ public class ReleaseService(
             return blocked;
         }
 
-        var record = await history.CreateReleaseAsync(targetEnv, ImageName);
+        // Resolve the Clarity branch for this environment and stamp the HEAD SHA
+        // before creating the record so we capture "what was deployed" accurately.
+        var branch    = targetEnv switch { "fdev" => "develop", "staging" => "staging", "uat" => "uat", _ => "main" };
+        var currentSha = promotions.GetBranchTipSha("Clarity", branch);
+
+        var record = await history.CreateReleaseAsync(targetEnv, ImageName, currentSha);
 
         try
         {
@@ -182,6 +188,18 @@ public class ReleaseService(
         }
         finally
         {
+            // Stamp the exact OPC ticket numbers introduced by this release:
+            // diff from previous release's SHA to this release's SHA on the Clarity branch.
+            try
+            {
+                var prev = await history.GetLastSuccessfulReleaseForEnvAsync(targetEnv);
+                // Exclude the current (in-flight) record — it's not succeeded yet
+                var prevSha = prev?.Id == record.Id ? null : prev?.CommitSha;
+                if (currentSha is not null)
+                    record.OpcNumbers = await promotions.ExtractOpcNumbersDeltaAsync("Clarity", currentSha, prevSha, ct);
+            }
+            catch { /* git not configured — continue without OPC stamp */ }
+
             await history.UpdateReleaseAsync(record);
             _lock.Release();
         }

ControlPlane.Core/ControlPlane.Core.csproj

@@ -5,6 +5,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+    <PackageReference Include="Npgsql" />
   </ItemGroup>
 
 </Project>

ControlPlane.Core/Interfaces/SagaContext.cs

@@ -24,6 +24,11 @@ public class SagaContext
     // Written by LaunchStep — primary app container name
     public string? ContainerName { get; set; }
 
+    // Written by VaultStep — scoped periodic token for the tenant (not the root token)
+    // and its accessor used for compensation/revocation
+    public string? VaultToken { get; set; }
+    public string? VaultTokenAccessor { get; set; }
+
     // Written by PulumiStep (DedicatedVM/Enterprise tier) — target host details for subsequent steps
     public string? VmIpAddress { get; set; }
     public string? VmSshKeyPath { get; set; }

ControlPlane.Core/Models/BuildRecord.cs

@@ -4,7 +4,7 @@ using System.Text.Json.Serialization;
 namespace ControlPlane.Core.Models;
 
 public enum BuildStatus { Running, Succeeded, Failed }
-public enum BuildKind   { DockerImage, DotnetProject, NpmProject }
+public enum BuildKind   { DockerImage, DotnetProject, NpmProject, SolutionBuild }
 
 /// <summary>
 /// Persisted record of a single build run — image build, dotnet build, or npm build.
@@ -20,5 +20,6 @@ public class BuildRecord
     public DateTimeOffset? FinishedAt  { get; set; }
     public int?            DurationMs  { get; set; }
     public string?         ImageDigest { get; set; }  // populated for DockerImage builds
+    public string?         CommitSha   { get; set; }  // HEAD SHA at build time
     public List<string>    Log         { get; set; } = [];
 }

ControlPlane.Core/Models/ConformanceModels.cs

@@ -0,0 +1,28 @@
+namespace ControlPlane.Core.Models;
+
+public enum ConformanceViolation { OK, Missing, Diverged, Stale }
+public enum ConformanceSeverity  { OK, Info, Warning, Critical }
+
+/// <summary>
+/// The conformance state of one branch in the TBD ladder relative to its upstream source.
+/// </summary>
+public record BranchConformanceCheck(
+    string Branch,
+    string? SourceBranch,   // the upstream branch this is derived from (null for trunk)
+    ConformanceViolation Violation,
+    ConformanceSeverity Severity,
+    string Detail,
+    int AheadOfSource,      // commits this branch has that source doesn't — diverged
+    int BehindSource,       // commits source has that this branch doesn't — pending promotion
+    string? FixSha          // source tip SHA — used when resetting to fix divergence
+);
+
+/// <summary>
+/// Full TBD conformance report for a single repository.
+/// IsConformant = no Diverged or Missing violations exist.
+/// </summary>
+public record ConformanceReport(
+    string Repo,
+    bool IsConformant,
+    BranchConformanceCheck[] Checks
+);

ControlPlane.Core/Models/ReleaseRecord.cs

@@ -16,6 +16,8 @@ public class ReleaseRecord
     public DateTimeOffset  StartedAt   { get; set; } = DateTimeOffset.UtcNow;
     public DateTimeOffset? FinishedAt  { get; set; }
     public List<TenantReleaseResult> Tenants    { get; set; } = [];
+    public List<string>              OpcNumbers { get; set; } = [];
+    public string?                   CommitSha  { get; set; }  // Clarity branch HEAD SHA at release time
 }
 
 public class TenantReleaseResult

ControlPlane.Core/Services/BuildHistoryService.cs

@@ -1,46 +1,36 @@
 using System.Text.Json;
 using ControlPlane.Core.Models;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
+using Npgsql;
 
 namespace ControlPlane.Core.Services;
 
 /// <summary>
-/// Persists build and release history to JSON files in the ClientAssets folder.
+/// Persists build and release history to opcdb (Postgres).
-/// Thread-safe — all writes go through a single lock per file.
+/// Replaces the previous JSON-file implementation.
+/// NpgsqlDataSource is singleton and manages the connection pool; this service is safe to register as singleton.
 /// </summary>
-public class BuildHistoryService
+public class BuildHistoryService(NpgsqlDataSource db, ILogger<BuildHistoryService> logger)
 {
-    private readonly string _buildsPath;
-    private readonly string _releasesPath;
-    private readonly ILogger<BuildHistoryService> _logger;
-
-    private static readonly SemaphoreSlim _buildLock   = new(1, 1);
-    private static readonly SemaphoreSlim _releaseLock = new(1, 1);
-
-    private static readonly JsonSerializerOptions JsonOpts = new()
-    {
-        WriteIndented          = true,
-        PropertyNamingPolicy   = JsonNamingPolicy.CamelCase,
-        Converters             = { new System.Text.Json.Serialization.JsonStringEnumConverter() },
-    };
-
-    public BuildHistoryService(IConfiguration config, ILogger<BuildHistoryService> logger)
-    {
-        var folder = config["ClientAssets__Folder"] ?? config["ClientAssets:Folder"]
-                     ?? Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "ClientAssets"));
-        Directory.CreateDirectory(folder);
-        _buildsPath   = Path.Combine(folder, "builds.json");
-        _releasesPath = Path.Combine(folder, "releases.json");
-        _logger = logger;
-    }
-
     // ── Builds ──────────────────────────────────────────────────────────────
 
     public async Task<BuildRecord> CreateBuildAsync(BuildKind kind, string target)
     {
         var record = new BuildRecord { Kind = kind, Target = target };
-        await SaveBuildAsync(record);
+
+        await using var cmd = db.CreateCommand("""
+            INSERT INTO build_record (id, kind, target, status, started_at, commit_sha, log)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            """);
+        cmd.Parameters.AddWithValue(record.Id);
+        cmd.Parameters.AddWithValue(record.Kind.ToString());
+        cmd.Parameters.AddWithValue(record.Target);
+        cmd.Parameters.AddWithValue(record.Status.ToString());
+        cmd.Parameters.AddWithValue(record.StartedAt);
+        cmd.Parameters.AddWithValue((object?)record.CommitSha ?? DBNull.Value);
+        cmd.Parameters.AddWithValue(string.Empty);
+        await cmd.ExecuteNonQueryAsync();
+
         return record;
     }
 
@@ -50,89 +40,251 @@ public class BuildHistoryService
         record.FinishedAt  = DateTimeOffset.UtcNow;
         record.DurationMs  = (int)(record.FinishedAt.Value - record.StartedAt).TotalMilliseconds;
         record.ImageDigest = digest;
-        await SaveBuildAsync(record);
+
+        await using var cmd = db.CreateCommand("""
+            UPDATE build_record
+            SET status = $2, finished_at = $3, duration_ms = $4, image_digest = $5, commit_sha = $6, log = $7
+            WHERE id = $1
+            """);
+        cmd.Parameters.AddWithValue(record.Id);
+        cmd.Parameters.AddWithValue(record.Status.ToString());
+        cmd.Parameters.AddWithValue(record.FinishedAt!.Value);
+        cmd.Parameters.AddWithValue((object?)record.DurationMs ?? DBNull.Value);
+        cmd.Parameters.AddWithValue((object?)record.ImageDigest ?? DBNull.Value);
+        cmd.Parameters.AddWithValue((object?)record.CommitSha ?? DBNull.Value);
+        cmd.Parameters.AddWithValue(string.Join('\n', record.Log));
+        await cmd.ExecuteNonQueryAsync();
     }
 
     public async Task AppendBuildLogAsync(BuildRecord record, string line)
     {
         record.Log.Add(line);
-        // Flush to disk every 20 lines to avoid excessive I/O but keep reasonable freshness
+        // Flush to Postgres every 20 lines — keeps the live log queryable without hammering the DB
         if (record.Log.Count % 20 == 0)
-            await SaveBuildAsync(record);
+            await FlushLogAsync(record);
+    }
+
+    private async Task FlushLogAsync(BuildRecord record)
+    {
+        await using var cmd = db.CreateCommand("UPDATE build_record SET log = $2 WHERE id = $1");
+        cmd.Parameters.AddWithValue(record.Id);
+        cmd.Parameters.AddWithValue(string.Join('\n', record.Log));
+        await cmd.ExecuteNonQueryAsync();
     }
 
     public async Task<List<BuildRecord>> GetBuildsAsync()
     {
-        await _buildLock.WaitAsync();
+        var result = new List<BuildRecord>();
-        try   { return LoadJson<BuildRecord>(_buildsPath); }
+
-        finally { _buildLock.Release(); }
+        await using var cmd = db.CreateCommand("""
+            SELECT id, kind, target, status, started_at, finished_at, duration_ms, image_digest, commit_sha, log
+            FROM build_record
+            ORDER BY started_at DESC
+            LIMIT 100
+            """);
+        await using var reader = await cmd.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            var logText = reader.IsDBNull(9) ? "" : reader.GetString(9);
+            result.Add(new BuildRecord
+            {
+                Id          = reader.GetString(0),
+                Kind        = Enum.Parse<BuildKind>(reader.GetString(1)),
+                Target      = reader.GetString(2),
+                Status      = Enum.Parse<BuildStatus>(reader.GetString(3)),
+                StartedAt   = reader.GetFieldValue<DateTimeOffset>(4),
+                FinishedAt  = reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5),
+                DurationMs  = reader.IsDBNull(6) ? null : reader.GetInt32(6),
+                ImageDigest = reader.IsDBNull(7) ? null : reader.GetString(7),
+                CommitSha   = reader.IsDBNull(8) ? null : reader.GetString(8),
+                Log         = logText.Length == 0 ? [] : [.. logText.Split('\n')],
+            });
         }
 
-    private async Task SaveBuildAsync(BuildRecord record)
+        return result;
-    {
-        await _buildLock.WaitAsync();
-        try
-        {
-            var all = LoadJson<BuildRecord>(_buildsPath);
-            var idx = all.FindIndex(b => b.Id == record.Id);
-            if (idx >= 0) all[idx] = record;
-            else          all.Insert(0, record);
-
-            // Keep last 100 builds
-            if (all.Count > 100) all = all[..100];
-            await File.WriteAllTextAsync(_buildsPath, JsonSerializer.Serialize(all, JsonOpts));
     }
-        finally { _buildLock.Release(); }
+
+    // ── Builds by SHA ────────────────────────────────────────────────────────
+
+    /// <summary>Returns all build records whose <c>commit_sha</c> exactly matches <paramref name="sha"/>.</summary>
+    public async Task<List<BuildRecord>> GetBuildsByShaAsync(string sha)
+    {
+        var result = new List<BuildRecord>();
+
+        await using var cmd = db.CreateCommand("""
+            SELECT id, kind, target, status, started_at, finished_at, duration_ms, image_digest, commit_sha, log
+            FROM build_record
+            WHERE commit_sha = $1
+            ORDER BY started_at DESC
+            """);
+        cmd.Parameters.AddWithValue(sha);
+        await using var reader = await cmd.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            var logText = reader.IsDBNull(9) ? "" : reader.GetString(9);
+            result.Add(new BuildRecord
+            {
+                Id          = reader.GetString(0),
+                Kind        = Enum.Parse<BuildKind>(reader.GetString(1)),
+                Target      = reader.GetString(2),
+                Status      = Enum.Parse<BuildStatus>(reader.GetString(3)),
+                StartedAt   = reader.GetFieldValue<DateTimeOffset>(4),
+                FinishedAt  = reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5),
+                DurationMs  = reader.IsDBNull(6) ? null : reader.GetInt32(6),
+                ImageDigest = reader.IsDBNull(7) ? null : reader.GetString(7),
+                CommitSha   = reader.IsDBNull(8) ? null : reader.GetString(8),
+                Log         = logText.Length == 0 ? [] : [.. logText.Split('\n')],
+            });
+        }
+
+        return result;
     }
 
     // ── Releases ────────────────────────────────────────────────────────────
 
-    public async Task<ReleaseRecord> CreateReleaseAsync(string environment, string imageName)
+    public async Task<ReleaseRecord> CreateReleaseAsync(string environment, string imageName, string? commitSha = null)
     {
-        var record = new ReleaseRecord { Environment = environment, ImageName = imageName };
+        var record = new ReleaseRecord { Environment = environment, ImageName = imageName, CommitSha = commitSha };
-        await SaveReleaseAsync(record);
+
+        await using var cmd = db.CreateCommand("""
+            INSERT INTO release_record (id, environment, image_name, status, started_at, opc_numbers, commit_sha)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            """);
+        cmd.Parameters.AddWithValue(record.Id);
+        cmd.Parameters.AddWithValue(record.Environment);
+        cmd.Parameters.AddWithValue(record.ImageName);
+        cmd.Parameters.AddWithValue(record.Status.ToString());
+        cmd.Parameters.AddWithValue(record.StartedAt);
+        cmd.Parameters.Add(new NpgsqlParameter<string[]> { TypedValue = [.. record.OpcNumbers] });
+        cmd.Parameters.AddWithValue((object?)record.CommitSha ?? DBNull.Value);
+        await cmd.ExecuteNonQueryAsync();
+
         return record;
     }
 
     public async Task UpdateReleaseAsync(ReleaseRecord record)
     {
         record.FinishedAt = DateTimeOffset.UtcNow;
-        await SaveReleaseAsync(record);
+
+        await using var conn = await db.OpenConnectionAsync();
+        await using var tx   = await conn.BeginTransactionAsync();
+
+        await using var upd = new NpgsqlCommand("""
+            UPDATE release_record SET status = $2, finished_at = $3, opc_numbers = $4, commit_sha = $5 WHERE id = $1
+            """, conn, tx);
+        upd.Parameters.AddWithValue(record.Id);
+        upd.Parameters.AddWithValue(record.Status.ToString());
+        upd.Parameters.AddWithValue(record.FinishedAt!.Value);
+        upd.Parameters.Add(new NpgsqlParameter<string[]> { TypedValue = [.. record.OpcNumbers] });
+        upd.Parameters.AddWithValue((object?)record.CommitSha ?? DBNull.Value);
+        await upd.ExecuteNonQueryAsync();
+
+        // Replace tenant results wholesale on each update
+        await using var del = new NpgsqlCommand(
+            "DELETE FROM release_tenant_result WHERE release_id = $1", conn, tx);
+        del.Parameters.AddWithValue(record.Id);
+        await del.ExecuteNonQueryAsync();
+
+        foreach (var t in record.Tenants)
+        {
+            await using var ins = new NpgsqlCommand("""
+                INSERT INTO release_tenant_result (release_id, subdomain, container_name, success, error)
+                VALUES ($1, $2, $3, $4, $5)
+                """, conn, tx);
+            ins.Parameters.AddWithValue(record.Id);
+            ins.Parameters.AddWithValue(t.Subdomain);
+            ins.Parameters.AddWithValue(t.ContainerName);
+            ins.Parameters.AddWithValue(t.Success);
+            ins.Parameters.AddWithValue((object?)t.Error ?? DBNull.Value);
+            await ins.ExecuteNonQueryAsync();
+        }
+
+        await tx.CommitAsync();
     }
 
     public async Task<List<ReleaseRecord>> GetReleasesAsync()
     {
-        await _releaseLock.WaitAsync();
+        var ordered = new List<ReleaseRecord>();
-        try   { return LoadJson<ReleaseRecord>(_releasesPath); }
+        var lookup  = new Dictionary<string, ReleaseRecord>();
-        finally { _releaseLock.Release(); }
+
+        await using var cmd = db.CreateCommand("""
+            SELECT id, environment, image_name, status, started_at, finished_at, opc_numbers, commit_sha
+            FROM release_record
+            ORDER BY started_at DESC
+            LIMIT 50
+            """);
+        await using (var reader = await cmd.ExecuteReaderAsync())
+        {
+            while (await reader.ReadAsync())
+            {
+                var r = new ReleaseRecord
+                {
+                    Id          = reader.GetString(0),
+                    Environment = reader.GetString(1),
+                    ImageName   = reader.GetString(2),
+                    Status      = Enum.Parse<ReleaseStatus>(reader.GetString(3)),
+                    StartedAt   = reader.GetFieldValue<DateTimeOffset>(4),
+                    FinishedAt  = reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5),
+                    OpcNumbers  = reader.IsDBNull(6) ? [] : [.. reader.GetFieldValue<string[]>(6)],
+                    CommitSha   = reader.IsDBNull(7) ? null : reader.GetString(7),
+                };
+                ordered.Add(r);
+                lookup[r.Id] = r;
+            }
         }
 
-    private async Task SaveReleaseAsync(ReleaseRecord record)
+        if (lookup.Count == 0) return [];
-    {
-        await _releaseLock.WaitAsync();
-        try
-        {
-            var all = LoadJson<ReleaseRecord>(_releasesPath);
-            var idx = all.FindIndex(r => r.Id == record.Id);
-            if (idx >= 0) all[idx] = record;
-            else          all.Insert(0, record);
 
-            if (all.Count > 50) all = all[..50];
+        // Load all tenant results for the fetched release IDs in one query
-            await File.WriteAllTextAsync(_releasesPath, JsonSerializer.Serialize(all, JsonOpts));
+        await using var cmd2 = db.CreateCommand("""
-        }
+            SELECT release_id, subdomain, container_name, success, error
-        finally { _releaseLock.Release(); }
+            FROM release_tenant_result
+            WHERE release_id = ANY($1)
+            """);
+        cmd2.Parameters.Add(new NpgsqlParameter<string[]> { TypedValue = [.. lookup.Keys] });
+        await using var reader2 = await cmd2.ExecuteReaderAsync();
+        while (await reader2.ReadAsync())
+        {
+            if (lookup.TryGetValue(reader2.GetString(0), out var r))
+                r.Tenants.Add(new TenantReleaseResult
+                {
+                    Subdomain     = reader2.GetString(1),
+                    ContainerName = reader2.GetString(2),
+                    Success       = reader2.GetBoolean(3),
+                    Error         = reader2.IsDBNull(4) ? null : reader2.GetString(4),
+                });
         }
 
-    // ── Helpers ─────────────────────────────────────────────────────────────
+        return ordered;
-
-    private static List<T> LoadJson<T>(string path)
-    {
-        if (!File.Exists(path)) return [];
-        try
-        {
-            var json = File.ReadAllText(path);
-            return JsonSerializer.Deserialize<List<T>>(json, JsonOpts) ?? [];
     }
-        catch { return []; }
+
+    /// <summary>
+    /// Returns the most recent succeeded release for <paramref name="environment"/>, or null if none exists.
+    /// Used to calculate the OPC ticket delta between releases (previousSha..currentSha).
+    /// </summary>
+    public async Task<ReleaseRecord?> GetLastSuccessfulReleaseForEnvAsync(string environment)
+    {
+        await using var cmd = db.CreateCommand("""
+            SELECT id, environment, image_name, status, started_at, finished_at, opc_numbers, commit_sha
+            FROM release_record
+            WHERE environment = $1 AND status = 'Succeeded'
+            ORDER BY started_at DESC
+            LIMIT 1
+            """);
+        cmd.Parameters.AddWithValue(environment);
+        await using var reader = await cmd.ExecuteReaderAsync();
+        if (!await reader.ReadAsync()) return null;
+        return new ReleaseRecord
+        {
+            Id          = reader.GetString(0),
+            Environment = reader.GetString(1),
+            ImageName   = reader.GetString(2),
+            Status      = Enum.Parse<ReleaseStatus>(reader.GetString(3)),
+            StartedAt   = reader.GetFieldValue<DateTimeOffset>(4),
+            FinishedAt  = reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5),
+            OpcNumbers  = reader.IsDBNull(6) ? [] : [.. reader.GetFieldValue<string[]>(6)],
+            CommitSha   = reader.IsDBNull(7) ? null : reader.GetString(7),
+        };
     }
 }
+

ControlPlane.Worker/Services/ClarityContainerService.cs

@@ -105,13 +105,16 @@ public class ClarityContainerService(
                 ["clarity.subdomain"]              = subdomain,
                 ["clarity.siteCode"]               = siteCode,
                 ["clarity.env"]                    = environment,
+                // Groups containers in Docker Desktop by environment tier (fdev / uat / prod).
+                ["com.docker.compose.project"]     = $"clarity-{environment.ToLowerInvariant()}",
+                ["com.docker.compose.service"]     = name,
             },
         }, cancellationToken);
 
         // Ensure Keycloak and Vault are reachable on the managed network via their Docker DNS aliases.
         // Aspire places them on its own bridge; tenant containers on clarity-net need them aliased here.
-        await EnsureContainerOnNetworkAsync(docker, "keycloak", Infra.Network, "keycloak", cancellationToken);
+        await EnsureContainerOnNetworkAsync(docker, "clarity-keycloak", Infra.Network, "keycloak", cancellationToken);
-        await EnsureContainerOnNetworkAsync(docker, "vault",    Infra.Network, "vault",    cancellationToken);
+        await EnsureContainerOnNetworkAsync(docker, "clarity-vault",    Infra.Network, "vault",    cancellationToken);
 
         var started = await docker.Containers.StartContainerAsync(container.ID, null, cancellationToken);
         if (!started)
@@ -244,14 +247,13 @@ public class ClarityContainerService(
         {
             using var docker = CreateClient();
 
-            // Find the nginx container by image name — Aspire appends a random suffix to the name
+            // Find the nginx container by name — platform infra always uses "clarity-nginx".
-            // so we can't rely on the static name "nginx".
             var containers = await docker.Containers.ListContainersAsync(
                 new ContainersListParameters
                 {
                     Filters = new Dictionary<string, IDictionary<string, bool>>
                     {
-                        ["ancestor"] = new Dictionary<string, bool> { ["nginx"] = true }
+                        ["name"] = new Dictionary<string, bool> { ["clarity-nginx"] = true }
                     }
                 }, ct);
 

ControlPlane.Worker/Steps/KeycloakStep.cs

@@ -41,6 +41,17 @@ public class KeycloakStep(
         }, cancellationToken);
 
         // clarity-web-app: public OIDC client used by the React frontend.
+        // fdev is a developer dogfood environment — allow localhost redirect URIs so that a
+        // local Aspire dev loop (any port) can complete the OIDC flow against the shared
+        // OPC infra Keycloak without any post-provisioning patching.
+        var isFdev = string.Equals(context.Job.Environment, "fdev", StringComparison.OrdinalIgnoreCase);
+        var redirectUris = isFdev
+            ? new[] { $"{tenantOrigin}/*", "http://localhost:*/*", "http://*.dev.localhost:*/*" }
+            : new[] { $"{tenantOrigin}/*" };
+        var webOrigins = isFdev
+            ? "+"          // match all valid redirect URI origins
+            : tenantOrigin;
+
         await adminClient.CreateClientAsync(realmId, new
         {
             clientId                  = "clarity-web-app",
@@ -51,8 +62,8 @@ public class KeycloakStep(
             directAccessGrantsEnabled = false,
             rootUrl                   = tenantOrigin,
             baseUrl                   = "/",
-            redirectUris              = new[] { $"{tenantOrigin}/*" },
+            redirectUris,
-            webOrigins                = new[] { tenantOrigin },
+            webOrigins                = new[] { webOrigins },
         }, cancellationToken);
 
         // Ensure tokens issued by clarity-web-app include "clarity-rest-api" in the `aud` claim

ControlPlane.Worker/Steps/LaunchStep.cs

@@ -32,7 +32,7 @@ public class LaunchStep(
             subdomain:                job.Subdomain,
             keycloakRealm:            $"clarity-{job.Subdomain.ToLowerInvariant()}",
             postgresConnectionString: context.TenantConnectionString,
-            vaultToken:               ReadVaultToken(config),
+            vaultToken:               context.VaultToken ?? ReadVaultToken(config),
             jobId:                    job.Id,
             cancellationToken:        cancellationToken);
 

ControlPlane.Worker/Steps/VaultStep.cs

@@ -1,6 +1,9 @@
 using ControlPlane.Core.Interfaces;
 using ControlPlane.Core.Models;
+using System.Net.Http.Headers;
+using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 
 namespace ControlPlane.Worker.Steps;
 
@@ -8,38 +11,117 @@ public class VaultStep(ILogger<VaultStep> logger, IConfiguration config) : ISaga
 {
     public string StepName => "Cryptographic Pre-Flight (Vault)";
 
-    public Task ExecuteAsync(SagaContext context, CancellationToken cancellationToken)
+    // Policy grants the tenant token exactly the three Transit operations Clarity.Server needs:
+    //   GenerateTenantKEKAsync  → datakey/plaintext  (first boot only)
+    //   DecryptTenantKEKAsync   → decrypt            (every restart)
+    //   RewrapTenantKEKAsync    → rewrap             (key rotation)
+    private const string PolicyTemplate = """
+        path "clarity-transit/datakey/plaintext/master-key" {
+          capabilities = ["update"]
+        }
+        path "clarity-transit/decrypt/master-key" {
+          capabilities = ["update"]
+        }
+        path "clarity-transit/rewrap/master-key" {
+          capabilities = ["update"]
+        }
+        """;
+
+    public async Task ExecuteAsync(SagaContext context, CancellationToken cancellationToken)
     {
-        // TODO: VaultSharp
+        var rootToken = ReadRootToken();
-        // 1. Assert Transit engine is active and healthy
+        var vaultAddr = (config["Vault:Address"] ?? "http://localhost:8200").TrimEnd('/');
-        // 2. Derive/validate TenantContextId (e.g. FL_COM_001)
+        var subdomain = context.Job.Subdomain.ToLowerInvariant();
-        // 3. Register TenantContextId in a KV entry or TenantRegistry table
+        var policyName = $"clarity-tenant-{subdomain}";
-        //    so Clarity.Server can resolve the derivation path later
+
-        //
+        using var http = new HttpClient { BaseAddress = new Uri(vaultAddr) };
-        // Root token is read at runtime from the persisted init.json on the Vault volume:
+        http.DefaultRequestHeaders.Add("X-Vault-Token", rootToken);
-        //   var token = ReadRootToken();
+
-        logger.LogInformation("[{JobId}] Vault step is a stub - VaultSharp not yet wired.", context.Job.Id);
+        // ── 1. Assert Transit engine + master-key are healthy ─────────────────
+        logger.LogInformation("[{JobId}] Verifying Vault Transit engine and master-key.", context.Job.Id);
+        var healthRes = await http.GetAsync("v1/clarity-transit/keys/master-key", cancellationToken);
+        if (!healthRes.IsSuccessStatusCode)
+            throw new InvalidOperationException(
+                $"Vault Transit master-key not found at {vaultAddr}. " +
+                "Ensure OPC infra is running and the entrypoint has bootstrapped Vault.");
+
+        // ── 2. Upsert per-tenant policy (idempotent PUT) ──────────────────────
+        logger.LogInformation("[{JobId}] Writing Vault policy '{Policy}'.", context.Job.Id, policyName);
+        var policyBody = JsonSerializer.Serialize(new { policy = PolicyTemplate });
+        var policyRes = await http.PutAsync(
+            $"v1/sys/policies/acl/{policyName}",
+            new StringContent(policyBody, Encoding.UTF8, "application/json"),
+            cancellationToken);
+        policyRes.EnsureSuccessStatusCode();
+
+        // ── 3. Create scoped periodic token bound to tenant policy ────────────
+        logger.LogInformation("[{JobId}] Creating scoped Vault token for policy '{Policy}'.", context.Job.Id, policyName);
+        var tokenBody = JsonSerializer.Serialize(new
+        {
+            policies  = new[] { policyName },
+            period    = "72h",
+            renewable = true,
+            metadata  = new Dictionary<string, string>
+            {
+                ["tenant"]    = subdomain,
+                ["createdBy"] = "ControlPlane.Worker",
+            },
+        });
+        var tokenRes = await http.PostAsync(
+            "v1/auth/token/create",
+            new StringContent(tokenBody, Encoding.UTF8, "application/json"),
+            cancellationToken);
+        tokenRes.EnsureSuccessStatusCode();
+
+        var tokenJson = JsonNode.Parse(await tokenRes.Content.ReadAsStringAsync(cancellationToken))!;
+        context.VaultToken         = tokenJson["auth"]!["client_token"]!.GetValue<string>();
+        context.VaultTokenAccessor = tokenJson["auth"]!["accessor"]!.GetValue<string>();
+
+        logger.LogInformation("[{JobId}] Vault step complete. Token accessor: {Accessor}",
+            context.Job.Id, context.VaultTokenAccessor);
+
         context.Job.CompletedSteps |= CompletedSteps.VaultVerified;
-        return Task.CompletedTask;
     }
 
-    public Task CompensateAsync(SagaContext context, CancellationToken cancellationToken)
+    public async Task CompensateAsync(SagaContext context, CancellationToken cancellationToken)
     {
-        logger.LogInformation("[{JobId}] Vault step: no compensation needed.", context.Job.Id);
+        if (string.IsNullOrWhiteSpace(context.VaultTokenAccessor)) return;
-        return Task.CompletedTask;
+
+        logger.LogWarning("[{JobId}] Compensating Vault — revoking token accessor {Accessor}.",
+            context.Job.Id, context.VaultTokenAccessor);
+
+        try
+        {
+            var rootToken = ReadRootToken();
+            var vaultAddr = (config["Vault:Address"] ?? "http://localhost:8200").TrimEnd('/');
+            using var http = new HttpClient { BaseAddress = new Uri(vaultAddr) };
+            http.DefaultRequestHeaders.Add("X-Vault-Token", rootToken);
+
+            var body = JsonSerializer.Serialize(new { accessor = context.VaultTokenAccessor });
+            await http.PostAsync(
+                "v1/auth/token/revoke-accessor",
+                new StringContent(body, Encoding.UTF8, "application/json"),
+                cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "[{JobId}] Failed to revoke Vault token accessor {Accessor} during compensation.",
+                context.Job.Id, context.VaultTokenAccessor);
+        }
     }
 
-    /// <summary>
-    /// Reads the root token from the init.json written by the Vault entrypoint on first boot.
-    /// Path is injected via Vault__KeysFile config.
-    /// </summary>
     internal string ReadRootToken()
     {
-        var path = config["Vault__KeysFile"]
+        var path = config["Vault:KeysFile"] ?? config["Vault__KeysFile"];
-            ?? throw new InvalidOperationException("Vault__KeysFile is not configured.");
+        if (!string.IsNullOrWhiteSpace(path) && File.Exists(path))
-
+        {
             using var doc = JsonDocument.Parse(File.ReadAllText(path));
-        return doc.RootElement.GetProperty("root_token").GetString()
+            if (doc.RootElement.TryGetProperty("root_token", out var tok))
-            ?? throw new InvalidOperationException("root_token not found in Vault init.json.");
+                return tok.GetString()!;
+        }
+
+        return config["Vault:Token"]
+            ?? throw new InvalidOperationException(
+                "Cannot resolve Vault root token: neither Vault:KeysFile nor Vault:Token is configured.");
     }
 }

ControlPlane.Worker/appsettings.Development.json

@@ -0,0 +1,5 @@
+{
+  "Vault": {
+    "KeysFile": "C:\\Users\\amadzarak\\source\\repos\\ClarityStack\\OPC\\infra\\vault\\data\\init.json"
+  }
+}

ControlPlane.Worker/appsettings.json

@@ -20,7 +20,7 @@
 
   // ── Vault ─────────────────────────────────────────────────────────────────────
   // Worker uses localhost:8200 for admin calls.
-  // Vault__KeysFile is machine-specific → still injected by Aspire AppHost.
+  // Vault:KeysFile is machine-specific → set in appsettings.Development.json.
   "Vault": {
     "Address": "http://localhost:8200",
     "ContainerAddress": "http://vault:8200"

clarity.controlplane/package-lock.json

@@ -13,7 +13,8 @@
         "highlight.js": "^11.11.1",
         "react": "^18.3.1",
         "react-dom": "^18.3.1",
-        "react-multistep": "^7.0.0"
+        "react-multistep": "^7.0.0",
+        "react-router-dom": "^7.14.2"
       },
       "devDependencies": {
         "@eslint/js": "^9.39.4",
@@ -1710,6 +1711,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/cookie": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -3043,6 +3057,44 @@
         "react-dom": "^16.8.0 || ^17 || ^18"
       }
     },
+    "node_modules/react-router": {
+      "version": "7.14.2",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.14.2.tgz",
+      "integrity": "sha512-yCqNne6I8IB6rVCH7XUvlBK7/QKyqypBFGv+8dj4QBFJiiRX+FG7/nkdAvGElyvVZ/HQP5N19wzteuTARXi5Gw==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "^1.0.1",
+        "set-cookie-parser": "^2.6.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/react-router-dom": {
+      "version": "7.14.2",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.14.2.tgz",
+      "integrity": "sha512-YZcM5ES8jJSM+KrJ9BdvHHqlnGTg5tH3sC5ChFRj4inosKctdyzBDhOyyHdGk597q2OT6NTrCA1OvB/YDwfekQ==",
+      "license": "MIT",
+      "dependencies": {
+        "react-router": "7.14.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      }
+    },
     "node_modules/react-transition-group": {
       "version": "4.4.5",
       "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
@@ -3140,6 +3192,12 @@
         "upper-case-first": "^2.0.2"
       }
     },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
+      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
+      "license": "MIT"
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",

clarity.controlplane/package.json

@@ -15,7 +15,8 @@
     "highlight.js": "^11.11.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-multistep": "^7.0.0"
+    "react-multistep": "^7.0.0",
+    "react-router-dom": "^7.14.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",

clarity.controlplane/src/App.tsx

@@ -1,6 +1,6 @@
 import '@blueprintjs/core/lib/css/blueprint.css';
 import './App.css';
-import { useState } from 'react';
+import { Navigate, Route, Routes, useLocation, useNavigate } from 'react-router-dom';
 import { Menu, MenuItem, MenuDivider } from '@blueprintjs/core';
 import DashboardPage from './pages/DashboardPage';
 import PipelinesPage from './pages/PipelinesPage';
@@ -11,12 +11,12 @@ import OpcPage from './opc/OpcPage';
 import InfraPage from './pages/InfraPage';
 import ChangesetsPage from './pages/ChangesetsPage';
 
-function App() {
+function Sidebar() {
-  const [activeNav, setActiveNav] = useState('opc');
+  const navigate     = useNavigate();
+  const { pathname } = useLocation();
+  const at           = (path: string) => pathname === path || pathname.startsWith(path + '/');
 
   return (
-    <div className="cp-shell">
-      {/* ── Sidebar ── */}
     <aside className="cp-sidebar">
       <div className="cp-sidebar-brand">
         <span className="brand-mark">CP</span>
@@ -25,17 +25,17 @@ function App() {
 
       <div className="cp-sidebar-nav">
         <Menu className="cp-sidebar-menu">
-            <MenuItem icon="cloud-upload" text="Deployments" active={activeNav === 'deployments'} onClick={() => setActiveNav('deployments')} />
+          <MenuItem icon="cloud-upload" text="Deployments"   active={at('/deployments')}   onClick={() => navigate('/deployments')} />
-            <MenuItem icon="git-branch"   text="Pipelines"   active={activeNav === 'pipelines'}    onClick={() => setActiveNav('pipelines')} />
+          <MenuItem icon="git-branch"   text="Pipelines"     active={at('/pipelines')}      onClick={() => navigate('/pipelines')} />
-            <MenuItem icon="git-merge"     text="Branch Ladder" active={activeNav === 'branches'}   onClick={() => setActiveNav('branches')} />
+          <MenuItem icon="git-merge"    text="Branch Ladder" active={at('/branches')}       onClick={() => navigate('/branches')} />
-            <MenuItem icon="build"        text="Image Build" active={activeNav === 'image-build'}  onClick={() => setActiveNav('image-build')} />
+          <MenuItem icon="build"        text="Image Build"   active={at('/image-build')}    onClick={() => navigate('/image-build')} />
-            <MenuItem icon="pulse"        text="Build Monitor" active={activeNav === 'build-monitor'} onClick={() => setActiveNav('build-monitor')} />
+          <MenuItem icon="pulse"        text="Build Monitor" active={at('/build-monitor')}  onClick={() => navigate('/build-monitor')} />
           <MenuDivider />
-            <MenuItem icon="heat-grid"  text="Infrastructure" active={activeNav === 'infra'}       onClick={() => setActiveNav('infra')} />
+          <MenuItem icon="heat-grid"    text="Infrastructure" active={at('/infra')}         onClick={() => navigate('/infra')} />
-            <MenuItem icon="clipboard"  text="OPC"            active={activeNav === 'opc'}       onClick={() => setActiveNav('opc')} />
+          <MenuItem icon="clipboard"    text="OPC"            active={at('/opc')}            onClick={() => navigate('/opc')} />
-            <MenuItem icon="history"    text="Changesets"     active={activeNav === 'changesets'} onClick={() => setActiveNav('changesets')} />
+          <MenuItem icon="history"      text="Changesets"    active={at('/changesets')}     onClick={() => navigate('/changesets')} />
-            <MenuItem icon="people"       text="Clients"     active={activeNav === 'clients'}      onClick={() => setActiveNav('clients')} />
+          <MenuItem icon="people"       text="Clients"       active={at('/clients')}        onClick={() => navigate('/clients')} />
-            <MenuItem icon="cog"          text="Settings"    active={activeNav === 'settings'}     onClick={() => setActiveNav('settings')} />
+          <MenuItem icon="cog"          text="Settings"      active={at('/settings')}       onClick={() => navigate('/settings')} />
         </Menu>
       </div>
 
@@ -49,21 +49,6 @@ function App() {
         </div>
       </div>
     </aside>
-
-      {/* ── Main content ── */}
-      <main className="cp-main">
-        {activeNav === 'deployments'   && <DashboardPage />}
-        {activeNav === 'pipelines'     && <PipelinesPage />}
-        {activeNav === 'branches'      && <BranchPage />}
-        {activeNav === 'image-build'   && <ImageBuildPage />}
-        {activeNav === 'build-monitor' && <BuildMonitorPage />}
-        {activeNav === 'infra'         && <InfraPage />}
-        {activeNav === 'opc'           && <OpcPage />}
-        {activeNav === 'changesets'    && <ChangesetsPage />}
-        {activeNav === 'clients'       && <PlaceholderPage title="Clients" />}
-        {activeNav === 'settings'      && <PlaceholderPage title="Settings" />}
-      </main>
-    </div>
   );
 }
 
@@ -76,4 +61,27 @@ function PlaceholderPage({ title }: { title: string }) {
   );
 }
 
+function App() {
+  return (
+    <div className="cp-shell">
+      <Sidebar />
+      <main className="cp-main">
+        <Routes>
+          <Route path="/"             element={<Navigate to="/opc" replace />} />
+          <Route path="/deployments"  element={<DashboardPage />} />
+          <Route path="/pipelines"    element={<PipelinesPage />} />
+          <Route path="/branches"     element={<BranchPage />} />
+          <Route path="/image-build"  element={<ImageBuildPage />} />
+          <Route path="/build-monitor" element={<BuildMonitorPage />} />
+          <Route path="/infra"        element={<InfraPage />} />
+          <Route path="/opc"          element={<OpcPage />} />
+          <Route path="/changesets"   element={<ChangesetsPage />} />
+          <Route path="/clients"      element={<PlaceholderPage title="Clients" />} />
+          <Route path="/settings"     element={<PlaceholderPage title="Settings" />} />
+        </Routes>
+      </main>
+    </div>
+  );
+}
+
 export default App;

clarity.controlplane/src/api/buildApi.ts

@@ -0,0 +1,49 @@
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export interface ProjectDefinition {
+  name:         string;
+  kind:         'DotnetProject' | 'NpmProject' | 'SolutionBuild';
+  relativePath: string;
+}
+
+export interface BuildRecord {
+  id:          string;
+  kind:        'DockerImage' | 'DotnetProject' | 'NpmProject' | 'SolutionBuild';
+  target:      string;
+  status:      'Running' | 'Succeeded' | 'Failed';
+  startedAt:   string;
+  finishedAt?: string;
+  durationMs?: number;
+  commitSha?:  string;
+  log:         string[];
+}
+
+export async function getProjects(): Promise<ProjectDefinition[]> {
+  const res = await fetch(`${BASE_URL}/api/builds/projects`);
+  if (!res.ok) throw new Error(`Failed to get projects: ${res.statusText}`);
+  return res.json();
+}
+
+export async function getBuildHistory(): Promise<BuildRecord[]> {
+  const res = await fetch(`${BASE_URL}/api/builds/history`);
+  if (!res.ok) throw new Error(`Failed to get build history: ${res.statusText}`);
+  return res.json();
+}
+
+export function triggerProjectBuild(
+  projectName: string,
+  onLine:      (line: string) => void,
+  onDone:      (record: BuildRecord) => void,
+  onError:     (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${BASE_URL}/api/builds/${encodeURIComponent(projectName)}`);
+  source.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(e.data);
+      if (msg.done && msg.build) { onDone(msg.build as BuildRecord); source.close(); }
+      else if (typeof msg.line === 'string') onLine(msg.line);
+    } catch { /* ignore */ }
+  };
+  source.onerror = (e) => { onError(e); };
+  return source;
+}

clarity.controlplane/src/api/gitApi.ts

@@ -0,0 +1,18 @@
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export interface GitCommit {
+  hash:      string;
+  shortHash: string;
+  author:    string;
+  date:      string;
+  subject:   string;
+  files:     string[];
+}
+
+export async function getGitLog(path?: string, limit = 20): Promise<GitCommit[]> {
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (path) params.set('path', path);
+  const res = await fetch(`${BASE_URL}/api/git/log?${params}`);
+  if (!res.ok) throw new Error(`Failed to get git log: ${res.statusText}`);
+  return res.json();
+}

clarity.controlplane/src/api/imageApi.ts

@@ -0,0 +1,51 @@
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export interface ImageBuildStatus {
+  imageName:   string | null;
+  builtAt:     string | null;
+  lastMessage: string;
+  isBuilding:  boolean;
+}
+
+export interface BuildHistoryRecord {
+  id:          string;
+  status:      'Running' | 'Succeeded' | 'Failed';
+  startedAt:   string;
+  durationMs:  number | null;
+  commitSha:   string | null;
+  imageDigest: string | null;
+}
+
+export async function getImageStatus(): Promise<ImageBuildStatus> {
+  const res = await fetch(`${BASE_URL}/api/image/status`);
+  if (!res.ok) throw new Error(`Failed to get image status: ${res.statusText}`);
+  return res.json();
+}
+
+export async function getImageBuildHistory(limit = 30): Promise<BuildHistoryRecord[]> {
+  const res = await fetch(`${BASE_URL}/api/image/history?limit=${limit}`);
+  if (!res.ok) throw new Error(`Failed to get build history: ${res.statusText}`);
+  return res.json();
+}
+
+export function triggerImageBuild(
+  onLine:  (line: string) => void,
+  onDone:  (success: boolean) => void,
+  onError: (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${BASE_URL}/api/image/build-stream`);
+  source.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(e.data);
+      if (msg.done) { onDone(true); source.close(); }
+      else if (msg.line) onLine(msg.line);
+    } catch { /* ignore */ }
+  };
+  source.onerror = (e) => { onDone(false); onError(e); };
+  return source;
+}
+
+export async function startImageBuild(): Promise<void> {
+  const res = await fetch(`${BASE_URL}/api/image/build`, { method: 'POST' });
+  if (!res.ok) throw new Error(`Build trigger failed: ${res.statusText}`);
+}

clarity.controlplane/src/api/opcApi.ts

@@ -328,7 +328,7 @@ export async function listGiteaBranches(repoKey?: string): Promise<GiteaBranch[]
 export async function createGiteaBranch(
   opcNumber: string,
   opcTitle: string,
-  from = 'master',
+  from = 'main',
 ): Promise<GiteaBranch> {
   const res = await fetch(`${BASE_URL}/api/gitea/branches`, {
     method: 'POST',

clarity.controlplane/src/api/promotionApi.ts

@@ -0,0 +1,220 @@
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export interface CommitInfo {
+  sha:      string;
+  shortSha: string;
+  message:  string;
+  author:   string;
+  date:     string;
+}
+
+export interface BranchStatus {
+  branch:            string;
+  exists:            boolean;
+  shortHash:         string | null;
+  lastCommitSummary: string | null;
+  aheadOfNext:       number;
+  behindNext:        number;
+  unreleasedCommits: CommitInfo[];
+  tipSha:            string | null;
+}
+
+export interface PromotionRecord {
+  id:          string;
+  fromBranch:  string;
+  toBranch:    string;
+  requestedBy: string;
+  note:        string | null;
+  status:      'Pending' | 'Running' | 'Succeeded' | 'Failed';
+  createdAt:   string;
+  completedAt: string | null;
+  commitCount: number;
+  commitLines: string[];
+  log:         string[];
+}
+
+export type ConformanceViolation = 'OK' | 'Missing' | 'Diverged' | 'Stale';
+export type ConformanceSeverity  = 'OK' | 'Info' | 'Warning' | 'Critical';
+
+export interface BranchConformanceCheck {
+  branch:        string;
+  sourceBranch:  string | null;
+  violation:     ConformanceViolation;
+  severity:      ConformanceSeverity;
+  detail:        string;
+  aheadOfSource: number;
+  behindSource:  number;
+  fixSha:        string | null;
+}
+
+export interface ConformanceReport {
+  repo:         string;
+  isConformant: boolean;
+  checks:       BranchConformanceCheck[];
+}
+
+export async function getLadderStatus(repo = 'Clarity'): Promise<BranchStatus[]> {
+  const res = await fetch(`${BASE_URL}/api/promotions/ladder?repo=${encodeURIComponent(repo)}`);
+  if (!res.ok) throw new Error(`Failed to get ladder status: ${res.statusText}`);
+  return res.json();
+}
+
+export async function getPromotionHistory(): Promise<PromotionRecord[]> {
+  const res = await fetch(`${BASE_URL}/api/promotions/history`);
+  if (!res.ok) throw new Error(`Failed to get promotion history: ${res.statusText}`);
+  return res.json();
+}
+
+export function triggerPromotion(
+  from:        string,
+  to:          string,
+  requestedBy: string,
+  note:        string | undefined,
+  onLine:      (line: string) => void,
+  onDone:      (record: PromotionRecord) => void,
+  onError:     (err: string) => void,
+  repo = 'Clarity',
+): () => void {
+  let cancelled = false;
+  const controller = new AbortController();
+
+  (async () => {
+    try {
+      const res = await fetch(`${BASE_URL}/api/promotions/promote`, {
+        method:  'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body:    JSON.stringify({ from, to, requestedBy, note, repo }),
+        signal:  controller.signal,
+      });
+      if (!res.ok || !res.body) { onError(res.statusText); return; }
+
+      const reader  = res.body.getReader();
+      const decoder = new TextDecoder();
+      let   buffer  = '';
+
+      while (!cancelled) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split('\n\n');
+        buffer = parts.pop() ?? '';
+        for (const chunk of parts) {
+          const dataLine = chunk.replace(/^data:\s*/m, '').trim();
+          if (!dataLine) continue;
+          try {
+            const msg = JSON.parse(dataLine);
+            if (msg.done && msg.promotion) onDone(msg.promotion as PromotionRecord);
+            else if (typeof msg.line === 'string') onLine(msg.line);
+          } catch { /* skip */ }
+        }
+      }
+    } catch (e) {
+      if (!cancelled) onError(e instanceof Error ? e.message : 'Unknown error');
+    }
+  })();
+
+  return () => { cancelled = true; controller.abort(); };
+}
+
+export function triggerCherryPick(
+  shas:        string[],
+  from:        string,
+  to:          string,
+  requestedBy: string,
+  note:        string | undefined,
+  onLine:      (line: string) => void,
+  onDone:      (record: PromotionRecord) => void,
+  onError:     (err: string) => void,
+  repo = 'Clarity',
+): () => void {
+  let cancelled = false;
+  const controller = new AbortController();
+
+  (async () => {
+    try {
+      const res = await fetch(`${BASE_URL}/api/promotions/cherry-pick`, {
+        method:  'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body:    JSON.stringify({ shas, from, to, requestedBy, note, repo }),
+        signal:  controller.signal,
+      });
+      if (!res.ok || !res.body) { onError(res.statusText); return; }
+
+      const reader  = res.body.getReader();
+      const decoder = new TextDecoder();
+      let   buffer  = '';
+
+      while (!cancelled) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split('\n\n');
+        buffer = parts.pop() ?? '';
+        for (const chunk of parts) {
+          const dataLine = chunk.replace(/^data:\s*/m, '').trim();
+          if (!dataLine) continue;
+          try {
+            const msg = JSON.parse(dataLine);
+            if (msg.done && msg.promotion) onDone(msg.promotion as PromotionRecord);
+            else if (typeof msg.line === 'string') onLine(msg.line);
+          } catch { /* skip */ }
+        }
+      }
+    } catch (e) {
+      if (!cancelled) onError(e instanceof Error ? e.message : 'Unknown error');
+    }
+  })();
+
+  return () => { cancelled = true; controller.abort(); };
+}
+
+export async function resetBranch(branch: string, toSha: string, repo: string): Promise<void> {
+  const res = await fetch(`${BASE_URL}/api/promotions/reset`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ branch, toSha, repo }),
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error((body as { error?: string }).error ?? res.statusText);
+  }
+}
+
+export async function getConformanceReport(repo = 'Clarity'): Promise<ConformanceReport> {
+  const res = await fetch(`${BASE_URL}/api/promotions/conformance?repo=${encodeURIComponent(repo)}`);
+  if (!res.ok) throw new Error(`Failed to get conformance report: ${res.statusText}`);
+  return res.json();
+}
+
+export async function getAllConformanceReports(): Promise<ConformanceReport[]> {
+  const res = await fetch(`${BASE_URL}/api/promotions/conformance/all`);
+  if (!res.ok) throw new Error(`Failed to get conformance reports: ${res.statusText}`);
+  return res.json();
+}
+
+export async function createLadderBranch(branch: string, fromSha: string, repo: string): Promise<void> {
+  const res = await fetch(`${BASE_URL}/api/promotions/create-branch`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ branch, fromSha, repo }),
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error((body as { error?: string }).error ?? res.statusText);
+  }
+}
+
+// ── Build gate ───────────────────────────────────────────────────────────────────────────────
+
+export interface BuildGate {
+  status:      'Green' | 'Red' | 'Running' | 'Unknown';
+  sha:         string;
+  buildId:     string | null;
+  buildStatus: string | null;
+}
+
+export async function getBuildGate(sha: string): Promise<BuildGate> {
+  const res = await fetch(`${BASE_URL}/api/promotions/build-gate?sha=${encodeURIComponent(sha)}`);
+  if (!res.ok) throw new Error(`Failed to get build gate: ${res.statusText}`);
+  return res.json();
+}

clarity.controlplane/src/api/provisioningApi.ts

@@ -1,290 +1,7 @@
-import type { ProvisioningProgressEvent, ProvisioningRequest, TenantRecord } from '../types/provisioning';
+// Barrel re-export � split into domain modules. Import directly from the specific module for new code.
-
+export * from './tenantApi';
-const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+export * from './imageApi';
-
+export * from './releaseApi';
-export async function submitProvisioningJob(request: ProvisioningRequest): Promise<string> {
+export * from './buildApi';
-  const res = await fetch(`${BASE_URL}/api/provision`, {
+export * from './gitApi';
-    method: 'POST',
+export * from './promotionApi';
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(request),
-  });
-
-  if (!res.ok) throw new Error(`Failed to queue job: ${res.statusText}`);
-
-  const data = await res.json();
-  return data.id as string;
-}
-
-export async function getTenants(): Promise<TenantRecord[]> {
-  const res = await fetch(`${BASE_URL}/api/tenants`);
-  if (!res.ok) throw new Error(`Failed to load tenants: ${res.statusText}`);
-  return res.json();
-}
-
-export function subscribeToTenantLogs(
-  subdomain: string,
-  onLine: (line: string) => void,
-  onError: (err: Event) => void
-): EventSource {
-  const source = new EventSource(`${BASE_URL}/api/tenants/${subdomain}/logs`);
-  source.onmessage = (e) => { if (e.data) onLine(e.data); };
-  source.onerror = onError;
-  return source;
-}
-
-export function subscribeToJobStream(
-  jobId: string,
-  onEvent: (event: ProvisioningProgressEvent) => void,
-  onError: (err: Event) => void
-): EventSource {
-  const source = new EventSource(`${BASE_URL}/api/provision/${jobId}/stream`);
-
-  source.onmessage = (e) => {
-    try { onEvent(JSON.parse(e.data)); } catch { /* ignore */ }
-  };
-
-  source.onerror = onError;
-  return source;
-}
-
-export interface ImageBuildStatus {
-  imageName:   string | null;
-  builtAt:     string | null;
-  lastMessage: string;
-  isBuilding:  boolean;
-}
-
-export async function getImageStatus(): Promise<ImageBuildStatus> {
-  const res = await fetch(`${BASE_URL}/api/image/status`);
-  if (!res.ok) throw new Error(`Failed to get image status: ${res.statusText}`);
-  return res.json();
-}
-
-/** Triggers a build and streams log lines. Calls onLine for each log chunk, onDone when finished. */
-export function triggerImageBuild(
-  onLine: (line: string) => void,
-  onDone: (success: boolean) => void,
-  onError: (err: Event) => void
-): EventSource {
-  const source = new EventSource(`${BASE_URL}/api/image/build-stream`);
-
-  source.onmessage = (e) => {
-    try {
-      const msg = JSON.parse(e.data);
-      if (msg.done) { onDone(true); source.close(); }
-      else if (msg.line) onLine(msg.line);
-    } catch { /* ignore */ }
-  };
-
-  source.onerror = (e) => { onDone(false); onError(e); };
-  return source;
-}
-
-/** POST to kick off the build — returns immediately; use subscribeToJobStream for progress */
-export async function startImageBuild(): Promise<void> {
-  const res = await fetch(`${BASE_URL}/api/image/build`, { method: 'POST' });
-  if (!res.ok) throw new Error(`Build trigger failed: ${res.statusText}`);
-}
-
-// ── Release API ──────────────────────────────────────────────────────────────
-
-export interface TenantReleaseResult {
-  subdomain:     string;
-  containerName: string;
-  success:       boolean;
-  error?:        string;
-}
-
-export interface ReleaseRecord {
-  id:          string;
-  environment: string;
-  imageName:   string;
-  status:      'Running' | 'Succeeded' | 'PartialFailure' | 'Failed';
-  startedAt:   string;
-  finishedAt?: string;
-  tenants:     TenantReleaseResult[];
-}
-
-export async function getReleaseHistory(): Promise<ReleaseRecord[]> {
-  const res = await fetch(`${BASE_URL}/api/release/history`);
-  if (!res.ok) throw new Error(`Failed to get release history: ${res.statusText}`);
-  return res.json();
-}
-
-/** Triggers a release to the given environment and streams log lines as SSE. */
-export function triggerRelease(
-  env: string,
-  onLine: (line: string) => void,
-  onDone: (record: ReleaseRecord) => void,
-  onError: (err: Event) => void
-): EventSource {
-  const source = new EventSource(`${BASE_URL}/api/release/${env}`);
-  source.onmessage = (e) => {
-    try {
-      const msg = JSON.parse(e.data);
-      if (msg.done && msg.release) { onDone(msg.release as ReleaseRecord); source.close(); }
-      else if (typeof msg.line === 'string') onLine(msg.line);
-    } catch { /* ignore */ }
-  };
-  source.onerror = (e) => { onError(e); };
-  return source;
-}
-
-// ── Project Build API ────────────────────────────────────────────────────────
-
-export interface ProjectDefinition {
-  name:         string;
-  kind:         'DotnetProject' | 'NpmProject';
-  relativePath: string;
-}
-
-export interface BuildRecord {
-  id:          string;
-  kind:        'DockerImage' | 'DotnetProject' | 'NpmProject';
-  target:      string;
-  status:      'Running' | 'Succeeded' | 'Failed';
-  startedAt:   string;
-  finishedAt?: string;
-  durationMs?: number;
-  log:         string[];
-}
-
-export async function getProjects(): Promise<ProjectDefinition[]> {
-  const res = await fetch(`${BASE_URL}/api/builds/projects`);
-  if (!res.ok) throw new Error(`Failed to get projects: ${res.statusText}`);
-  return res.json();
-}
-
-export async function getBuildHistory(): Promise<BuildRecord[]> {
-  const res = await fetch(`${BASE_URL}/api/builds/history`);
-  if (!res.ok) throw new Error(`Failed to get build history: ${res.statusText}`);
-  return res.json();
-}
-
-/** Triggers a project build and streams log lines. */
-export function triggerProjectBuild(
-  projectName: string,
-  onLine: (line: string) => void,
-  onDone: (record: BuildRecord) => void,
-  onError: (err: Event) => void
-): EventSource {
-  const source = new EventSource(`${BASE_URL}/api/builds/${encodeURIComponent(projectName)}`);
-  source.onmessage = (e) => {
-    try {
-      const msg = JSON.parse(e.data);
-      if (msg.done && msg.build) { onDone(msg.build as BuildRecord); source.close(); }
-      else if (typeof msg.line === 'string') onLine(msg.line);
-    } catch { /* ignore */ }
-  };
-  source.onerror = (e) => { onError(e); };
-  return source;
-}
-
-// ── Git History API ──────────────────────────────────────────────────────────
-
-export interface GitCommit {
-  hash:      string;
-  shortHash: string;
-  author:    string;
-  date:      string;
-  subject:   string;
-  files:     string[];
-}
-
-export async function getGitLog(path?: string, limit = 20): Promise<GitCommit[]> {
-  const params = new URLSearchParams({ limit: String(limit) });
-  if (path) params.set('path', path);
-  const res = await fetch(`${BASE_URL}/api/git/log?${params}`);
-  if (!res.ok) throw new Error(`Failed to get git log: ${res.statusText}`);
-  return res.json();
-}
-
-// ── Promotion / Branch Ladder API ────────────────────────────────────────────
-
-export interface BranchStatus {
-  branch:            string;
-  exists:            boolean;
-  shortHash:         string | null;
-  lastCommitSummary: string | null;
-  aheadOfNext:       number;
-  behindNext:        number;
-  unreleasedLines:   string[];
-}
-
-export interface PromotionRecord {
-  id:          string;
-  fromBranch:  string;
-  toBranch:    string;
-  requestedBy: string;
-  note:        string | null;
-  status:      'Pending' | 'Running' | 'Succeeded' | 'Failed';
-  createdAt:   string;
-  completedAt: string | null;
-  commitCount: number;
-  commitLines: string[];
-  log:         string[];
-}
-
-export async function getLadderStatus(): Promise<BranchStatus[]> {
-  const res = await fetch(`${BASE_URL}/api/promotions/ladder`);
-  if (!res.ok) throw new Error(`Failed to get ladder status: ${res.statusText}`);
-  return res.json();
-}
-
-export async function getPromotionHistory(): Promise<PromotionRecord[]> {
-  const res = await fetch(`${BASE_URL}/api/promotions/history`);
-  if (!res.ok) throw new Error(`Failed to get promotion history: ${res.statusText}`);
-  return res.json();
-}
-
-/** Triggers a promotion and streams SSE lines. Calls onDone with the final record. */
-export function triggerPromotion(
-  from: string,
-  to: string,
-  requestedBy: string,
-  note: string | undefined,
-  onLine: (line: string) => void,
-  onDone: (record: PromotionRecord) => void,
-  onError: (err: string) => void,
-): () => void {
-  let cancelled = false;
-  const controller = new AbortController();
-
-  (async () => {
-    try {
-      const res = await fetch(`${BASE_URL}/api/promotions/promote`, {
-        method:  'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body:    JSON.stringify({ from, to, requestedBy, note }),
-        signal:  controller.signal,
-      });
-
-      if (!res.ok || !res.body) { onError(res.statusText); return; }
-
-      const reader  = res.body.getReader();
-      const decoder = new TextDecoder();
-      let   buffer  = '';
-
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const parts = buffer.split('\n\n');
-        buffer = parts.pop() ?? '';
-        for (const chunk of parts) {
-          const dataLine = chunk.replace(/^data:\s*/m, '').trim();
-          if (!dataLine) continue;
-          try {
-            const msg = JSON.parse(dataLine);
-            if (msg.done && msg.promotion) onDone(msg.promotion as PromotionRecord);
-            else if (typeof msg.line === 'string') onLine(msg.line);
-          } catch { /* skip */ }
-        }
-      }
-    } catch (e) {
-      if (!cancelled) onError(e instanceof Error ? e.message : 'Unknown error');
-    }
-  })();
-
-  return () => { cancelled = true; controller.abort(); };
-}

clarity.controlplane/src/api/releaseApi.ts

@@ -0,0 +1,43 @@
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export interface TenantReleaseResult {
+  subdomain:     string;
+  containerName: string;
+  success:       boolean;
+  error?:        string;
+}
+
+export interface ReleaseRecord {
+  id:          string;
+  environment: string;
+  imageName:   string;
+  status:      'Running' | 'Succeeded' | 'PartialFailure' | 'Failed';
+  startedAt:   string;
+  finishedAt?: string;
+  tenants:     TenantReleaseResult[];
+  opcNumbers:  string[];
+}
+
+export async function getReleaseHistory(): Promise<ReleaseRecord[]> {
+  const res = await fetch(`${BASE_URL}/api/release/history`);
+  if (!res.ok) throw new Error(`Failed to get release history: ${res.statusText}`);
+  return res.json();
+}
+
+export function triggerRelease(
+  env:     string,
+  onLine:  (line: string) => void,
+  onDone:  (record: ReleaseRecord) => void,
+  onError: (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${BASE_URL}/api/release/${env}`);
+  source.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(e.data);
+      if (msg.done && msg.release) { onDone(msg.release as ReleaseRecord); source.close(); }
+      else if (typeof msg.line === 'string') onLine(msg.line);
+    } catch { /* ignore */ }
+  };
+  source.onerror = (e) => { onError(e); };
+  return source;
+}

clarity.controlplane/src/api/tenantApi.ts

@@ -0,0 +1,44 @@
+import type { ProvisioningProgressEvent, ProvisioningRequest, TenantRecord } from '../types/provisioning';
+
+const BASE_URL = import.meta.env.VITE_API_URL ?? '';
+
+export async function submitProvisioningJob(request: ProvisioningRequest): Promise<string> {
+  const res = await fetch(`${BASE_URL}/api/provision`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  if (!res.ok) throw new Error(`Failed to queue job: ${res.statusText}`);
+  const data = await res.json();
+  return data.id as string;
+}
+
+export async function getTenants(): Promise<TenantRecord[]> {
+  const res = await fetch(`${BASE_URL}/api/tenants`);
+  if (!res.ok) throw new Error(`Failed to load tenants: ${res.statusText}`);
+  return res.json();
+}
+
+export function subscribeToTenantLogs(
+  subdomain: string,
+  onLine: (line: string) => void,
+  onError: (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${BASE_URL}/api/tenants/${subdomain}/logs`);
+  source.onmessage = (e) => { if (e.data) onLine(e.data); };
+  source.onerror = onError;
+  return source;
+}
+
+export function subscribeToJobStream(
+  jobId: string,
+  onEvent: (event: ProvisioningProgressEvent) => void,
+  onError: (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${BASE_URL}/api/provision/${jobId}/stream`);
+  source.onmessage = (e) => {
+    try { onEvent(JSON.parse(e.data)); } catch { /* ignore */ }
+  };
+  source.onerror = onError;
+  return source;
+}

clarity.controlplane/src/components/GitCommitDrawer.tsx

@@ -1,74 +1,127 @@
-import { useEffect, useState, useRef } from 'react';
+import { useEffect, useState } from 'react';
-import { Button, Drawer, Intent, NonIdealState, Spinner, Tag, Tooltip } from '@blueprintjs/core';
+import { Button, Collapse, Drawer, Icon, Intent, NonIdealState, Spinner, Tag, Tooltip } from '@blueprintjs/core';
 import { html as diff2htmlHtml } from 'diff2html';
 import 'diff2html/bundles/css/diff2html.min.css';
-import hljs from 'highlight.js';
+import { getCommitDetail, type CommitDetail, type CommitFile } from '../api/opcApi';
-import 'highlight.js/styles/github.css';
-import { getCommitDetail, type CommitDetail } from '../api/opcApi';
 
 interface Props {
   hash: string | null;
   onClose: () => void;
 }
 
+function fileStatusIntent(status: string): Intent {
+  if (status === 'added')   return Intent.SUCCESS;
+  if (status === 'deleted') return Intent.DANGER;
+  if (status === 'renamed') return Intent.WARNING;
+  return Intent.NONE;
+}
+
+function fileStatusIcon(status: string): string {
+  if (status === 'added')   return 'plus';
+  if (status === 'deleted') return 'minus';
+  if (status === 'renamed') return 'arrow-right';
+  return 'edit';
+}
+
+function FileDiff({ file }: { file: CommitFile }) {
+  const [open, setOpen] = useState(true);
+
+  const diffHtml = file.patch
+    ? diff2htmlHtml(file.patch, {
+        drawFileList:           false,
+        matching:               'lines',
+        outputFormat:           'line-by-line',
+        renderNothingWhenEmpty: true,
+      })
+    : '';
+
+  const displayPath = file.status === 'renamed' && file.oldPath && file.oldPath !== file.path
+    ? `${file.oldPath} → ${file.path}`
+    : file.path;
+
+  return (
+    <div className="gcd-file-section">
+      <button
+        className={`gcd-file-header ${open ? 'gcd-file-header--open' : ''}`}
+        onClick={() => setOpen(o => !o)}
+        type="button"
+      >
+        <Icon icon={open ? 'chevron-down' : 'chevron-right'} size={14} className="gcd-file-chevron" />
+        <Icon icon={fileStatusIcon(file.status)} size={13} intent={fileStatusIntent(file.status)} className="gcd-file-status-icon" />
+        <span className="gcd-file-path">{displayPath}</span>
+        <span className="gcd-file-stats">
+          {file.additions > 0 && <span className="gcd-adds">+{file.additions}</span>}
+          {file.deletions > 0 && <span className="gcd-dels">-{file.deletions}</span>}
+        </span>
+      </button>
+      <Collapse isOpen={open} keepChildrenMounted>
+        {diffHtml
+          ? <div className="git-diff-container" dangerouslySetInnerHTML={{ __html: diffHtml }} />
+          : <div className="gcd-no-diff">Binary or empty file — no textual diff available.</div>
+        }
+      </Collapse>
+    </div>
+  );
+}
+
 export function GitCommitDrawer({ hash, onClose }: Props) {
   const [detail,  setDetail]  = useState<CommitDetail | null>(null);
   const [loading, setLoading] = useState(false);
   const [error,   setError]   = useState<string | null>(null);
-  const diffRef = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
-    if (!hash) { setDetail(null); setError(null); return; }
+    if (!hash) {
-    setLoading(true); setDetail(null); setError(null);
+      // Delay clearing so the closing animation doesn't flash blank
+      const t = setTimeout(() => { setDetail(null); setError(null); }, 300);
+      return () => clearTimeout(t);
+    }
+    setLoading(true);
+    setError(null);
     getCommitDetail(hash)
-      .then(setDetail)
+      .then(d  => { setDetail(d); setError(null); })
       .catch(e => setError(String(e)))
       .finally(() => setLoading(false));
   }, [hash]);
 
-  // After diff HTML is injected, run highlight.js over code blocks
+  const totalAdds = detail?.files.reduce((a, f) => a + f.additions, 0) ?? 0;
-  useEffect(() => {
+  const totalDels = detail?.files.reduce((a, f) => a + f.deletions, 0) ?? 0;
-    if (detail && diffRef.current) {
-      diffRef.current.querySelectorAll<HTMLElement>('code[class]').forEach(el => {
-        hljs.highlightElement(el);
-      });
-    }
-  }, [detail]);
-
-  const combinedPatch = detail?.files.map(f => f.patch).join('\n') ?? '';
-  const diffHtml = combinedPatch
-    ? diff2htmlHtml(combinedPatch, {
-        drawFileList:    true,
-        matching:        'lines',
-        outputFormat:    'line-by-line',
-        renderNothingWhenEmpty: false,
-      })
-    : '';
 
   return (
     <Drawer
       isOpen={!!hash}
       onClose={onClose}
-      title={detail ? (
+      title={
+        detail ? (
           <span className="git-drawer-title">
             <code className="git-drawer-hash">{detail.shortHash}</code>
             <span className="git-drawer-subject">{detail.subject}</span>
           </span>
-      ) : 'Commit Diff'}
+        ) : 'Commit Diff'
+      }
       size="70%"
       position="right"
       className="git-commit-drawer"
     >
-      <div className="git-drawer-body">
+      {/* Scrollable body */}
-        {loading && <NonIdealState icon={<Spinner size={24} />} title="Loading diff…" />}
+      <div className="gcd-body">
-        {error   && <NonIdealState icon="error" intent={Intent.DANGER} title="Failed to load commit" description={error} />}
+        {/* Loading overlay — keeps old content visible while fetching next */}
+        {loading && (
+          <div className="gcd-loading-overlay">
+            <Spinner size={28} />
+          </div>
+        )}
 
-        {detail && (
+        {error && (
+          <NonIdealState icon="error" intent={Intent.DANGER}
+            title="Failed to load commit" description={error} />
+        )}
+
+        {!error && detail && (
           <>
             {/* Metadata bar */}
             <div className="git-commit-meta-bar">
               <div className="git-commit-meta-left">
-                <Tooltip content="Copy full hash">
+                <Tooltip content="Copy full hash" placement="bottom">
                   <code
                     className="git-commit-hash-chip"
                     onClick={() => navigator.clipboard.writeText(detail.hash)}
@@ -81,26 +134,33 @@ export function GitCommitDrawer({ hash, onClose }: Props) {
                 <span className="git-commit-date">{detail.date}</span>
               </div>
               <div className="git-commit-meta-right">
-                <Tag intent={Intent.SUCCESS} minimal round icon="add">
+                {totalAdds > 0 && (
-                  +{detail.files.reduce((a, f) => a + f.additions, 0)}
+                  <Tag intent={Intent.SUCCESS} minimal round>+{totalAdds}</Tag>
+                )}
+                {totalDels > 0 && (
+                  <Tag intent={Intent.DANGER} minimal round>-{totalDels}</Tag>
+                )}
+                <Tag minimal round>
+                  {detail.files.length} file{detail.files.length !== 1 ? 's' : ''}
                 </Tag>
-                <Tag intent={Intent.DANGER} minimal round icon="remove">
-                  -{detail.files.reduce((a, f) => a + f.deletions, 0)}
-                </Tag>
-                <Tag minimal round>{detail.files.length} file{detail.files.length !== 1 ? 's' : ''}</Tag>
               </div>
             </div>
 
-            {/* Commit body if multiline */}
+            {/* Extended commit message */}
             {detail.body.trim() !== detail.subject.trim() && (
               <pre className="git-commit-body">{detail.body.trim()}</pre>
             )}
 
-            {/* Diff */}
+            {/* Per-file diffs */}
-            {diffHtml
+            {detail.files.length === 0 ? (
-              ? <div ref={diffRef} className="git-diff-container" dangerouslySetInnerHTML={{ __html: diffHtml }} />
+              <NonIdealState icon="git-commit" title="No file changes" />
-              : <NonIdealState icon="git-commit" title="No diff" description="This commit has no file changes." />
+            ) : (
-            }
+              <div className="gcd-files-list">
+                {detail.files.map(f => (
+                  <FileDiff key={f.path} file={f} />
+                ))}
+              </div>
+            )}
           </>
         )}
 
@@ -109,7 +169,8 @@ export function GitCommitDrawer({ hash, onClose }: Props) {
         )}
       </div>
 
-      <div className="git-drawer-footer">
+      {/* Footer — sticky at bottom */}
+      <div className="gcd-footer">
         <Button text="Close" onClick={onClose} />
       </div>
     </Drawer>

clarity.controlplane/src/components/ImageBuildPanel.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from 'react';
 import { Button, Callout, Intent, Tag } from '@blueprintjs/core';
-import { getImageStatus, type ImageBuildStatus } from '../api/provisioningApi';
+import { getImageStatus, type ImageBuildStatus } from '../api/imageApi';
 
 const BASE_URL = import.meta.env.VITE_API_URL ?? '';
 

clarity.controlplane/src/components/wizard/DeployWizard.tsx

@@ -4,7 +4,7 @@ import ClientDetailsStep from './ClientDetailsStep';
 import DeploymentConfigStep from './DeploymentConfigStep';
 import ReviewStep from './ReviewStep';
 import DeploymentLiveStep from './DeploymentLiveStep';
-import { submitProvisioningJob } from '../../api/provisioningApi';
+import { submitProvisioningJob } from '../../api/tenantApi';
 import { defaultStackConfig } from '../../types/provisioning';
 import type { ProvisioningRequest } from '../../types/provisioning';
 

clarity.controlplane/src/components/wizard/DeploymentLiveStep.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from 'react';
 import { AnchorButton, Callout, Intent, ProgressBar, Spinner, Tab, Tabs, Tag } from '@blueprintjs/core';
-import { subscribeToJobStream } from '../../api/provisioningApi';
+import { subscribeToJobStream } from '../../api/tenantApi';
 import { tenantUrl } from '../../config';
 import type { ProvisioningProgressEvent } from '../../types/provisioning';
 

clarity.controlplane/src/index.css

@@ -804,30 +804,116 @@ body {
 
 .opc-sdlc-pipeline {
   display: flex;
-  align-items: center;
+  align-items: flex-start;
-  flex-wrap: wrap;
+  flex-wrap: nowrap;
-  gap: 0.2rem;
+  gap: 0;
-  margin-bottom: 0.35rem;
+  overflow-x: auto;
-}
+  padding-bottom: 0.25rem;
-
-.opc-sdlc-stage-item {
-  display: flex;
-  align-items: center;
-  gap: 0.2rem;
 }
 
 .opc-sdlc-arrow {
   color: #8f99a8;
-  font-size: 0.8rem;
+  font-size: 1rem;
   font-weight: 600;
-  margin: 0 0.1rem;
+  flex-shrink: 0;
+  align-self: center;
+  margin: 0 0.4rem;
   user-select: none;
 }
 
-.opc-sdlc-furthest {
+/* Individual branch box */
-  font-size: 0.75rem;
+.opc-sdlc-box {
+  flex: 1 1 140px;
+  min-width: 130px;
+  max-width: 200px;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid #dce0e6;
+  border-radius: 6px;
+  background: #fff;
+  overflow: hidden;
+  flex-shrink: 0;
+}
+
+.opc-sdlc-box--reached {
+  border-width: 2px;
+}
+
+.opc-sdlc-box-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0.3rem 0.5rem;
+  background: #f6f7f9;
+  border-bottom: 1px solid #e5e8eb;
+  flex-shrink: 0;
+}
+
+.opc-sdlc-box-count {
+  font-size: 0.68rem;
   color: #738091;
-  margin-top: 0.3rem;
+  background: #e5e8eb;
+  border-radius: 10px;
+  padding: 0 6px;
+  line-height: 1.5;
+}
+
+/* Scrollable body */
+.opc-sdlc-box-body {
+  flex: 1;
+  overflow-y: auto;
+  max-height: 140px;
+  min-height: 60px;
+  padding: 0.3rem 0.4rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+}
+
+.opc-sdlc-sha-row {
+  display: flex;
+  align-items: baseline;
+  gap: 0.35rem;
+  padding: 0.1rem 0.2rem;
+  border-radius: 3px;
+  opacity: 0.35;
+}
+
+.opc-sdlc-sha-row--reached {
+  opacity: 1;
+}
+
+.opc-sdlc-sha {
+  font-family: 'Consolas', 'Courier New', monospace;
+  font-size: 0.7rem;
+  color: #2d72d2;
+  flex-shrink: 0;
+}
+
+.opc-sdlc-sha-msg {
+  font-size: 0.68rem;
+  color: #4a5568;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  flex: 1;
+  min-width: 0;
+}
+
+.opc-sdlc-box-empty {
+  font-size: 0.7rem;
+  color: #a3acb6;
+  font-style: italic;
+  padding: 0.2rem 0;
+}
+
+.opc-sdlc-box-pending {
+  font-size: 0.68rem;
+  color: #a3acb6;
+  font-style: italic;
+  margin-top: auto;
+  padding-top: 0.25rem;
+  border-top: 1px dashed #e5e8eb;
 }
 
 /* Commits section labels */
@@ -850,10 +936,50 @@ body {
 }
 
 /* ── Git Commit Drawer ──────────────────────────────────────────────────────── */
-.git-commit-drawer .bp5-drawer-header {
+
+/* Drawer shell: full-height flex column */
+.git-commit-drawer.bp6-drawer {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  overflow: hidden;
+}
+
+.git-commit-drawer .bp6-drawer-header {
+  flex-shrink: 0;
   padding: 0.75rem 1rem;
 }
 
+/*
+ * .gcd-body is the scrollable content area.
+ * Blueprint v6 renders children directly inside .bp6-drawer — no body wrapper.
+ */
+.git-commit-drawer .gcd-body {
+  flex: 1 1 0;         /* 0 basis — don't size from content, allow shrink */
+  min-height: 0;       /* flex children won't shrink past content without this */
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  position: relative;  /* loading overlay anchor */
+}
+
+/* Children of the scroll container must NOT shrink — if they do, content
+ * never overflows and the scrollbar never appears. */
+.git-commit-drawer .gcd-body > * {
+  flex-shrink: 0;
+}
+
+/* Footer rendered as last child — sits below the scroll area */
+.git-commit-drawer .gcd-footer {
+  flex-shrink: 0;
+  padding: 0.5rem 1rem;
+  display: flex;
+  justify-content: flex-end;
+}
+
 .git-drawer-title {
   display: flex;
   align-items: center;
@@ -871,6 +997,95 @@ body {
   font-family: 'JetBrains Mono', 'Fira Code', monospace;
 }
 
+/* Loading overlay — keeps old diff visible while fetching next commit */
+.gcd-loading-overlay {
+  position: absolute;
+  inset: 0;
+  background: rgba(255, 255, 255, 0.7);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 10;
+  pointer-events: none;
+}
+
+/* Per-file accordion */
+.gcd-files-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  border: 1px solid #dce0e6;
+  border-radius: 6px;
+  overflow: hidden;
+  margin: 0.75rem 0;
+}
+
+.gcd-file-section {
+  border-bottom: 1px solid #dce0e6;
+}
+
+.gcd-file-section:last-child {
+  border-bottom: none;
+}
+
+.gcd-file-header {
+  all: unset;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  width: 100%;
+  padding: 0.45rem 0.75rem;
+  background: #f6f8fa;
+  cursor: pointer;
+  user-select: none;
+  transition: background 0.1s;
+  font-family: 'JetBrains Mono', 'Fira Code', monospace;
+  font-size: 0.78rem;
+  color: #1c2127;
+}
+
+.gcd-file-header:hover,
+.gcd-file-header--open {
+  background: #edf2f7;
+}
+
+.gcd-file-chevron {
+  flex-shrink: 0;
+  color: #738091;
+}
+
+.gcd-file-status-icon {
+  flex-shrink: 0;
+}
+
+.gcd-file-path {
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  min-width: 0;
+}
+
+.gcd-file-stats {
+  display: flex;
+  gap: 0.4rem;
+  flex-shrink: 0;
+  font-size: 0.73rem;
+  font-family: 'JetBrains Mono', 'Fira Code', monospace;
+}
+
+.gcd-adds { color: #1a7f37; font-weight: 600; }
+.gcd-dels { color: #cf222e; font-weight: 600; }
+
+.gcd-no-diff {
+  padding: 0.6rem 1rem;
+  font-size: 0.8rem;
+  color: #738091;
+  font-style: italic;
+  background: #fafafa;
+}
+
 .git-drawer-subject {
   font-size: 0.92rem;
   font-weight: 600;
@@ -880,21 +1095,6 @@ body {
   color: #1c2127;
 }
 
-.git-drawer-body {
-  flex: 1;
-  overflow-y: auto;
-  padding: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-}
-
-.git-drawer-footer {
-  padding: 0.75rem 1rem;
-  border-top: 1px solid #d3d8de;
-  display: flex;
-  justify-content: flex-end;
-}
 
 .git-commit-meta-bar {
   display: flex;
@@ -961,7 +1161,8 @@ body {
   font-size: 0.78rem;
   line-height: 1.45;
   border-radius: 6px;
-  overflow: hidden;
+  overflow-x: auto;   /* horizontal scroll for wide diffs, not clip */
+  overflow-y: visible;
   border: 1px solid #d0d7de;
 }
 

clarity.controlplane/src/main.tsx

@@ -1,10 +1,13 @@
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
+import { BrowserRouter } from 'react-router-dom'
 import './index.css'
 import App from './App.tsx'
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
+    <BrowserRouter>
       <App />
+    </BrowserRouter>
   </StrictMode>,
 )

clarity.controlplane/src/opc/OpcPage.tsx

@@ -1,4 +1,4 @@
-import { useState, useMemo, useEffect, useCallback } from 'react';
+import { useState, useMemo, useEffect, useCallback, Fragment } from 'react';
 import { GitCommitDrawer } from '../components/GitCommitDrawer';
 import {
   Button, Callout, Divider, Drawer, FormGroup,
@@ -76,18 +76,9 @@ const SDLC_STAGES: { branch: string; label: string; intent: Intent }[] = [
   { branch: 'develop', label: 'Dev',        intent: Intent.PRIMARY  },
   { branch: 'staging', label: 'Staging',    intent: Intent.WARNING  },
   { branch: 'uat',     label: 'UAT',        intent: Intent.DANGER   },
-  { branch: 'master',  label: 'Production', intent: Intent.SUCCESS  },
+  { branch: 'main',    label: 'Production', intent: Intent.SUCCESS  },
 ];
 
-function deriveSdlcSummary(coverage: BranchCoverage[]): { label: string; intent: Intent } | null {
-  for (let i = SDLC_STAGES.length - 1; i >= 0; i--) {
-    const stage = SDLC_STAGES[i];
-    const hit = coverage.find(c => c.branch === stage.branch);
-    if (hit?.contains) return { label: stage.label, intent: stage.intent };
-  }
-  return null;
-}
-
 // Aggregate per-repo branch coverage into a single view.
 // A stage is "reached" only when every repo that recognised at least one hash
 // reports contains=true for that branch. Repos that recognised no hashes are
@@ -487,42 +478,48 @@ function CommitsTab({ opc, isActive }: { opc: Opc; isActive: boolean }) {
 
       {/* SDLC Delivery Chain */}
       {coverage.length > 0 && (() => {
-        const summary = deriveSdlcSummary(coverage);
+        const allCommits = [
+          ...autoCommits,
+          ...pinned.map(p => ({ repoKey: 'pinned', hash: p.hash, shortHash: p.shortHash, author: p.pinnedBy, date: p.pinnedAt, subject: p.subject, files: [] })),
+        ].filter((c, i, a) => a.findIndex(x => x.hash === c.hash) === i);
+
         return (
           <div className="opc-delivery-chain">
-            <div className="opc-field-label" style={{ marginBottom: '0.6rem' }}>Delivery Chain</div>
+            <div className="opc-field-label" style={{ marginBottom: '0.75rem' }}>Delivery Chain</div>
             <div className="opc-sdlc-pipeline">
               {SDLC_STAGES.map((stage, i) => {
                 const hit     = coverage.find(c => c.branch === stage.branch);
                 const reached = hit?.contains ?? false;
                 return (
-                  <div key={stage.branch} className="opc-sdlc-stage-item">
+                  <Fragment key={stage.branch}>
                     {i > 0 && <span className="opc-sdlc-arrow">→</span>}
-                    <Tooltip content={
+                    <div className={`opc-sdlc-box${reached ? ' opc-sdlc-box--reached' : ''}`} style={{ borderColor: reached ? SDLC_STAGES[i].intent === 'primary' ? '#2d72d2' : SDLC_STAGES[i].intent === 'warning' ? '#c87619' : SDLC_STAGES[i].intent === 'danger' ? '#ac2f33' : '#1c6e42' : '#dce0e6' }}>
-                      reached
+                      {/* Box header */}
-                        ? `All linked commits have reached ${stage.label}`
+                      <div className="opc-sdlc-box-header">
-                        : hit
+                        <Tag intent={reached ? stage.intent : Intent.NONE} minimal={!reached} round style={{ fontWeight: 600, fontSize: '0.72rem' }}>
-                          ? `Not all linked commits have reached ${stage.label} yet`
-                          : `${stage.label} branch not found locally`
-                    }>
-                      <Tag
-                        intent={reached ? stage.intent : Intent.NONE}
-                        icon={reached ? 'tick-circle' : 'circle'}
-                        minimal={!reached}
-                        round
-                      >
                           {stage.label}
                         </Tag>
-                    </Tooltip>
+                        {reached && <span className="opc-sdlc-box-count">{allCommits.length}</span>}
                       </div>
+                      {/* Scrollable SHA list */}
+                      <div className="opc-sdlc-box-body">
+                        {allCommits.length === 0 ? (
+                          <span className="opc-sdlc-box-empty">No linked commits</span>
+                        ) : allCommits.map(c => (
+                          <div key={c.hash} className={`opc-sdlc-sha-row${reached ? ' opc-sdlc-sha-row--reached' : ''}`} title={c.subject}>
+                            <code className="opc-sdlc-sha">{c.shortHash}</code>
+                            <span className="opc-sdlc-sha-msg">{c.subject}</span>
+                          </div>
+                        ))}
+                        {!reached && allCommits.length > 0 && (
+                          <div className="opc-sdlc-box-pending">Not yet promoted</div>
+                        )}
+                      </div>
+                    </div>
+                  </Fragment>
                 );
               })}
             </div>
-            {summary && (
-              <div className="opc-sdlc-furthest">
-                Furthest: <strong>{summary.label}</strong>
-              </div>
-            )}
           </div>
         );
       })()}

clarity.controlplane/src/pages/BuildMonitorPage.tsx

@@ -3,10 +3,8 @@ import {
   Button, Callout, Intent, Tag, Spinner, NonIdealState,
   Collapse, HTMLTable,
 } from '@blueprintjs/core';
-import {
+import { getProjects, getBuildHistory, type ProjectDefinition, type BuildRecord } from '../api/buildApi';
-  getProjects, getBuildHistory, getGitLog,
+import { getGitLog, type GitCommit } from '../api/gitApi';
-  type ProjectDefinition, type BuildRecord, type GitCommit,
-} from '../api/provisioningApi';
 
 const BASE_URL = import.meta.env.VITE_API_URL ?? '';
 
@@ -14,6 +12,7 @@ const KIND_INTENT: Record<string, Intent> = {
   DotnetProject:  Intent.PRIMARY,
   NpmProject:     Intent.WARNING,
   DockerImage:    Intent.NONE,
+  SolutionBuild:  Intent.SUCCESS,
 };
 
 const STATUS_INTENT: Record<string, Intent> = {
@@ -64,7 +63,7 @@ function GitHistoryPanel({ relativePath }: { relativePath: string }) {
           <p style={{ fontSize: '0.75rem', color: '#8f99a8', marginTop: '0.5rem' }}>No commits found for this path.</p>
         )}
         {commits.length > 0 && (
-          <HTMLTable className="bp5-html-table-condensed bp5-html-table-striped" style={{ width: '100%', marginTop: '0.5rem', fontSize: '0.72rem' }}>
+          <HTMLTable className="bp6-html-table-condensed bp6-html-table-striped" style={{ width: '100%', marginTop: '0.5rem', fontSize: '0.72rem' }}>
             <thead>
               <tr>
                 <th style={{ width: 60 }}>Commit</th>
@@ -250,9 +249,9 @@ export default function BuildMonitorPage() {
 
   useEffect(() => { (async () => { await load(); })(); }, []);
 
-  // Find latest build per project
+  // Find latest build per project — match exactly by relativePath (= build target)
-  const lastBuildFor = (name: string): BuildRecord | undefined =>
+  const lastBuildFor = (project: ProjectDefinition): BuildRecord | undefined =>
-    history.find((b) => b.target.includes(name.split(' ')[0]) || b.target.endsWith(name));
+    history.find((b) => b.target === project.relativePath);
 
   return (
     <>
@@ -292,7 +291,7 @@ export default function BuildMonitorPage() {
             <ProjectCard
               key={p.name}
               project={p}
-              lastBuild={lastBuildFor(p.name)}
+              lastBuild={lastBuildFor(p)}
               onBuilt={load}
             />
           ))}

clarity.controlplane/src/pages/DashboardPage.tsx

@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from 'react';
 import { AnchorButton, Button, Callout, Intent, NonIdealState, Spinner, Tab, Tabs, Tag } from '@blueprintjs/core';
 import DeployWizard from '../components/wizard/DeployWizard';
 import { tenantUrl, CLARITY_DOMAIN } from '../config';
-import { getTenants, subscribeToTenantLogs } from '../api/provisioningApi';
+import { getTenants, subscribeToTenantLogs } from '../api/tenantApi';
 import type { TenantRecord } from '../types/provisioning';
 
 const ENV_INTENT: Record<string, Intent> = {

clarity.controlplane/src/pages/ImageBuildPage.tsx

@@ -4,7 +4,8 @@ import {
   HTMLTable, Card, Elevation, Tabs, Tab, type TabId,
   FormGroup, InputGroup,
 } from '@blueprintjs/core';
-import { getImageStatus, getBuildHistory, type ImageBuildStatus, type BuildRecord } from '../api/provisioningApi';
+import { getImageStatus, type ImageBuildStatus } from '../api/imageApi';
+import { getBuildHistory, type BuildRecord } from '../api/buildApi';
 import {
   getInfraStatus, streamComposeUp, streamComposeForceUp, streamComposeNuke, streamComposeDown,
   type InfraService,

clarity.controlplane/src/pages/PipelinesPage.tsx

@@ -3,10 +3,8 @@ import {
   Button, Callout, Intent, Tag, Spinner, HTMLTable,
   NonIdealState,
 } from '@blueprintjs/core';
-import {
+import { getReleaseHistory, type ReleaseRecord } from '../api/releaseApi';
-  getReleaseHistory, getBuildHistory,
+import { getBuildHistory, type BuildRecord } from '../api/buildApi';
-  type ReleaseRecord, type BuildRecord,
-} from '../api/provisioningApi';
 
 const BASE_URL = import.meta.env.VITE_API_URL ?? '';
 
@@ -145,6 +143,14 @@ function ReleaseHistoryTable({ records }: { records: ReleaseRecord[] }) {
             {expanded === r.id && (
               <tr key={r.id + '-detail'}>
                 <td colSpan={7} style={{ padding: '0.4rem 1rem 0.8rem' }}>
+                  {r.opcNumbers?.length > 0 && (
+                    <div style={{ display: 'flex', gap: '0.3rem', flexWrap: 'wrap', alignItems: 'center', marginBottom: '0.5rem', paddingBottom: '0.5rem', borderBottom: '1px solid #e5e8eb' }}>
+                      <span style={{ fontSize: '0.72rem', color: '#8f99a8' }}>OPCs in this release:</span>
+                      {r.opcNumbers.map(n => (
+                        <Tag key={n} intent={Intent.PRIMARY} minimal round style={{ fontFamily: 'monospace', fontSize: '0.72rem' }}>{n}</Tag>
+                      ))}
+                    </div>
+                  )}
                   {r.tenants.map((t) => (
                     <div key={t.subdomain} style={{ display: 'flex', gap: '0.5rem', marginBottom: 2 }}>
                       <Tag intent={t.success ? Intent.SUCCESS : Intent.DANGER} minimal round>
@@ -226,7 +232,7 @@ export default function PipelinesPage() {
     try {
       const [r, b] = await Promise.all([getReleaseHistory(), getBuildHistory()]);
       setReleases(r);
-      setBuilds(b.filter((b) => b.kind === 'DockerImage'));
+      setBuilds(b.filter((b) => b.kind === 'SolutionBuild'));
     } finally {
       setLoading(false);
     }
@@ -252,7 +258,7 @@ export default function PipelinesPage() {
       </section>
 
       <section>
-        <h3 style={{ margin: '0 0 0.5rem' }}>Image Build History</h3>
+        <h3 style={{ margin: '0 0 0.5rem' }}>Solution Build History</h3>
         {loading ? <Spinner size={20} /> : <BuildHistoryTable records={builds} />}
       </section>
     </>

infra/nginx/conf.d/fdev-app-clarity-01000000.conf

@@ -0,0 +1,19 @@
+# Auto-generated by ControlPlane.Worker — do not edit manually.
+# Tenant: fdev-app-clarity-01000000
+server {
+    listen 443 ssl;
+    server_name fdev-app-clarity-01000000.clarity.test;
+
+    ssl_certificate     /etc/nginx/certs/clarity.test.crt;
+    ssl_certificate_key /etc/nginx/certs/clarity.test.key;
+
+    location / {
+        # Docker DNS resolves the container name on the managed network
+        set $upstream http://fdev-app-clarity-01000000:8080;
+        proxy_pass $upstream;
+        proxy_set_header Host              $host;
+        proxy_set_header X-Real-IP         $remote_addr;
+        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}

infra/nginx/conf.d/keycloak.clarity.test.conf

@@ -0,0 +1,15 @@
+server {
+    listen 443 ssl;
+    server_name keycloak.clarity.test;
+
+    ssl_certificate     /etc/nginx/certs/clarity.test.crt;
+    ssl_certificate_key /etc/nginx/certs/clarity.test.key;
+
+    location / {
+        proxy_pass         http://keycloak:8080;
+        proxy_set_header   Host              $host;
+        proxy_set_header   X-Real-IP         $remote_addr;
+        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
+        proxy_set_header   X-Forwarded-Proto $scheme;
+    }
+}