diff --git a/SW.Bitween.Api/Resources/Subscriptions/Search.cs b/SW.Bitween.Api/Resources/Subscriptions/Search.cs
index 0083bdf..302bfd0 100644
--- a/SW.Bitween.Api/Resources/Subscriptions/Search.cs
+++ b/SW.Bitween.Api/Resources/Subscriptions/Search.cs
@@ -56,6 +56,11 @@ join document in _dbContext.Set<Document>() on subscriber.DocumentId equals docu
                     AggregationForId = subscriber.AggregationForId,
                     Temporary = subscriber.Temporary,
                     ReceiveOn = subscriber.ReceiveOn,
+                    // The next-fire time of the other scheduled type. Left out, an aggregation
+                    // row had no next run to show at all — ReceiveOn is only ever set for
+                    // Receiving, and the list page reads one field for both.
+                    AggregateOn = subscriber.AggregateOn,
+                    AggregationTarget = subscriber.AggregationTarget,
                     PausedOn = subscriber.PausedOn,
                     IsRunning = subscriber.IsRunning,
                     ConsecutiveFailures = subscriber.ConsecutiveFailures,
diff --git a/SW.Bitween.Api/Resources/Subscriptions/SubscriptionConfigurationApplier.cs b/SW.Bitween.Api/Resources/Subscriptions/SubscriptionConfigurationApplier.cs
index f9264d4..a6a17b0 100644
--- a/SW.Bitween.Api/Resources/Subscriptions/SubscriptionConfigurationApplier.cs
+++ b/SW.Bitween.Api/Resources/Subscriptions/SubscriptionConfigurationApplier.cs
@@ -37,6 +37,9 @@ public static async Task Apply(BitweenDbContext dbContext, Subscription entity,
         entity.WorkGroupId = model.WorkGroupId;
         entity.ResponseSubscriptionId = model.ResponseSubscriptionId;
         entity.ResponseMessageTypeName = model.ResponseMessageTypeName;
+        // Meaningless for every other type, where it stays at its default — but harmless
+        // there, and applying it unconditionally is what stops create and update disagreeing.
+        entity.AggregationTarget = model.AggregationTarget;
 
         // Only when the caller said something about them. A Receiving subscription with no
         // schedules is what SetSchedules throws on, and a create that mentions no schedule at
diff --git a/SW.Bitween.Api/Services/AggregationJob.cs b/SW.Bitween.Api/Services/AggregationJob.cs
index 818e661..fceb676 100644
--- a/SW.Bitween.Api/Services/AggregationJob.cs
+++ b/SW.Bitween.Api/Services/AggregationJob.cs
@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using SW.Bitween.Domain;
+using SW.Bitween.Model;
 using SW.Scheduler;
 using System;
 using System.Linq;
@@ -25,6 +26,15 @@ public async Task Execute(AggregationJobParams jobParams)
 
         if (aggSub == null) return;
 
+        var startedOn = DateTime.UtcNow;
+        // Decided as the run goes and written once at the end. Recording inside both the try
+        // and the catch wrote two rows for a single run whenever something threw after the
+        // roll-up was already built — SetSchedules does exactly that on an aggregation that
+        // somehow has no schedule.
+        var outcome = ReceiveOutcome.NoNewData;
+        string errorMessage = null;
+        string[] createdExchangeIds = [];
+
         try
         {
             var xchangeQuery =
@@ -46,7 +56,11 @@ from agg in xa.DefaultIfEmpty()
                 var aggXchange = await xchangeService.CreateXchange(aggSub, xchangeAggregationFile);
                 dbContext.Add(aggXchange);
                 targetXchangeList.ForEach(id => dbContext.Add(new XchangeAggregation(id, aggXchange.Id)));
+                outcome = ReceiveOutcome.Received;
+                createdExchangeIds = [aggXchange.Id];
             }
+            // Otherwise the outcome stays NoNewData: nothing outstanding is an ordinary, quiet
+            // result, the same thing a receiver reports when the folder it polls is empty.
 
             aggSub.SetSchedules();
             aggSub.SetHealth();
@@ -54,9 +68,35 @@ from agg in xa.DefaultIfEmpty()
         catch (Exception ex)
         {
             aggSub.SetHealth(ex.ToString());
+            errorMessage = ex.ToString();
+            // A run that already built its roll-up did the thing it exists to do; a throw after
+            // that is bookkeeping, and calling the run failed would misreport delivered work.
+            // The error is kept on the attempt either way, and on the integration's health.
+            if (createdExchangeIds.Length == 0) outcome = ReceiveOutcome.Failed;
             logger.LogError(ex, "Error processing aggregation for subscription {SubscriptionId}", jobParams.SubscriptionId);
         }
 
+        RecordAttempt(aggSub.Id, startedOn, outcome, errorMessage, createdExchangeIds);
+
         await dbContext.SaveChangesAsync();
     }
+
+    /// <summary>
+    /// Writes the run into the same history a receiver's runs go into, which is what lets one
+    /// table on the integration page show a run beside the exchange it produced. The entity is
+    /// named for the job that came first; nothing on it is specific to receiving.
+    /// </summary>
+    private void RecordAttempt(int subscriptionId, DateTime startedOn, ReceiveOutcome outcome,
+        string errorMessage, string[] exchangeIds)
+    {
+        dbContext.Add(new ReceiveAttempt
+        {
+            SubscriptionId = subscriptionId,
+            StartedOn = startedOn,
+            FinishedOn = DateTime.UtcNow,
+            Outcome = outcome,
+            ErrorMessage = errorMessage,
+            ExchangeIds = exchangeIds,
+        });
+    }
 }
diff --git a/SW.Bitween.IntegrationTests/Tests/AggregationTests.cs b/SW.Bitween.IntegrationTests/Tests/AggregationTests.cs
index 9171eff..aacfdb4 100644
--- a/SW.Bitween.IntegrationTests/Tests/AggregationTests.cs
+++ b/SW.Bitween.IntegrationTests/Tests/AggregationTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
@@ -157,4 +158,241 @@ public async Task Aggregation_job_does_nothing_for_inactive_subscription()
         var count = await db.Set<Xchange>().CountAsync(x => x.SubscriptionId == aggSub.Id);
         Assert.Equal(0, count);
     }
+
+    // ─── Run history ────────────────────────────────────────────────────────
+    //
+    // Every run is written into the same history a receiver's runs go into, so the integration
+    // page can show one table of runs with the exchange each produced instead of two tables
+    // that cannot be joined. Before this, an aggregation recorded nothing at all.
+
+    [Fact]
+    public async Task A_run_that_rolls_something_up_records_the_exchange_it_made()
+    {
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var job = scope.ServiceProvider.GetRequiredService<AggregationJob>();
+        var cache = _fixture.App.Services.GetRequiredService<IInfolinkCache>();
+
+        var sourceDoc = new Document(null, "Agg Attempt Doc", DocumentFormat.Json);
+        db.Set<Document>().Add(sourceDoc);
+        await db.SaveChangesAsync();
+        var sourceSub = new Subscription("Agg Attempt Source", sourceDoc.Id);
+        sourceSub.Inactive = false;
+        db.Set<Subscription>().Add(sourceSub);
+        await db.SaveChangesAsync();
+
+        var xchange = new Xchange(sourceSub, new XchangeFile("{\"n\":1}"));
+        db.Set<Xchange>().Add(xchange);
+        await db.SaveChangesAsync();
+        db.Set<XchangeResult>().Add(new XchangeResult(xchange.Id, null, null));
+        await db.SaveChangesAsync();
+
+        var aggSub = new Subscription("Agg Attempt", sourceSub.Id, Partner.SystemId);
+        aggSub.Inactive = false;
+        // A real aggregation always has one — SetSchedules throws without it, and the run would
+        // then report a failure it did not have.
+        aggSub.SetSchedules([new Schedule(Recurrence.Daily, TimeSpan.FromHours(2))]);
+        db.Set<Subscription>().Add(aggSub);
+        await db.SaveChangesAsync();
+
+        cache.Revoke();
+
+        await job.Execute(new AggregationJobParams(aggSub.Id, null));
+
+        var attempt = await db.Set<ReceiveAttempt>().SingleAsync(a => a.SubscriptionId == aggSub.Id);
+        Assert.Equal(ReceiveOutcome.Received, attempt.Outcome);
+        Assert.Null(attempt.ErrorMessage);
+
+        var rollUp = await db.Set<Xchange>().SingleAsync(x => x.SubscriptionId == aggSub.Id);
+        Assert.Equal([rollUp.Id], attempt.ExchangeIds);
+    }
+
+    [Fact]
+    public async Task A_run_with_nothing_outstanding_records_no_new_data_rather_than_nothing()
+    {
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var job = scope.ServiceProvider.GetRequiredService<AggregationJob>();
+        var cache = _fixture.App.Services.GetRequiredService<IInfolinkCache>();
+
+        var sourceDoc = new Document(null, "Agg Empty Attempt Doc", DocumentFormat.Json);
+        db.Set<Document>().Add(sourceDoc);
+        await db.SaveChangesAsync();
+        // A source with no exchanges at all — the run has nothing to collect.
+        var sourceSub = new Subscription("Agg Empty Attempt Source", sourceDoc.Id);
+        sourceSub.Inactive = false;
+        db.Set<Subscription>().Add(sourceSub);
+        await db.SaveChangesAsync();
+
+        var aggSub = new Subscription("Agg Empty Attempt", sourceSub.Id, Partner.SystemId);
+        aggSub.Inactive = false;
+        // A real aggregation always has one — SetSchedules throws without it, and the run would
+        // then report a failure it did not have.
+        aggSub.SetSchedules([new Schedule(Recurrence.Daily, TimeSpan.FromHours(2))]);
+        db.Set<Subscription>().Add(aggSub);
+        await db.SaveChangesAsync();
+
+        cache.Revoke();
+
+        await job.Execute(new AggregationJobParams(aggSub.Id, null));
+
+        var attempt = await db.Set<ReceiveAttempt>().SingleAsync(a => a.SubscriptionId == aggSub.Id);
+        Assert.Equal(ReceiveOutcome.NoNewData, attempt.Outcome);
+        Assert.Empty(attempt.ExchangeIds);
+        // The quiet outcome still creates no exchange — that part has not changed.
+        Assert.Equal(0, await db.Set<Xchange>().CountAsync(x => x.SubscriptionId == aggSub.Id));
+    }
+
+    [Fact]
+    public async Task An_inactive_aggregation_records_no_run_at_all()
+    {
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var job = scope.ServiceProvider.GetRequiredService<AggregationJob>();
+
+        var sourceDoc = new Document(null, "Agg Skipped Attempt Doc", DocumentFormat.Json);
+        db.Set<Document>().Add(sourceDoc);
+        await db.SaveChangesAsync();
+        var sourceSub = new Subscription("Agg Skipped Attempt Source", sourceDoc.Id);
+        db.Set<Subscription>().Add(sourceSub);
+        await db.SaveChangesAsync();
+
+        // Inactive by default — the job returns before it does anything, and a run that never
+        // happened must not appear in the history as a quiet success.
+        var aggSub = new Subscription("Agg Skipped Attempt", sourceSub.Id, Partner.SystemId);
+        db.Set<Subscription>().Add(aggSub);
+        await db.SaveChangesAsync();
+
+        await job.Execute(new AggregationJobParams(aggSub.Id, null));
+
+        Assert.Empty(await db.Set<ReceiveAttempt>().Where(a => a.SubscriptionId == aggSub.Id).ToListAsync());
+    }
+
+    // ─── Configuration ──────────────────────────────────────────────────────
+    //
+    // Which file a roll-up links to is the one aggregation setting no UI has ever offered.
+    // It reached the entity only through the generic property copy in the update handler, so
+    // create could not set it at all and every aggregation started on Input whatever the
+    // caller asked for. These pin the field to the shared applier both handlers run.
+
+    private static int _seq;
+    private static string Unique(string prefix) => $"{prefix}-{Interlocked.Increment(ref _seq)}";
+
+    /// <summary>An integration to roll up, and a partner to attribute the roll-up to.</summary>
+    private async Task<(int sourceId, int partnerId)> Groundwork()
+    {
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+
+        var doc = new Document(null, Unique("Agg config doc"), DocumentFormat.Json);
+        db.Set<Document>().Add(doc);
+        var partner = new Partner(Unique("Agg config partner"));
+        db.Set<Partner>().Add(partner);
+        await db.SaveChangesAsync();
+
+        var source = new Subscription(Unique("Agg config source"), doc.Id);
+        db.Set<Subscription>().Add(source);
+        await db.SaveChangesAsync();
+
+        return (source.Id, partner.Id);
+    }
+
+    private static ScheduleView[] Daily() =>
+        [new ScheduleView { Recurrence = Recurrence.Daily, Hours = 2 }];
+
+    private async Task<int> CreateAggregation(int sourceId, int partnerId, XchangeFileType? target)
+    {
+        await using var scope = _fixture.CreateScope();
+        scope.Superuser();
+        var handler = ActivatorUtilities.CreateInstance<Resources.Subscriptions.Create>(scope.ServiceProvider);
+
+        var model = new SubscriptionCreate
+        {
+            Name = Unique("Agg config"),
+            Type = SubscriptionType.Aggregation,
+            AggregationForId = sourceId,
+            PartnerId = partnerId,
+            Schedules = Daily(),
+        };
+        // Left unset on purpose by the caller testing the default, so that the test proves the
+        // default rather than the applier's willingness to copy whatever it was handed.
+        if (target.HasValue) model.AggregationTarget = target.Value;
+
+        return (int)await handler.Handle(model);
+    }
+
+    [Fact]
+    public async Task An_aggregation_can_be_created_collecting_the_mapped_file()
+    {
+        var (sourceId, partnerId) = await Groundwork();
+        var id = await CreateAggregation(sourceId, partnerId, XchangeFileType.Output);
+
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var entity = await db.Set<Subscription>().SingleAsync(s => s.Id == id);
+
+        Assert.Equal(XchangeFileType.Output, entity.AggregationTarget);
+    }
+
+    [Fact]
+    public async Task An_aggregation_collects_what_came_in_unless_told_otherwise()
+    {
+        var (sourceId, partnerId) = await Groundwork();
+        var id = await CreateAggregation(sourceId, partnerId, null);
+
+        await using var scope = _fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var entity = await db.Set<Subscription>().SingleAsync(s => s.Id == id);
+
+        Assert.Equal(XchangeFileType.Input, entity.AggregationTarget);
+    }
+
+    [Fact]
+    public async Task Changing_which_file_is_collected_is_kept()
+    {
+        var (sourceId, partnerId) = await Groundwork();
+        var id = await CreateAggregation(sourceId, partnerId, XchangeFileType.Input);
+
+        await using (var scope = _fixture.CreateScope())
+        {
+            scope.Superuser();
+            var update = ActivatorUtilities.CreateInstance<Resources.Subscriptions.Update>(scope.ServiceProvider);
+            await update.Handle(id, new SubscriptionUpdate
+            {
+                Name = Unique("Agg config renamed"),
+                AggregationForId = sourceId,
+                PartnerId = partnerId,
+                Schedules = Daily(),
+                AggregationTarget = XchangeFileType.Response,
+            });
+        }
+
+        await using var check = _fixture.CreateScope();
+        var db = check.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        var entity = await db.Set<Subscription>().SingleAsync(s => s.Id == id);
+
+        Assert.Equal(XchangeFileType.Response, entity.AggregationTarget);
+    }
+
+    [Fact]
+    public async Task The_list_reports_when_an_aggregation_next_runs()
+    {
+        var (sourceId, partnerId) = await Groundwork();
+        var id = await CreateAggregation(sourceId, partnerId, XchangeFileType.Output);
+
+        await using var scope = _fixture.CreateScope();
+        scope.Superuser();
+        var search = ActivatorUtilities.CreateInstance<Resources.Subscriptions.Search>(scope.ServiceProvider);
+
+        var response = (SearchyResponse<SubscriptionSearch>)await search.Handle(
+            new SearchyRequest { PageSize = 500, PageIndex = 0 });
+        var row = response.Result.Single(r => r.Id == id);
+
+        // ReceiveOn is only ever set for Receiving, and the list page reads one next-run field
+        // for both scheduled types — so without AggregateOn in the projection every aggregation
+        // row showed no next run at all, for a job that plainly has one.
+        Assert.NotNull(row.AggregateOn);
+        Assert.Null(row.ReceiveOn);
+        Assert.Equal(XchangeFileType.Output, row.AggregationTarget);
+    }
 }
diff --git a/SW.Bitween.Sdk/Model/Subscription.cs b/SW.Bitween.Sdk/Model/Subscription.cs
index 5211a96..39f177b 100644
--- a/SW.Bitween.Sdk/Model/Subscription.cs
+++ b/SW.Bitween.Sdk/Model/Subscription.cs
@@ -195,6 +195,17 @@ public abstract class SubscriptionConfiguration : SubscriptionCreateUpdateBase
 
         public int? RetryPolicyId { get; set; }
         public CustomRetryPolicy CustomRetryPolicy { get; set; }
+
+        /// <summary>
+        /// Aggregation only: which file of each collected exchange the roll-up links to.
+        /// <para>
+        /// Here rather than on <see cref="SubscriptionUpdate"/>, where it used to live, because
+        /// it is a choice a person makes and not runtime state. On update alone it reached the
+        /// entity through the generic property copy, so create could not set it and every
+        /// aggregation started on <see cref="XchangeFileType.Input"/> whatever was wanted.
+        /// </para>
+        /// </summary>
+        public XchangeFileType AggregationTarget { get; set; }
     }
 
     /// <summary>
@@ -244,7 +255,6 @@ public class SubscriptionUpdate : SubscriptionConfiguration
         public DateTime? AggregateOn { get; set; }
         public int ConsecutiveFailures { get; set; }
         public string LastException { get; set; }
-        public XchangeFileType AggregationTarget { get; set; }
         public DateTime? PausedOn { get; set; }
         public string CategoryCode { get; set; }
         public string CategoryDescription { get; set; }
diff --git a/SW.Bitween.Web/ClientApp/src/api/client.ts b/SW.Bitween.Web/ClientApp/src/api/client.ts
index 21f919f..670260e 100644
--- a/SW.Bitween.Web/ClientApp/src/api/client.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/client.ts
@@ -2,6 +2,7 @@ import type { AddBusRouteInput, AttachPartnerInput } from "./http/gateways";
 import type {
   AdapterInfo,
   AdapterKind,
+  AggregationTarget,
   ApiGateway,
   ApiGatewayAttachment,
   ApiGatewayDetail,
@@ -16,6 +17,7 @@ import type {
   GlobalValuesSetRow,
   InformationType,
   InformationTypeDetail,
+  InformationTypeFormat,
   InformationTypeRow,
   Subscription,
   SubscriptionDetail,
@@ -129,6 +131,8 @@ export interface ApiClient {
   listInformationTypes(): Promise<InformationTypeRow[]>;
   searchInformationTypes(query: {
     search: string;
+    format?: InformationTypeFormat | null;
+    busEnabled?: boolean | null;
     offset: number;
     limit: number;
   }): Promise<Paged<InformationTypeRow>>;
@@ -179,6 +183,10 @@ export interface ApiClient {
     informationTypeId: number;
     /** Required by the types that carry their own partner — Internal and ApiCall. */
     partnerId?: number | null;
+    /** Aggregation only: whose exchanges get rolled up. Required, and fixed once created. */
+    aggregationForId?: number | null;
+    /** Aggregation only: which file of each collected exchange the roll-up links to. */
+    aggregationTarget?: AggregationTarget;
     receiverId?: string | null;
     receiverProperties?: Record<string, string>;
     validatorId?: string | null;
@@ -214,6 +222,7 @@ export interface ApiClient {
         | "schedules"
         | "responseSubscriptionId"
         | "responseMessageTypeName"
+        | "aggregationTarget"
       >
     >,
   ): Promise<Subscription>;
@@ -221,6 +230,8 @@ export interface ApiClient {
   /** Toggles paused: paused subscriptions accept work but hold it. */
   pauseSubscription(id: number): Promise<Subscription>;
   receiveNow(id: number): Promise<Subscription>;
+  /** Runs an aggregation's roll-up now instead of waiting for its schedule. */
+  aggregateNow(id: number): Promise<Subscription>;
   /** Run history for one scheduled subscription, newest first. Empty for unscheduled types. */
   listSubscriptionRuns(id: number, limit?: number): Promise<SubscriptionRun[]>;
   searchReceiveAttempts(
@@ -251,7 +262,12 @@ export interface ApiClient {
 
   // — API gateways —
   listApiGateways(): Promise<ApiGatewayRow[]>;
-  searchApiGateways(query: { search: string; offset: number; limit: number }): Promise<Paged<ApiGatewayRow>>;
+  searchApiGateways(query: {
+    search: string;
+    inactive?: boolean | null;
+    offset: number;
+    limit: number;
+  }): Promise<Paged<ApiGatewayRow>>;
   getApiGateway(id: number): Promise<ApiGatewayDetail>;
   searchGatewayAttachments(
     apiGatewayId: number,
diff --git a/SW.Bitween.Web/ClientApp/src/api/http/documents.ts b/SW.Bitween.Web/ClientApp/src/api/http/documents.ts
index 0bed1fd..8278b0d 100644
--- a/SW.Bitween.Web/ClientApp/src/api/http/documents.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/http/documents.ts
@@ -150,11 +150,17 @@ export const documentMethods = {
 
   async searchInformationTypes(query: {
     search: string;
+    format?: InformationTypeFormat | null;
+    busEnabled?: boolean | null;
     offset: number;
     limit: number;
   }): Promise<Paged<InformationTypeRow>> {
     const qs = buildListQuery({
-      filters: [["Name", SEARCHY_RULE.contains, query.search.trim()]],
+      filters: [
+        ["Name", SEARCHY_RULE.contains, query.search.trim()],
+        ["DocumentFormat", SEARCHY_RULE.equalsTo, query.format ?? ""],
+        ["BusEnabled", SEARCHY_RULE.equalsTo, query.busEnabled == null ? "" : String(query.busEnabled)],
+      ],
       offset: query.offset,
       limit: query.limit,
     });
diff --git a/SW.Bitween.Web/ClientApp/src/api/http/gateways.ts b/SW.Bitween.Web/ClientApp/src/api/http/gateways.ts
index ffff5ec..fc6bcec 100644
--- a/SW.Bitween.Web/ClientApp/src/api/http/gateways.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/http/gateways.ts
@@ -136,9 +136,17 @@ export const gatewayMethods = {
     return (res.result ?? []).map(toApiGatewayRow);
   },
 
-  async searchApiGateways(query: { search: string; offset: number; limit: number }): Promise<Paged<ApiGatewayRow>> {
+  async searchApiGateways(query: {
+    search: string;
+    inactive?: boolean | null;
+    offset: number;
+    limit: number;
+  }): Promise<Paged<ApiGatewayRow>> {
     const qs = buildListQuery({
-      filters: [["Name", SEARCHY_RULE.contains, query.search.trim()]],
+      filters: [
+        ["Name", SEARCHY_RULE.contains, query.search.trim()],
+        ["Inactive", SEARCHY_RULE.equalsTo, query.inactive === null || query.inactive === undefined ? "" : String(query.inactive)],
+      ],
       offset: query.offset,
       limit: query.limit,
     });
diff --git a/SW.Bitween.Web/ClientApp/src/api/http/subscriptions.ts b/SW.Bitween.Web/ClientApp/src/api/http/subscriptions.ts
index 0266ac9..d5f2e4a 100644
--- a/SW.Bitween.Web/ClientApp/src/api/http/subscriptions.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/http/subscriptions.ts
@@ -1,6 +1,7 @@
 import type { ApiClient } from "../client";
 import {
   ApiRequestError,
+  type AggregationTarget,
   type Subscription,
   type SubscriptionDetail,
   type SubscriptionInfo,
@@ -93,7 +94,7 @@ interface RawSubscription {
   isRunning: boolean | null;
   consecutiveFailures: number;
   lastException: string | null;
-  aggregationTarget?: string;
+  aggregationTarget?: AggregationTarget;
 }
 
 const SUB_TYPE_BY_NUM: Record<number, SubscriptionType> = {
@@ -133,6 +134,13 @@ const toSchedules = (raw: RawSchedule[] | null): Schedule[] =>
     backwards: s.backwards,
   }));
 
+/**
+ * When the schedule fires next. The two scheduled types keep it in different columns —
+ * `ReceiveOn` for Receiving, `AggregateOn` for Aggregation — and only ever one of them is
+ * set, so taking whichever exists lets every screen read one field.
+ */
+const nextRunOf = (raw: RawSubscription): string | null => raw.receiveOn ?? raw.aggregateOn ?? null;
+
 function toSubscription(raw: RawSubscription, idOverride?: number): Subscription {
   return {
     id: raw.id ?? idOverride!,
@@ -157,8 +165,9 @@ function toSubscription(raw: RawSubscription, idOverride?: number): Subscription
     responseSubscriptionId: raw.responseSubscriptionId ?? null,
     responseMessageTypeName: raw.responseMessageTypeName ?? null,
     aggregationForId: raw.aggregationForId ?? null,
+    aggregationTarget: raw.aggregationTarget ?? "Input",
     isRunning: raw.isRunning ?? false,
-    nextReceiveOn: raw.receiveOn ?? null,
+    nextReceiveOn: nextRunOf(raw),
     consecutiveFailures: raw.consecutiveFailures ?? 0,
     lastException: raw.lastException ?? null,
     // Subscription has no CreatedOn column on the backend.
@@ -196,14 +205,15 @@ type UpdatableFields = Partial<
     | "schedules"
     | "responseSubscriptionId"
     | "responseMessageTypeName"
+    | "aggregationTarget"
   >
 >;
 
 /**
  * POST /subscriptions/{id} replaces the whole record, and Update.cs's model
  * (SubscriptionUpdate) carries several fields this UI never shows (categoryId,
- * aggregationTarget, temporary, …) — omitting them would silently reset them
- * to their type default. So every write reads the current full record first
+ * temporary, …) — omitting them would silently reset them to their type
+ * default. So every write reads the current full record first
  * and splices `changes` on top of it, mirroring writePartner()'s pattern.
  *
  * Secret adapter property values arrive masked as the literal string
@@ -240,7 +250,8 @@ async function applyChanges(id: number, current: RawSubscription, changes: Updat
     responseMessageTypeName:
       changes.responseMessageTypeName !== undefined ? changes.responseMessageTypeName : current.responseMessageTypeName,
     temporary: current.temporary,
-    aggregationTarget: current.aggregationTarget,
+    aggregationTarget:
+      changes.aggregationTarget !== undefined ? changes.aggregationTarget : current.aggregationTarget,
     pausedOn: current.pausedOn,
     receiveOn: current.receiveOn,
     aggregateOn: current.aggregateOn,
@@ -279,7 +290,9 @@ function toSubscriptionRow(
       schedules.length > 0 && (type === "Receiving" || type === "Aggregation")
         ? schedulesSummary(schedules)
         : undefined,
-    nextReceiveOn: raw.receiveOn ?? null,
+    nextReceiveOn: nextRunOf(raw),
+    aggregationForId: raw.aggregationForId ?? null,
+    aggregationTarget: raw.aggregationTarget ?? "Input",
     createdOn: "",
   };
 }
@@ -402,9 +415,17 @@ export const subscriptionMethods = {
   async createSubscription(input: {
     type: SubscriptionType;
     name: string;
+    /**
+     * Ignored for Aggregation — the backend constructor forces the built-in
+     * "Aggregation Document" whatever the caller sends, so there is nothing to pick.
+     */
     informationTypeId: number;
-    /** Required by the types that carry their own partner — Internal and ApiCall. */
+    /** Required by the types that carry their own partner — Internal, ApiCall and Aggregation. */
     partnerId?: number | null;
+    /** Aggregation only: whose exchanges get rolled up. Required, and fixed once created. */
+    aggregationForId?: number | null;
+    /** Aggregation only: which file of each collected exchange the roll-up links to. */
+    aggregationTarget?: AggregationTarget;
     receiverId?: string | null;
     receiverProperties?: Record<string, string>;
     validatorId?: string | null;
@@ -427,7 +448,8 @@ export const subscriptionMethods = {
       documentId: input.informationTypeId,
       type: input.type,
       partnerId: input.partnerId ?? null,
-      aggregationForId: null,
+      aggregationForId: input.aggregationForId ?? null,
+      aggregationTarget: input.aggregationTarget ?? "Input",
       receiverId: input.receiverId ?? null,
       receiverProperties: toKvArray(input.receiverProperties ?? {}),
       validatorId: input.validatorId ?? null,
@@ -470,6 +492,11 @@ export const subscriptionMethods = {
     return toSubscription(await fetchRaw(id), id);
   },
 
+  async aggregateNow(id: number): Promise<Subscription> {
+    await post(`/subscriptions/${id}/aggregatenow`, {});
+    return toSubscription(await fetchRaw(id), id);
+  },
+
   listSubscriptionRuns(id: number, limit = 20): Promise<SubscriptionRun[]> {
     return get<SubscriptionRun[]>(`/subscriptions/runs?subscriptionId=${id}&limit=${limit}`);
   },
diff --git a/SW.Bitween.Web/ClientApp/src/api/types.ts b/SW.Bitween.Web/ClientApp/src/api/types.ts
index d748d45..3ee6743 100644
--- a/SW.Bitween.Web/ClientApp/src/api/types.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/types.ts
@@ -425,9 +425,15 @@ export interface NotifierDetail extends Notifier {
 // ——— Subscriptions (subscriptions) ———
 
 /**
- * Backend Subscription.Type. Aggregation exists in data but is deferred in
- * this UI; Internal and ApiCall are legacy — shown and editable, never created.
+ * Backend Subscription.Type. Internal and ApiCall are legacy — shown and
+ * editable, never created.
  */
+
+/**
+ * Which file of each collected exchange an aggregation's roll-up links to: what came
+ * in, what the mapper produced, or what the destination handed back.
+ */
+export type AggregationTarget = "Input" | "Output" | "Response";
 /**
  * The editable fields of a subscription being defined inline, while whatever points
  * at it is being made. Mirrors the studio's own draft — deliberately, so the canvas
@@ -539,7 +545,14 @@ export interface Subscription {
   /** Feed the handler's response into another subscription. */
   responseSubscriptionId: number | null;
   responseMessageTypeName: string | null;
+  /**
+   * Aggregation only: whose exchanges get rolled up. Fixed at creation — the backend
+   * property has a private setter and the configuration applier deliberately skips it,
+   * so no update can repoint a live roll-up.
+   */
   aggregationForId: number | null;
+  /** Aggregation only. Meaningless for every other type, where it stays "Input". */
+  aggregationTarget: AggregationTarget;
   // — health (read-only) —
   isRunning: boolean;
   /** Receiving (and Aggregation) only — when the schedule will next fire, not when it last did. */
@@ -562,8 +575,16 @@ export interface SubscriptionRow {
   consecutiveFailures: number;
   lastException: string | null;
   scheduleSummary?: string;
-  /** Receiving (and Aggregation) only — when the schedule will next fire, not when it last did. */
+  /**
+   * Receiving and Aggregation only — when the schedule will next fire, not when it last
+   * did. The two types keep it in different columns on the backend (`ReceiveOn` vs
+   * `AggregateOn`); this is whichever one applies.
+   */
   nextReceiveOn: string | null;
+  /** Aggregation only: whose exchanges it rolls up. */
+  aggregationForId: number | null;
+  /** Aggregation only: which file of each collected exchange the roll-up links to. */
+  aggregationTarget: AggregationTarget;
   createdOn: string;
 }
 
diff --git a/SW.Bitween.Web/ClientApp/src/components/config/AggregationFields.tsx b/SW.Bitween.Web/ClientApp/src/components/config/AggregationFields.tsx
new file mode 100644
index 0000000..6ff44ff
--- /dev/null
+++ b/SW.Bitween.Web/ClientApp/src/components/config/AggregationFields.tsx
@@ -0,0 +1,93 @@
+import { Link } from "react-router";
+import type { AggregationTarget } from "../../api";
+import { Field, Select } from "../ui/forms";
+
+/**
+ * How each choice reads to a person. The enum names the file from the system's side
+ * ("Output"); these name it from the source exchange's side, which is the only way to
+ * tell them apart without already knowing the pipeline.
+ *
+ * One definition, three lengths: the dropdown and the studio node and the list column
+ * all describe the same setting, and three hand-written wordings drift.
+ */
+export const AGGREGATION_TARGET_LABEL: Record<AggregationTarget, string> = {
+  Input: "What came in",
+  Output: "What the mapper produced",
+  Response: "What the destination replied",
+};
+
+export const AGGREGATION_TARGET_DETAIL: Record<AggregationTarget, string> = {
+  Input: "links to what came in",
+  Output: "links to what the mapper produced",
+  Response: "links to what the destination replied",
+};
+
+const TARGET_OPTIONS = (Object.keys(AGGREGATION_TARGET_LABEL) as AggregationTarget[]).map((value) => ({
+  value,
+  label: AGGREGATION_TARGET_LABEL[value],
+}));
+
+/**
+ * The two things that make an aggregation what it is: whose exchanges it collects, and
+ * which of their files the roll-up links to.
+ *
+ * Shared by the subscription's studio card and the create dialog, so the wording a person
+ * reads while making one is the wording they read afterwards. The source is display-only
+ * here and picked by the caller instead — it is fixed at creation by the backend, whose
+ * `AggregationForId` has a private setter and is skipped by the configuration applier.
+ */
+export function AggregationFields({
+  source,
+  target,
+  onTargetChange,
+  disabled,
+}: {
+  /**
+   * The subscription being rolled up. `null` while one is still being chosen; omit it
+   * entirely when the caller shows the source itself and only the collected-file half
+   * is left to ask.
+   */
+  source?: { id: number; name: string } | null;
+  target: AggregationTarget;
+  onTargetChange: (target: AggregationTarget) => void;
+  disabled?: boolean;
+}) {
+  return (
+    <div className="space-y-4">
+      {source !== undefined && (
+      <Field
+        label="Rolls up"
+        hint="Fixed once created. Only its successful exchanges are collected — a failed one is never picked up, even if a later retry succeeds."
+      >
+        {source ? (
+          <p className="flex h-9.5 items-center text-sm">
+            <Link
+              to={`/subscriptions/${source.id}`}
+              className="font-medium text-ink-800 hover:text-crimson-700 hover:underline"
+            >
+              {source.name}
+            </Link>
+          </p>
+        ) : (
+          <p className="flex h-9.5 items-center text-sm text-ink-400">Not set</p>
+        )}
+      </Field>
+      )}
+
+      <Field
+        label="Collects"
+        htmlFor="agg-target"
+        hint="Links only — the documents are not combined. Your mapper or delivery does that."
+      >
+        <Select
+          id="agg-target"
+          value={target}
+          disabled={disabled}
+          title="Which file of each collected exchange the roll-up links to: what arrived, what the mapper produced, or what the destination replied."
+          onChange={(e) => onTargetChange(e.target.value as AggregationTarget)}
+          options={TARGET_OPTIONS}
+        />
+      </Field>
+    </div>
+  );
+}
diff --git a/SW.Bitween.Web/ClientApp/src/components/config/ScheduleEditor.tsx b/SW.Bitween.Web/ClientApp/src/components/config/ScheduleEditor.tsx
index c3a6903..06942a6 100644
--- a/SW.Bitween.Web/ClientApp/src/components/config/ScheduleEditor.tsx
+++ b/SW.Bitween.Web/ClientApp/src/components/config/ScheduleEditor.tsx
@@ -121,7 +121,7 @@ function ScheduleDialog({
   );
 }
 
-/** Controlled list of run schedules for receivers. */
+/** Controlled list of run schedules, for either scheduled type. */
 export function ScheduleEditor({
   schedules,
   onChange,
@@ -137,7 +137,7 @@ export function ScheduleEditor({
     <div>
       {schedules.length === 0 ? (
         <p className="pb-2 text-sm text-ink-500">
-          No schedule yet — this receiver never runs on its own.
+          No schedule yet — this never runs on its own.
         </p>
       ) : (
         <ul className="space-y-1.5">
diff --git a/SW.Bitween.Web/ClientApp/src/components/config/SubscriptionMultiFilter.tsx b/SW.Bitween.Web/ClientApp/src/components/config/SubscriptionMultiFilter.tsx
new file mode 100644
index 0000000..3e95f9d
--- /dev/null
+++ b/SW.Bitween.Web/ClientApp/src/components/config/SubscriptionMultiFilter.tsx
@@ -0,0 +1,122 @@
+import { useEffect, useRef, useState } from "react";
+import { ChevronDown, Search } from "lucide-react";
+import type { SubscriptionInfo } from "../../api";
+import { SUBSCRIPTION_TYPE_LABELS } from "./shared";
+
+/**
+ * Pick any number of subscriptions, to filter a table down to the rows connected to at
+ * least one of them — "which partners does this subscription use", read the other way.
+ *
+ * Modelled on `ReferenceMenu`'s local popover rather than the portalled `Popover`: a
+ * filter row sits above the table, not inside its `overflow-x-auto` wrapper, so nothing
+ * clips it and the lighter, in-flow panel is enough.
+ */
+export function SubscriptionMultiFilter({
+  subscriptions,
+  selected,
+  onChange,
+  label = "Filter by subscription",
+}: {
+  subscriptions: SubscriptionInfo[];
+  selected: number[];
+  onChange: (ids: number[]) => void;
+  label?: string;
+}) {
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const onDown = (e: MouseEvent) => {
+      if (!ref.current?.contains(e.target as Node)) setOpen(false);
+    };
+    const onKey = (e: KeyboardEvent) => e.key === "Escape" && setOpen(false);
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+
+  const needle = query.trim().toLowerCase();
+  const matches = subscriptions.filter((i) => !needle || i.name.toLowerCase().includes(needle));
+  const selectedSet = new Set(selected);
+
+  const toggle = (id: number) =>
+    onChange(selectedSet.has(id) ? selected.filter((x) => x !== id) : [...selected, id]);
+
+  const selectedNames = subscriptions.filter((i) => selectedSet.has(i.id)).map((i) => i.name);
+  const buttonLabel =
+    selectedNames.length === 0
+      ? "Any subscription"
+      : selectedNames.length === 1
+        ? selectedNames[0]
+        : `${selectedNames.length} subscriptions`;
+
+  return (
+    <div ref={ref} className="relative">
+      <button
+        type="button"
+        onClick={() => setOpen((o) => !o)}
+        aria-label={label}
+        aria-expanded={open}
+        title={selectedNames.length > 1 ? selectedNames.join(", ") : undefined}
+        className={`flex h-9 w-full items-center gap-1.5 rounded-lg border px-3 text-sm ${
+          selectedNames.length > 0
+            ? "border-crimson-300 bg-crimson-50 text-crimson-800"
+            : "border-ink-200 bg-white text-ink-600 hover:border-ink-300"
+        }`}
+      >
+        <span className="min-w-0 flex-1 truncate text-left">{buttonLabel}</span>
+        <ChevronDown className="size-3.5 shrink-0 text-ink-400" />
+      </button>
+      {open && (
+        <div className="absolute top-full left-0 z-40 mt-1.5 w-72 rounded-xl border border-ink-100 bg-white p-2 shadow-lg">
+          <div className="relative mb-1.5">
+            <Search className="pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-ink-400" />
+            <input
+              autoFocus
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+              placeholder="Search subscriptions"
+              aria-label="Search subscriptions"
+              className="h-8 w-full rounded-md border border-ink-200 bg-white pr-2 pl-8 text-[13px] placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+            />
+          </div>
+          {selectedNames.length > 0 && (
+            <button
+              type="button"
+              onClick={() => onChange([])}
+              className="mb-1 block w-full rounded-md px-2 py-1 text-left text-[12.5px] font-medium text-crimson-700 hover:bg-crimson-50"
+            >
+              Clear {selectedNames.length} selected
+            </button>
+          )}
+          <div className="max-h-60 overflow-y-auto">
+            {matches.length === 0 ? (
+              <p className="px-2 py-2 text-[13px] text-ink-400">No subscriptions match.</p>
+            ) : (
+              matches.map((i) => (
+                <label
+                  key={i.id}
+                  className="flex cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-[13px] hover:bg-ink-50"
+                >
+                  <input
+                    type="checkbox"
+                    checked={selectedSet.has(i.id)}
+                    onChange={() => toggle(i.id)}
+                    className="size-3.5 shrink-0 cursor-pointer rounded accent-crimson-600"
+                  />
+                  <span className="min-w-0 flex-1 truncate text-ink-800">{i.name}</span>
+                  <span className="shrink-0 text-[11px] text-ink-400">{SUBSCRIPTION_TYPE_LABELS[i.type]}</span>
+                </label>
+              ))
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/SW.Bitween.Web/ClientApp/src/components/ui/Table.tsx b/SW.Bitween.Web/ClientApp/src/components/ui/Table.tsx
index 08b34a3..b07e55c 100644
--- a/SW.Bitween.Web/ClientApp/src/components/ui/Table.tsx
+++ b/SW.Bitween.Web/ClientApp/src/components/ui/Table.tsx
@@ -3,6 +3,14 @@ import type { ReactNode } from "react";
 export interface Column<T> {
   /** Header text. Empty string for action/icon columns. */
   header: string;
+  /**
+   * What the column means, shown on hovering the header.
+   *
+   * Required reading for any header whose value is derived, abbreviated or otherwise not
+   * self-explanatory — "Reliability" reading `3/10` told nobody anything, and the header is
+   * what a person reads before they think to hover a cell. Plain words, not the formula.
+   */
+  headerTitle?: string;
   /** Cell renderer. */
   cell: (row: T) => ReactNode;
   /** Extra classes on both header and cells — width, alignment, wrapping. */
@@ -61,8 +69,10 @@ export function Table<T>({
         <thead>
           <tr className="border-b border-ink-100 text-[11px] font-medium tracking-wide text-ink-400 uppercase">
             {columns.map((c, i) => (
-              <th key={i} className={cellClass(c)}>
-                {c.header}
+              <th key={i} className={cellClass(c)} title={c.headerTitle}>
+                <span className={c.headerTitle ? "cursor-help decoration-ink-300 decoration-dotted underline-offset-4 hover:underline" : undefined}>
+                  {c.header}
+                </span>
               </th>
             ))}
           </tr>
@@ -135,8 +145,10 @@ export function MiniTable<T>({
         <thead>
           <tr className="border-b border-ink-100 text-[11px] font-medium tracking-wide text-ink-400 uppercase">
             {columns.map((c, i) => (
-              <th key={i} className={`pb-1 ${cell(c)}`}>
-                {c.header}
+              <th key={i} className={`pb-1 ${cell(c)}`} title={c.headerTitle}>
+                <span className={c.headerTitle ? "cursor-help decoration-ink-300 decoration-dotted underline-offset-4 hover:underline" : undefined}>
+                  {c.header}
+                </span>
               </th>
             ))}
           </tr>
diff --git a/SW.Bitween.Web/ClientApp/src/nav.ts b/SW.Bitween.Web/ClientApp/src/nav.ts
index aef57ea..7ef6c18 100644
--- a/SW.Bitween.Web/ClientApp/src/nav.ts
+++ b/SW.Bitween.Web/ClientApp/src/nav.ts
@@ -6,6 +6,7 @@ import {
   CalendarClock,
   FileText,
   Handshake,
+  FileStack,
   Layers,
   Network,
   RefreshCw,
@@ -62,6 +63,9 @@ export const NAV_GROUPS: NavGroup[] = [
       { label: "API gateways", path: "/api-gateways", icon: Webhook, permissions: ["api-gateways.view"] },
       { label: "Bus gateways", path: "/bus-gateways", icon: Cable, permissions: ["bus-gateways.view"] },
       { label: "Scheduled jobs", path: "/scheduled-jobs", icon: CalendarClock, permissions: ["subscriptions.view"] },
+      // Directly under scheduled jobs: it is the other thing that runs on a schedule,
+      // and it collects what one of these produced.
+      { label: "Aggregations", path: "/aggregations", icon: FileStack, permissions: ["subscriptions.view"] },
       // After the three ways work enters, because it is the picture of how they join up
       // rather than a fourth kind of them. Gated on the bus alone: bus messages are what
       // carry work *between* gateways, so without that permission there is no flow to map.
diff --git a/SW.Bitween.Web/ClientApp/src/pages/aggregations/AggregationsPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/aggregations/AggregationsPage.tsx
new file mode 100644
index 0000000..80c5ad8
--- /dev/null
+++ b/SW.Bitween.Web/ClientApp/src/pages/aggregations/AggregationsPage.tsx
@@ -0,0 +1,399 @@
+import { useMemo, useState } from "react";
+import { Link, useNavigate, useSearchParams } from "react-router";
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { Layers, Play, Plus, Search } from "lucide-react";
+import { api, type SubscriptionRow, type ScheduleHealth } from "../../api";
+import { Can, useSessionCan } from "../../auth/guards";
+import { PageHeader } from "../../components/layout/PageHeader";
+import { Badge, Button, EmptyState, LoadingBlock } from "../../components/ui/basics";
+import { ConfirmDialog } from "../../components/ui/overlays";
+import { Select } from "../../components/ui/forms";
+import { Pagination } from "../../components/ui/Pagination";
+import { Table } from "../../components/ui/Table";
+import { AGGREGATION_TARGET_LABEL } from "../../components/config/AggregationFields";
+import {
+  HealthBadge,
+  SubscriptionStatusBadges,
+  LinkListCell,
+  scheduleFault,
+  useSubscriptionsCache,
+  useRetryPolicyNames,
+  useWorkGroupNames,
+} from "../../components/config/shared";
+import { formatDateTime, formatDurationMs, timeAgo, timeUntil } from "../../lib/dates";
+
+function AggregateNowButton({ job }: { job: SubscriptionRow }) {
+  const queryClient = useQueryClient();
+  const [confirming, setConfirming] = useState(false);
+  const aggregate = useMutation({
+    mutationFn: () => api.aggregateNow(job.id),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ["subscription-rows"] });
+      void queryClient.invalidateQueries({ queryKey: ["subscription-rows-search"] });
+      void queryClient.invalidateQueries({ queryKey: ["last-runs"] });
+    },
+  });
+
+  return (
+    <>
+      <Button
+        size="sm"
+        disabled={!job.enabled}
+        title={job.enabled ? "Roll up everything outstanding right now." : "Enable the aggregation first."}
+        onClick={(e) => {
+          e.stopPropagation();
+          setConfirming(true);
+        }}
+      >
+        <Play className="size-3.5" /> Roll up now
+      </Button>
+      {confirming && (
+        <ConfirmDialog
+          title="Roll up now?"
+          // Not a dry run: the roll-up exchange goes down its own pipeline, so this can
+          // reach a partner. Everything it collects is also marked as collected, so a
+          // later scheduled run will not include it again.
+          body={`${job.name} collects everything outstanding immediately and runs its delivery — outside the regular schedule.`}
+          confirmLabel="Roll up now"
+          onConfirm={async () => {
+            await aggregate.mutateAsync();
+          }}
+          onClose={() => setConfirming(false)}
+        />
+      )}
+    </>
+  );
+}
+
+const STATUS_OPTIONS = [
+  { value: "", label: "Any status" },
+  { value: "false", label: "Active" },
+  { value: "true", label: "Disabled" },
+];
+
+/** The scheduler disagreeing with the subscription's own record — see the scheduled-jobs page. */
+function ScheduleFault({ health }: { health: ScheduleHealth | undefined }) {
+  const fault = scheduleFault(health);
+  if (!fault) return null;
+  return (
+    <Badge tone={fault.tone} title={fault.title}>
+      {fault.label}
+    </Badge>
+  );
+}
+
+/**
+ * Aggregations — the other scheduled type. On a schedule, one collects another
+ * subscription's successful exchanges and creates a single exchange whose payload is a
+ * JSON list of links to their files.
+ *
+ * Its own page rather than a row on Scheduled jobs, because the columns that matter are
+ * different ones: what it rolls up and which file it collects, in place of the
+ * information type every aggregation shares.
+ */
+const PAGE_SIZE = 25;
+
+export function AggregationsPage() {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const navigate = useNavigate();
+  const q = searchParams.get("q") ?? "";
+  const inactiveParam = searchParams.get("inactive");
+  const inactive = inactiveParam === "true" ? true : inactiveParam === "false" ? false : null;
+  const offset = searchParams.get("offset") ? Number(searchParams.get("offset")) : 0;
+  const canOperate = useSessionCan("subscriptions.operate");
+
+  const rows = useQuery({
+    queryKey: ["subscription-rows-search", "Aggregation", q, inactive, offset],
+    queryFn: () =>
+      api.searchSubscriptionRows({ search: q, type: "Aggregation", inactive, offset, limit: PAGE_SIZE }),
+    placeholderData: keepPreviousData,
+  });
+  // The list rows don't carry work group or retry policy; the subscriptions cache does,
+  // and it is also where the source subscription's name comes from.
+  const setups = useSubscriptionsCache().data ?? [];
+  const setupById = useMemo(() => new Map(setups.map((s) => [s.id, s])), [setups]);
+  const nameById = useMemo(() => new Map(setups.map((s) => [s.id, s.name])), [setups]);
+  const workGroupNames = useWorkGroupNames();
+  const retryPolicyNames = useRetryPolicyNames();
+  const lastRuns = useQuery({ queryKey: ["last-runs"], queryFn: () => api.listLastRuns() }).data ?? [];
+  const lastRunById = useMemo(() => new Map(lastRuns.map((r) => [r.subscriptionId, r])), [lastRuns]);
+  const health =
+    useQuery({ queryKey: ["schedule-health"], queryFn: () => api.listScheduleHealth() }).data ?? [];
+  const healthById = useMemo(() => new Map(health.map((h) => [h.subscriptionId, h])), [health]);
+
+  const setParam = (key: string, value: string | null, resetOffset = true) =>
+    setSearchParams(
+      (prev) => {
+        const next = new URLSearchParams(prev);
+        if (value) next.set(key, value);
+        else next.delete(key);
+        if (resetOffset) next.delete("offset");
+        return next;
+      },
+      { replace: true },
+    );
+
+  const filtered = rows.data?.result ?? [];
+  const total = rows.data?.total ?? 0;
+
+  return (
+    <div>
+      <PageHeader
+        title="Aggregations"
+        description="Collect a subscription's exchanges on a schedule into one exchange listing links to their files. The files are not combined — a mapper or delivery does that."
+        actions={
+          <Can permission="subscriptions.create">
+            <Button variant="primary" onClick={() => navigate("/aggregations/new")}>
+              <Plus className="size-4" /> New aggregation
+            </Button>
+          </Can>
+        }
+      />
+
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search aggregations"
+            aria-label="Search aggregations"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-40">
+          <Select
+            aria-label="Filter by status"
+            className="!h-8 text-[13px]"
+            value={inactiveParam ?? ""}
+            onChange={(e) => setParam("inactive", e.target.value || null)}
+            options={STATUS_OPTIONS}
+          />
+        </div>
+      </div>
+
+      {rows.isPending ? (
+        <LoadingBlock label="Loading aggregations…" />
+      ) : filtered.length === 0 ? (
+        <EmptyState icon={<Layers />} title={q || inactive !== null ? "No aggregations match" : "No aggregations yet"}>
+          {q || inactive !== null
+            ? "Try a different search or filter."
+            : "Create one here, or open the subscription you want summarised and choose “Roll these up”."}
+        </EmptyState>
+      ) : (
+        <Table
+          rows={filtered}
+          rowKey={(r) => r.id}
+          minWidth="min-w-270"
+          onRowClick={(r) => navigate(`/subscriptions/${r.id}`)}
+          footer={
+            <Pagination
+              offset={offset}
+              limit={PAGE_SIZE}
+              total={total}
+              onOffsetChange={(o) => setParam("offset", String(o), false)}
+            />
+          }
+          columns={[
+            {
+              header: "Aggregation",
+              headerTitle: "The roll-up job itself. Open it to configure what it delivers.",
+              truncate: true,
+              cell: (r) => <span className="block truncate font-medium text-ink-900">{r.name}</span>,
+            },
+            {
+              // The whole point of the row: an aggregation with no source name is one
+              // whose source was deleted, and it will never produce anything again.
+              header: "Rolls up",
+              headerTitle: "The subscription whose successful exchanges this collects. Fixed when the aggregation was created.",
+              truncate: true,
+              cell: (r) => {
+                const name = r.aggregationForId === null ? null : nameById.get(r.aggregationForId);
+                if (r.aggregationForId === null)
+                  return <span className="text-[13px] text-ink-400">Not set</span>;
+                return name ? (
+                  <Link
+                    to={`/subscriptions/${r.aggregationForId}`}
+                    onClick={(e) => e.stopPropagation()}
+                    className="block truncate text-[13px] text-ink-700 hover:text-crimson-700 hover:underline"
+                  >
+                    {name}
+                  </Link>
+                ) : (
+                  <span className="text-[13px] text-ink-400">—</span>
+                );
+              },
+            },
+            {
+              header: "Collects",
+              headerTitle: "Which file of each collected exchange the roll-up links to. Links only \u2014 the files are not combined.",
+              truncate: true,
+              cell: (r) => (
+                <span className="block truncate text-[13px] text-ink-600">
+                  {AGGREGATION_TARGET_LABEL[r.aggregationTarget]}
+                </span>
+              ),
+            },
+            {
+              header: "Last run",
+              headerTitle: "When the roll-up last ran, how long it took, and whether someone triggered it by hand.",
+              className: "whitespace-nowrap",
+              cell: (r) => {
+                const run = lastRunById.get(r.id);
+                if (!run)
+                  return (
+                    <span className="text-ink-400" title="No run in the last 30 days">
+                      —
+                    </span>
+                  );
+                const running = run.success === null;
+                return (
+                  <>
+                    <span className="text-[13px] font-medium text-ink-800">{timeAgo(run.startedOn)}</span>
+                    <span
+                      className={`block text-xs ${run.success === false ? "text-danger-700" : "text-ink-400"}`}
+                    >
+                      {running
+                        ? "running…"
+                        : [
+                            run.success === false ? "failed" : null,
+                            run.durationMs !== null ? formatDurationMs(run.durationMs) : null,
+                            run.manual ? "manual" : null,
+                          ]
+                            .filter(Boolean)
+                            .join(" · ")}
+                    </span>
+                  </>
+                );
+              },
+            },
+            {
+              header: "Reliability",
+              headerTitle: "How many of the last runs succeeded, from the scheduler\u2019s own history (about 30 days). 3/10 means 3 of the last 10 finished runs worked.",
+              className: "whitespace-nowrap",
+              cell: (r) => {
+                const run = lastRunById.get(r.id);
+                if (!run || run.recentTotal === 0) return <span className="text-ink-400">—</span>;
+                const failed = run.recentTotal - run.recentSucceeded;
+                return (
+                  <span
+                    className={`text-[13px] ${failed > 0 ? "text-danger-700" : "text-ink-600"}`}
+                    title={`${run.recentSucceeded} of the last ${run.recentTotal} finished runs succeeded`}
+                  >
+                    {run.recentSucceeded}/{run.recentTotal}
+                  </span>
+                );
+              },
+            },
+            {
+              // The subscription's own AggregateOn, the aggregation counterpart of the
+              // ReceiveOn the scheduled-jobs page shows.
+              header: "Next run",
+              headerTitle: "When the schedule fires next. A dash means no schedule, so it only runs when someone presses Roll up now.",
+              className: "whitespace-nowrap",
+              cell: (r) =>
+                r.nextReceiveOn ? (
+                  <>
+                    <span className="text-[13px] font-medium text-ink-800">{timeUntil(r.nextReceiveOn)}</span>
+                    <span className="block text-xs text-ink-400">{formatDateTime(r.nextReceiveOn)}</span>
+                  </>
+                ) : (
+                  <span className="text-ink-400">—</span>
+                ),
+            },
+            {
+              header: "Partner",
+              headerTitle: "Who the roll-up exchange belongs to. Not the partners of the exchanges it collected \u2014 one roll-up can cover many.",
+              truncate: true,
+              cell: (r) => (
+                <LinkListCell
+                  label="partners"
+                  items={r.partners.map((p) => ({
+                    key: p.id,
+                    name: p.name,
+                    href: `/partners/${p.id}`,
+                  }))}
+                />
+              ),
+            },
+            {
+              header: "Work group",
+              headerTitle: "Which queue lane the roll-up runs in \u2014 the difference between idle and queued behind other work.",
+              truncate: true,
+              cell: (r) => {
+                const id = setupById.get(r.id)?.workGroupId ?? null;
+                const name = id === null ? null : (workGroupNames.get(id) ?? null);
+                if (id === null) return <span className="text-[13px] text-ink-400">Ungrouped</span>;
+                return name ? (
+                  <Link
+                    to={`/work-groups/${id}`}
+                    onClick={(e) => e.stopPropagation()}
+                    className="block truncate text-[13px] text-ink-700 hover:text-crimson-700 hover:underline"
+                  >
+                    {name}
+                  </Link>
+                ) : (
+                  <span className="text-[13px] text-ink-400">—</span>
+                );
+              },
+            },
+            {
+              header: "Retry policy",
+              headerTitle: "What happens when the roll-up\u2019s delivery fails. None means a failure is recorded and left alone.",
+              truncate: true,
+              cell: (r) => {
+                const id = setupById.get(r.id)?.retryPolicyId ?? null;
+                const name = id === null ? null : (retryPolicyNames.get(id) ?? null);
+                if (id === null) return <span className="text-[13px] text-ink-400">None</span>;
+                return name ? (
+                  <Link
+                    to={`/retry-policies/${id}`}
+                    onClick={(e) => e.stopPropagation()}
+                    className="block truncate text-[13px] text-ink-700 hover:text-crimson-700 hover:underline"
+                  >
+                    {name}
+                  </Link>
+                ) : (
+                  <span className="text-[13px] text-ink-400">—</span>
+                );
+              },
+            },
+            {
+              header: "Status",
+              headerTitle: "Whether it is turned on, holding work, and executing right now. Hover a badge for what it means.",
+              cell: (r) => (
+                <span className="inline-flex items-center gap-1">
+                  <ScheduleFault health={healthById.get(r.id)} />
+                  <SubscriptionStatusBadges enabled={r.enabled} paused={r.paused} />
+                  <HealthBadge isRunning={r.isRunning} consecutiveFailures={r.consecutiveFailures} />
+                </span>
+              ),
+            },
+            {
+              header: "Last error",
+              headerTitle: "The most recent failure this aggregation recorded. Open the row for the full run history.",
+              truncate: true,
+              cell: (r) =>
+                r.lastException ? (
+                  <span
+                    className="block truncate font-mono text-[11px] text-danger-700"
+                    title={r.lastException}
+                  >
+                    {r.lastException}
+                  </span>
+                ) : (
+                  <span className="text-ink-400">—</span>
+                ),
+            },
+            {
+              header: "",
+              align: "right",
+              cell: (r) => canOperate && <AggregateNowButton job={r} />,
+            },
+          ]}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/SW.Bitween.Web/ClientApp/src/pages/aggregations/NewAggregationPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/aggregations/NewAggregationPage.tsx
new file mode 100644
index 0000000..48af87a
--- /dev/null
+++ b/SW.Bitween.Web/ClientApp/src/pages/aggregations/NewAggregationPage.tsx
@@ -0,0 +1,360 @@
+import { useState } from "react";
+import { useNavigate, useSearchParams } from "react-router";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { X } from "lucide-react";
+import { Button, FormError } from "../../components/ui/basics";
+import { Checkbox, Field, TextInput } from "../../components/ui/forms";
+import { Panel } from "../../components/ui/Panel";
+import { SearchSelect } from "../../components/ui/SearchSelect";
+import { AdapterConfig, useAdapterCatalog } from "../../components/config/AdapterConfig";
+import { AggregationFields } from "../../components/config/AggregationFields";
+import { ScheduleEditor } from "../../components/config/ScheduleEditor";
+import { PartnerPicker } from "../../components/config/pickers";
+import { useSubscriptionsCache } from "../../components/config/shared";
+import { api, type AggregationTarget, type Schedule } from "../../api";
+import { STAGES, type StageId } from "../subscriptions/studio/stages";
+import { StageRail } from "../subscriptions/studio/StageRail";
+import { adapterIncomplete, faceOf } from "../subscriptions/studio/faces";
+import { ResponseFields } from "../subscriptions/studio/ResponseFields";
+import type { Draft as StudioDraft } from "../subscriptions/studio/model";
+import { BackLink } from "../../components/ui/BackLink";
+
+/** Local draft state with the patch-and-clear shape the other create pages use. */
+function useDraft<T extends object>(initial: T) {
+  const [draft, setDraft] = useState<T>(initial);
+  const update = (patch: Partial<T>) => setDraft((d) => ({ ...d, ...patch }));
+  return [draft, update] as const;
+}
+
+/** The whole pipeline — the same nodes the studio page edits for a saved aggregation. */
+const STAGES_HERE: StageId[] = ["aggregation", "schedule", "transformation", "delivery", "response"];
+
+type Draft = Pick<
+  StudioDraft,
+  | "name"
+  | "schedules"
+  | "aggregationTarget"
+  | "mapperId"
+  | "mapperProperties"
+  | "handlerId"
+  | "handlerProperties"
+  | "responseSubscriptionId"
+  | "responseMessageTypeName"
+> & {
+  aggregationForId: number | null;
+  partnerId: number | null;
+  /**
+   * Whether the partner shown is the person's own choice. Without this, "cleared it" and
+   * "hasn't chosen yet" look identical and the source's partner keeps coming back.
+   */
+  partnerTouched: boolean;
+  enable: boolean;
+};
+
+const EMPTY: Draft = {
+  name: "",
+  aggregationForId: null,
+  partnerId: null,
+  partnerTouched: false,
+  aggregationTarget: "Input",
+  // A sensible default so the node starts valid, edited through the full recurrence editor
+  // on demand — matching the scheduled-job page. An aggregation has no other trigger, so a
+  // draft that starts with none would open on a broken node.
+  schedules: [{ recurrence: "Daily", days: 0, hours: 0, minutes: 0, backwards: false }] as Schedule[],
+  mapperId: null,
+  mapperProperties: {},
+  handlerId: null,
+  handlerProperties: {},
+  responseSubscriptionId: null,
+  responseMessageTypeName: null,
+  enable: false,
+};
+
+/**
+ * Creating an aggregation, on the same pipeline the studio page edits — the scheduled-job
+ * page's shape, for the same reason: you learn the rail once, and after Create you land on
+ * the page you were already looking at.
+ *
+ * Arrives with `?source=` when started from the subscription being rolled up, in which case
+ * the source is fixed and shown rather than picked. Either way it is fixed after creation:
+ * the backend's `AggregationForId` has a private setter and the configuration applier skips
+ * it, so no update can repoint a live roll-up.
+ */
+export function NewAggregationPage() {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const [params] = useSearchParams();
+  const fixedSourceId = params.get("source") ? Number(params.get("source")) : null;
+
+  const [stage, setStage] = useState<StageId | null>("aggregation");
+
+  const allSubscriptions = useSubscriptionsCache();
+  const receivers = useAdapterCatalog("receiver");
+  const validators = useAdapterCatalog("validator");
+  const mappers = useAdapterCatalog("mapper");
+  const handlers = useAdapterCatalog("handler");
+
+  const [draft, update] = useDraft<Draft>({ ...EMPTY, aggregationForId: fixedSourceId });
+
+  const source = allSubscriptions.data?.find((s) => s.id === draft.aggregationForId) ?? null;
+
+  // An aggregation may point at another aggregation — the backend does not stop it, and a
+  // chain of roll-ups summarising roll-ups is not a shape anyone has asked for.
+  const candidates = (allSubscriptions.data ?? []).filter((s) => s.type !== "Aggregation");
+
+  // The source's own partner where it has one, until the person says otherwise. It is a
+  // suggestion rather than an inheritance: a Receiving source usually has no partner at all,
+  // and the roll-up's partner answers a different question from the source's anyway.
+  const partnerId = draft.partnerTouched ? draft.partnerId : (source?.partnerIds[0] ?? null);
+
+  const create = useMutation({
+    mutationFn: () =>
+      api.createSubscription({
+        type: "Aggregation",
+        name: draft.name.trim(),
+        // Ignored for this type — the backend forces the built-in Aggregation Document.
+        informationTypeId: 0,
+        partnerId,
+        aggregationForId: draft.aggregationForId,
+        aggregationTarget: draft.aggregationTarget,
+        schedules: draft.schedules,
+        mapperId: draft.mapperId,
+        mapperProperties: draft.mapperProperties,
+        handlerId: draft.handlerId,
+        handlerProperties: draft.handlerProperties,
+        responseSubscriptionId: draft.responseSubscriptionId,
+        responseMessageTypeName: draft.responseMessageTypeName,
+        enabled: draft.enable,
+      }),
+    onSuccess: (created) => {
+      void queryClient.invalidateQueries();
+      navigate(`/subscriptions/${created.id}`);
+    },
+  });
+
+  // faceOf works off the studio's full draft shape; the fields this type never has are empty.
+  const studioDraft: StudioDraft = {
+    ...draft,
+    enabled: draft.enable,
+    workGroupId: null,
+    retryPolicyId: null,
+    receiverId: null,
+    receiverProperties: {},
+    validatorId: null,
+    validatorProperties: {},
+    matchExpression: null,
+  };
+
+  const faces = STAGES_HERE.map((id) =>
+    faceOf(id, {
+      type: "Aggregation",
+      draft: studioDraft,
+      catalogs: { receivers, validators, mappers, handlers },
+      subscriptionNames: allSubscriptions.data,
+      aggregationForId: draft.aggregationForId,
+      unsaved: true,
+    }),
+  );
+
+  const unfilled = [
+    adapterIncomplete(mappers, draft.mapperId, draft.mapperProperties) && "transformation",
+    adapterIncomplete(handlers, draft.handlerId, draft.handlerProperties) && "delivery",
+  ].filter((m): m is string => typeof m === "string");
+
+  const missing = [
+    draft.aggregationForId === null && "something to roll up",
+    draft.name.trim().length < 2 && "a name",
+    partnerId === null && "a partner",
+    // As strict as the scheduled-job page, for the same reason: a roll-up with nowhere to go
+    // is built and then thrown away. It also keeps the rail honest — the Delivery node reads
+    // "Needed" while nothing is set, and that has to mean something.
+    draft.handlerId === null && "a delivery",
+    // Create does not demand a schedule, but update does — one saved without could never be
+    // saved again from its own page. The surface that can make that mistake refuses to.
+    draft.schedules.length === 0 && "a schedule",
+    unfilled.length > 0 && `the required fields on ${unfilled.join(" and ")}`,
+  ].filter((m): m is string => typeof m === "string");
+
+  const renderStage = (stageId: StageId) => {
+    const { label, description } = STAGES[stageId];
+    switch (stageId) {
+      case "aggregation":
+        return (
+          <Panel title={label} description={description}>
+            <AggregationFields
+              source={source}
+              target={draft.aggregationTarget}
+              onTargetChange={(aggregationTarget: AggregationTarget) => update({ aggregationTarget })}
+            />
+          </Panel>
+        );
+      case "schedule":
+        return (
+          <Panel title={label} description="When the source's exchanges are rolled up.">
+            <ScheduleEditor
+              schedules={draft.schedules}
+              onChange={(schedules) => update({ schedules })}
+              disabled={false}
+            />
+          </Panel>
+        );
+      case "transformation":
+        return (
+          <Panel title={label} description={description}>
+            <AdapterConfig
+              kind="mapper"
+              adapterId={draft.mapperId}
+              properties={draft.mapperProperties}
+              onChange={(mapperId, mapperProperties) => update({ mapperId, mapperProperties })}
+              disabled={false}
+              noneLabel="None — the list of links is delivered as it is"
+            />
+            <p className="mt-3 rounded-lg bg-ink-50 px-3 py-2 text-[13px] text-ink-500">
+              What arrives here is a JSON list of links, not the documents themselves. Combining
+              them into one file is this step's job, or the delivery's.
+            </p>
+          </Panel>
+        );
+      case "delivery":
+        return (
+          <Panel title={label} description={description}>
+            <AdapterConfig
+              kind="handler"
+              adapterId={draft.handlerId}
+              properties={draft.handlerProperties}
+              onChange={(handlerId, handlerProperties) => update({ handlerId, handlerProperties })}
+              disabled={false}
+              required
+            />
+          </Panel>
+        );
+      case "response":
+        return (
+          <Panel title={label} description={description}>
+            <ResponseFields
+              handlerId={draft.handlerId}
+              responseSubscriptionId={draft.responseSubscriptionId}
+              responseMessageTypeName={draft.responseMessageTypeName}
+              onChange={update}
+              disabled={false}
+              candidates={allSubscriptions.data ?? []}
+              idPrefix="na-resp"
+            />
+          </Panel>
+        );
+      default:
+        return null;
+    }
+  };
+
+  return (
+    <div className="pb-10">
+      <BackLink to="/aggregations" label="Aggregations" />
+
+      <h1 className="text-[22px] font-semibold tracking-tight text-ink-900">New aggregation</h1>
+      <p className="mt-1 mb-5 text-sm text-ink-500">
+        On a schedule, collects another subscription's successful exchanges into one exchange
+        listing links to their files. It does not combine the files — the transformation or the
+        delivery does that.
+      </p>
+
+      <div className="mb-5 flex flex-wrap gap-5">
+        <div className="w-80">
+          <Field label="Name" htmlFor="na-name">
+            <TextInput
+              id="na-name"
+              value={draft.name}
+              autoFocus
+              placeholder={source ? `e.g. ${source.name} — daily manifest` : "e.g. Daily invoice manifest"}
+              onChange={(e) => update({ name: e.target.value })}
+            />
+          </Field>
+        </div>
+        {fixedSourceId === null && (
+          <div className="w-80">
+            <Field
+              label="Rolls up"
+              htmlFor="na-source"
+              hint="Fixed once created. An aggregation cannot roll up another aggregation."
+            >
+              <SearchSelect
+                id="na-source"
+                aria-label="Subscription to roll up"
+                value={draft.aggregationForId === null ? "" : String(draft.aggregationForId)}
+                disabled={allSubscriptions.isPending}
+                onChange={(v) => v !== "" && update({ aggregationForId: Number(v) })}
+                placeholder="Pick a subscription…"
+                options={candidates.map((s) => ({ value: String(s.id), label: s.name, hint: s.type }))}
+              />
+            </Field>
+          </div>
+        )}
+        <div className="w-80">
+          <Field
+            label="Partner"
+            htmlFor="na-partner"
+            // The question this answers is not "whose exchanges are collected" — one roll-up
+            // can sweep up exchanges belonging to many partners, or to none. It is who the
+            // roll-up itself belongs to.
+            hint="Who the roll-up exchange belongs to, and whose values fill {{partner.…}} in the delivery below. It does not affect which exchanges are collected."
+          >
+            <PartnerPicker
+              id="na-partner"
+              value={partnerId}
+              onChange={(v) => update({ partnerId: v === "none" ? null : v, partnerTouched: true })}
+            />
+          </Field>
+        </div>
+      </div>
+
+      <StageRail faces={faces} selected={stage} onSelect={setStage} />
+
+      {stage !== null && (
+        <div className="relative">
+          {renderStage(stage)}
+          <button
+            type="button"
+            onClick={() => setStage(null)}
+            aria-label="Close this step"
+            title="Close"
+            className="absolute top-2.5 right-3 rounded-md p-1.5 text-ink-400 hover:bg-ink-100 hover:text-ink-700"
+          >
+            <X className="size-4" />
+          </button>
+        </div>
+      )}
+
+      <div className="mt-5 flex flex-wrap items-center justify-between gap-3 rounded-xl border border-ink-200 bg-white px-4 py-3">
+        <Checkbox
+          label="Enable immediately"
+          // Off by default, unlike a scheduled job: the first run of a new aggregation sweeps
+          // up every successful exchange its source has ever produced, which for an old source
+          // can be a very large first roll-up going straight to a partner.
+          description="Off by default — the first run collects everything the source has ever produced, so enable it when you've checked the pipeline."
+          checked={draft.enable}
+          onChange={(e) => update({ enable: e.target.checked })}
+        />
+        <div className="flex items-center gap-3">
+          {missing.length > 0 && (
+            <p className="text-[13px] text-ink-500">
+              Still needs {missing.slice(0, -1).join(", ")}
+              {missing.length > 1 ? " and " : ""}
+              {missing.at(-1)}.
+            </p>
+          )}
+          <Button onClick={() => navigate("/aggregations")}>Cancel</Button>
+          <Button
+            variant="primary"
+            busy={create.isPending}
+            disabled={missing.length > 0}
+            onClick={() => create.mutate()}
+          >
+            Create aggregation
+          </Button>
+        </div>
+      </div>
+
+      <FormError>{create.error?.message}</FormError>
+    </div>
+  );
+}
diff --git a/SW.Bitween.Web/ClientApp/src/pages/api-gateways/ApiGatewaysPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/api-gateways/ApiGatewaysPage.tsx
index e4dedc1..804d0be 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/api-gateways/ApiGatewaysPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/api-gateways/ApiGatewaysPage.tsx
@@ -6,6 +6,7 @@ import { Can } from "../../auth/guards";
 import { PageHeader } from "../../components/layout/PageHeader";
 import { Badge, Button, EmptyState, LoadingBlock } from "../../components/ui/basics";
 import { Pagination } from "../../components/ui/Pagination";
+import { Select } from "../../components/ui/forms";
 import { Table } from "../../components/ui/Table";
 import {
   LinkListCell,
@@ -20,15 +21,23 @@ import {
  */
 const PAGE_SIZE = 25;
 
+const STATUS_OPTIONS = [
+  { value: "", label: "Any status" },
+  { value: "false", label: "Active" },
+  { value: "true", label: "Deactivated" },
+];
+
 export function ApiGatewaysPage() {
   const [searchParams, setSearchParams] = useSearchParams();
   const navigate = useNavigate();
   const q = searchParams.get("q") ?? "";
+  const inactiveParam = searchParams.get("inactive");
+  const inactive = inactiveParam === "true" ? true : inactiveParam === "false" ? false : null;
   const offset = searchParams.get("offset") ? Number(searchParams.get("offset")) : 0;
 
   const gateways = useQuery({
-    queryKey: ["api-gateways-search", q, offset],
-    queryFn: () => api.searchApiGateways({ search: q, offset, limit: PAGE_SIZE }),
+    queryKey: ["api-gateways-search", q, inactive, offset],
+    queryFn: () => api.searchApiGateways({ search: q, inactive, offset, limit: PAGE_SIZE }),
     placeholderData: keepPreviousData,
   });
   const subscriptionsById = useSubscriptionRowsById();
@@ -62,23 +71,34 @@ export function ApiGatewaysPage() {
         }
       />
 
-      <div className="relative mb-4 max-w-xs">
-        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
-        <input
-          type="search"
-          value={q}
-          onChange={(e) => setParam("q", e.target.value || null)}
-          placeholder="Search gateways"
-          aria-label="Search API gateways"
-          className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
-        />
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search gateways"
+            aria-label="Search API gateways"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-40">
+          <Select
+            aria-label="Filter by status"
+            className="!h-8 text-[13px]"
+            value={inactiveParam ?? ""}
+            onChange={(e) => setParam("inactive", e.target.value || null)}
+            options={STATUS_OPTIONS}
+          />
+        </div>
       </div>
 
       {gateways.isPending ? (
         <LoadingBlock label="Loading API gateways…" />
       ) : rows.length === 0 ? (
-        <EmptyState icon={<Webhook />} title={q ? "No gateways match" : "No API gateways yet"}>
-          {q ? "Try a different search." : "Create a gateway to give partners a URL to push documents to."}
+        <EmptyState icon={<Webhook />} title={q || inactive !== null ? "No gateways match" : "No API gateways yet"}>
+          {q || inactive !== null ? "Try a different search or filter." : "Create a gateway to give partners a URL to push documents to."}
         </EmptyState>
       ) : (
         <Table
diff --git a/SW.Bitween.Web/ClientApp/src/pages/api-gateways/NewGatewaySubscriptionPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/api-gateways/NewGatewaySubscriptionPage.tsx
index 323de06..fdaea86 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/api-gateways/NewGatewaySubscriptionPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/api-gateways/NewGatewaySubscriptionPage.tsx
@@ -134,6 +134,8 @@ export function NewGatewaySubscriptionPage() {
   // set (there is no receiver, schedule or filter on this type) are simply empty.
   const studioDraft: StudioDraft = {
     ...draft,
+    // Aggregation only, and this page never creates one.
+    aggregationTarget: "Input",
     enabled: true,
     workGroupId: null,
     retryPolicyId: null,
diff --git a/SW.Bitween.Web/ClientApp/src/pages/exchanges/ExchangeDrawer.tsx b/SW.Bitween.Web/ClientApp/src/pages/exchanges/ExchangeDrawer.tsx
index b006769..5cb3e85 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/exchanges/ExchangeDrawer.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/exchanges/ExchangeDrawer.tsx
@@ -7,6 +7,7 @@ import { useSessionCan } from "../../auth/guards";
 import { Badge, Button } from "../../components/ui/basics";
 import { ConfirmDialog } from "../../components/ui/overlays";
 import { formatDateTime, duration, timeUntil } from "../../lib/dates";
+import { useSubscriptionsCache } from "../../components/config/shared";
 import { RetryDialog, journeyStages, type JourneyStage } from "./shared";
 
 const STAGE_TONES: Record<JourneyStage["state"], { ring: string; badge: ReactNode }> = {
@@ -56,6 +57,10 @@ export function ExchangeDrawer({ x }: { x: ExchangeRow }) {
   const stages = journeyStages(x);
   const canOperate = useSessionCan("exchanges.operate");
   const queryClient = useQueryClient();
+  // An aggregation's exchange is the roll-up — its payload is the list of links to
+  // everything it collected, so it is the one exchange worth offering that drill from.
+  const isRollUp =
+    useSubscriptionsCache().data?.find((i) => i.id === x.subscriptionId)?.type === "Aggregation";
 
   const files: Record<ExchangeDocStage, ExchangeRow["files"]["input"]> = {
     Input: x.files.input,
@@ -223,6 +228,20 @@ export function ExchangeDrawer({ x }: { x: ExchangeRow }) {
             </Link>
           </MetaItem>
         )}
+        {isRollUp && (
+          <MetaItem label="Rolled up">
+            {/* The Id filter matches AggregationXchangeId as well as Id, so this one
+                link is already the list of everything collected into this exchange —
+                what was missing was anything saying so from the roll-up's own side. */}
+            <Link
+              to={`/exchanges?ids=${encodeURIComponent(x.id)}`}
+              title="Every exchange rolled up into this one, listed beside it."
+              className="text-[13px] font-medium text-ink-700 hover:text-crimson-700 hover:underline"
+            >
+              The exchanges this collected
+            </Link>
+          </MetaItem>
+        )}
         {x.aggregationXchangeId && (
           <MetaItem label="Aggregated into">
             <Link
diff --git a/SW.Bitween.Web/ClientApp/src/pages/global-values/GlobalValueSetsPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/global-values/GlobalValueSetsPage.tsx
index b770ea3..d6f0fa7 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/global-values/GlobalValueSetsPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/global-values/GlobalValueSetsPage.tsx
@@ -4,6 +4,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { Plus, Search, SlidersHorizontal } from "lucide-react";
 import { api, referencesGlobal } from "../../api";
 import { Can } from "../../auth/guards";
+import { SubscriptionMultiFilter } from "../../components/config/SubscriptionMultiFilter";
 import { PageHeader } from "../../components/layout/PageHeader";
 import { Button, EmptyState, FormError, LoadingBlock } from "../../components/ui/basics";
 import { Field, TextInput } from "../../components/ui/forms";
@@ -77,10 +78,20 @@ function CreateValueSetDialog({ onClose }: { onClose: () => void }) {
   );
 }
 
+/** ?subscriptions=3,5 — no id can be 0, so filter/join round-trip cleanly through this. */
+const parseIds = (raw: string | null): number[] =>
+  raw
+    ? raw
+        .split(",")
+        .map(Number)
+        .filter((n) => Number.isInteger(n) && n > 0)
+    : [];
+
 export function GlobalValueSetsPage() {
   const [searchParams, setSearchParams] = useSearchParams();
   const navigate = useNavigate();
   const q = searchParams.get("q") ?? "";
+  const subscriptionIds = parseIds(searchParams.get("subscriptions"));
   const creating = searchParams.get("new") === "1";
 
   const sets = useQuery({ queryKey: ["value-sets"], queryFn: () => api.listValueSets() });
@@ -99,10 +110,13 @@ export function GlobalValueSetsPage() {
 
   const filtered = useMemo(() => {
     const needle = q.trim().toLowerCase();
-    return (sets.data ?? []).filter(
-      (s) => !needle || s.name.toLowerCase().includes(needle) || s.id.includes(needle),
-    );
-  }, [sets.data, q]);
+    const wantedSubscriptions = subscriptions.filter((i) => subscriptionIds.includes(i.id));
+    return (sets.data ?? []).filter((s) => {
+      if (needle && !s.name.toLowerCase().includes(needle) && !s.id.includes(needle)) return false;
+      if (subscriptionIds.length > 0 && !wantedSubscriptions.some((i) => referencesGlobal(i, s.id))) return false;
+      return true;
+    });
+  }, [sets.data, q, subscriptionIds, subscriptions]);
 
   return (
     <div>
@@ -118,23 +132,38 @@ export function GlobalValueSetsPage() {
         }
       />
 
-      <div className="relative mb-4 max-w-xs">
-        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
-        <input
-          type="search"
-          value={q}
-          onChange={(e) => setParam("q", e.target.value || null)}
-          placeholder="Search value sets"
-          aria-label="Search value sets"
-          className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
-        />
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search value sets"
+            aria-label="Search value sets"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-60">
+          <SubscriptionMultiFilter
+            subscriptions={subscriptions}
+            selected={subscriptionIds}
+            onChange={(ids) => setParam("subscriptions", ids.length ? ids.join(",") : null)}
+            label="Filter by subscription"
+          />
+        </div>
       </div>
 
       {sets.isPending ? (
         <LoadingBlock label="Loading value sets…" />
       ) : filtered.length === 0 ? (
-        <EmptyState icon={<SlidersHorizontal />} title={q ? "No value sets match" : "No value sets yet"}>
-          {q ? "Try a different search." : "Create a set of shared values your adapters can reference."}
+        <EmptyState
+          icon={<SlidersHorizontal />}
+          title={q || subscriptionIds.length > 0 ? "No value sets match" : "No value sets yet"}
+        >
+          {q || subscriptionIds.length > 0
+            ? "Try a different search or filter."
+            : "Create a set of shared values your adapters can reference."}
         </EmptyState>
       ) : (
         <Table
diff --git a/SW.Bitween.Web/ClientApp/src/pages/information-types/InformationTypesPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/information-types/InformationTypesPage.tsx
index 2c9e608..2958e84 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/information-types/InformationTypesPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/information-types/InformationTypesPage.tsx
@@ -1,12 +1,14 @@
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { useNavigate, useSearchParams } from "react-router";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
 import { FileText, Plus, Search } from "lucide-react";
 import { api } from "../../api";
 import { Can } from "../../auth/guards";
 import { InformationTypeDialog } from "../../components/config/InformationTypeDialog";
+import { SubscriptionMultiFilter } from "../../components/config/SubscriptionMultiFilter";
 import { PageHeader } from "../../components/layout/PageHeader";
 import { Badge, Button, EmptyState, LoadingBlock } from "../../components/ui/basics";
+import { Select } from "../../components/ui/forms";
 import { CodeBadge } from "../../components/ui/Panel";
 import { Pagination } from "../../components/ui/Pagination";
 import { Table } from "../../components/ui/Table";
@@ -14,19 +16,57 @@ import { UsedByCell, useSubscriptionsCache } from "../../components/config/share
 
 const PAGE_SIZE = 25;
 
+const FORMAT_OPTIONS = [
+  { value: "", label: "Any format" },
+  { value: "Json", label: "JSON" },
+  { value: "Xml", label: "XML" },
+];
+
+const BUS_OPTIONS = [
+  { value: "", label: "Any bus status" },
+  { value: "true", label: "On the bus" },
+  { value: "false", label: "Not on the bus" },
+];
+
+/** ?subscriptions=3,5 — no id can be 0, so filter/join round-trip cleanly through this. */
+const parseIds = (raw: string | null): number[] =>
+  raw
+    ? raw
+        .split(",")
+        .map(Number)
+        .filter((n) => Number.isInteger(n) && n > 0)
+    : [];
+
 export function InformationTypesPage() {
   const [searchParams, setSearchParams] = useSearchParams();
   const navigate = useNavigate();
   const [creating, setCreating] = useState(false);
   const q = searchParams.get("q") ?? "";
+  const format = searchParams.get("format") as "Json" | "Xml" | null;
+  const busParam = searchParams.get("bus");
+  const busEnabled = busParam === "true" ? true : busParam === "false" ? false : null;
+  const subscriptionIds = parseIds(searchParams.get("subscriptions"));
   const offset = searchParams.get("offset") ? Number(searchParams.get("offset")) : 0;
 
-  const types = useQuery({
-    queryKey: ["information-types-search", q, offset],
-    queryFn: () => api.searchInformationTypes({ search: q, offset, limit: PAGE_SIZE }),
+  const subscriptions = useSubscriptionsCache().data ?? [];
+
+  // The backend's Search endpoint has no "id is in this set" filter, so filtering by
+  // which subscriptions use a type can't be pushed down like name/format/bus can. Falls
+  // back to the full list, filtered and paged client-side, only while that filter is
+  // active — same trade-off as the Partners and Global values pages.
+  const filtering = subscriptionIds.length > 0;
+
+  const serverSearch = useQuery({
+    queryKey: ["information-types-search", q, format, busEnabled, offset],
+    queryFn: () => api.searchInformationTypes({ search: q, format, busEnabled, offset, limit: PAGE_SIZE }),
     placeholderData: keepPreviousData,
+    enabled: !filtering,
+  });
+  const allTypes = useQuery({
+    queryKey: ["information-types-all"],
+    queryFn: () => api.listInformationTypes(),
+    enabled: filtering,
   });
-  const subscriptions = useSubscriptionsCache().data ?? [];
 
   const setParam = (key: string, value: string | null, resetOffset = true) =>
     setSearchParams(
@@ -40,8 +80,22 @@ export function InformationTypesPage() {
       { replace: key === "q" },
     );
 
-  const rows = types.data?.result ?? [];
-  const total = types.data?.total ?? 0;
+  const filteredSorted = useMemo(() => {
+    if (!filtering) return [];
+    const needle = q.trim().toLowerCase();
+    const wanted = new Set(subscriptionIds);
+    return (allTypes.data ?? []).filter((t) => {
+      if (needle && !t.name.toLowerCase().includes(needle)) return false;
+      if (format && t.format !== format) return false;
+      if (busEnabled !== null && t.busEnabled !== busEnabled) return false;
+      const usedBy = subscriptions.filter((s) => s.informationTypeId === t.id);
+      return usedBy.some((s) => wanted.has(s.id));
+    });
+  }, [filtering, allTypes.data, q, format, busEnabled, subscriptionIds, subscriptions]);
+
+  const isPending = filtering ? allTypes.isPending : serverSearch.isPending;
+  const rows = filtering ? filteredSorted.slice(offset, offset + PAGE_SIZE) : (serverSearch.data?.result ?? []);
+  const total = filtering ? filteredSorted.length : (serverSearch.data?.total ?? 0);
 
   return (
     <div>
@@ -74,23 +128,56 @@ export function InformationTypesPage() {
         }
       />
 
-      <div className="relative mb-4 max-w-xs">
-        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
-        <input
-          type="search"
-          value={q}
-          onChange={(e) => setParam("q", e.target.value || null)}
-          placeholder="Search by name"
-          aria-label="Search information types"
-          className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
-        />
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search by name"
+            aria-label="Search information types"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-36">
+          <Select
+            aria-label="Filter by format"
+            className="!h-8 text-[13px]"
+            value={format ?? ""}
+            onChange={(e) => setParam("format", e.target.value || null)}
+            options={FORMAT_OPTIONS}
+          />
+        </div>
+        <div className="w-44">
+          <Select
+            aria-label="Filter by bus status"
+            className="!h-8 text-[13px]"
+            value={busParam ?? ""}
+            onChange={(e) => setParam("bus", e.target.value || null)}
+            options={BUS_OPTIONS}
+          />
+        </div>
+        <div className="w-60">
+          <SubscriptionMultiFilter
+            subscriptions={subscriptions}
+            selected={subscriptionIds}
+            onChange={(ids) => setParam("subscriptions", ids.length ? ids.join(",") : null)}
+            label="Filter by subscription"
+          />
+        </div>
       </div>
 
-      {types.isPending ? (
+      {isPending ? (
         <LoadingBlock label="Loading information types…" />
       ) : rows.length === 0 ? (
-        <EmptyState icon={<FileText />} title={q ? "No information types match" : "No information types yet"}>
-          {q ? "Try a different search." : "Define the first kind of document your subscriptions will carry."}
+        <EmptyState
+          icon={<FileText />}
+          title={q || format || busParam || subscriptionIds.length > 0 ? "No information types match" : "No information types yet"}
+        >
+          {q || format || busParam || subscriptionIds.length > 0
+            ? "Try a different search or filter."
+            : "Define the first kind of document your subscriptions will carry."}
         </EmptyState>
       ) : (
         <Table
diff --git a/SW.Bitween.Web/ClientApp/src/pages/partners/PartnersPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/partners/PartnersPage.tsx
index 274901d..1e053ff 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/partners/PartnersPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/partners/PartnersPage.tsx
@@ -1,32 +1,36 @@
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { useNavigate, useSearchParams } from "react-router";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
 import { Handshake, Plus, Search } from "lucide-react";
 import { api } from "../../api";
 import { Can } from "../../auth/guards";
+import { SubscriptionMultiFilter } from "../../components/config/SubscriptionMultiFilter";
 import { PartnerDialog } from "../../components/config/PartnerDialog";
 import { PageHeader } from "../../components/layout/PageHeader";
 import { Badge, Button, EmptyState, LoadingBlock } from "../../components/ui/basics";
 import { Pagination } from "../../components/ui/Pagination";
 import { Table } from "../../components/ui/Table";
-import { UsedByCell, usePartnerSubscriptions } from "../../components/config/shared";
+import { UsedByCell, useSubscriptionsCache, usePartnerSubscriptions } from "../../components/config/shared";
 
 const PAGE_SIZE = 25;
 
+/** ?subscriptions=3,5 — no id can be 0, so filter/join round-trip cleanly through this. */
+const parseIds = (raw: string | null): number[] =>
+  raw
+    ? raw
+        .split(",")
+        .map(Number)
+        .filter((n) => Number.isInteger(n) && n > 0)
+    : [];
+
 export function PartnersPage() {
   const [searchParams, setSearchParams] = useSearchParams();
   const navigate = useNavigate();
   const [creating, setCreating] = useState(false);
   const q = searchParams.get("q") ?? "";
+  const subscriptionIds = parseIds(searchParams.get("subscriptions"));
   const offset = searchParams.get("offset") ? Number(searchParams.get("offset")) : 0;
 
-  const partners = useQuery({
-    queryKey: ["partners-search", q, offset],
-    queryFn: () => api.searchPartners({ search: q, offset, limit: PAGE_SIZE }),
-    placeholderData: keepPreviousData,
-  });
-  const partnerSubscriptions = usePartnerSubscriptions();
-
   const setParam = (key: string, value: string | null, resetOffset = true) =>
     setSearchParams(
       (prev) => {
@@ -39,8 +43,44 @@ export function PartnersPage() {
       { replace: key === "q" },
     );
 
-  const rows = partners.data?.result ?? [];
-  const total = partners.data?.total ?? 0;
+  const partnerSubscriptions = usePartnerSubscriptions();
+  const subscriptions = useSubscriptionsCache().data ?? [];
+
+  // The backend's Search endpoint has no "id is in this set" filter, so filtering by
+  // which subscriptions a partner is wired to can't be pushed down like the name search
+  // can. Every partner is already loaded once for `usePartnerSubscriptions` above, so
+  // reusing the same full list here — and paging it client-side — costs nothing extra
+  // and stays correct across pages. The plain search case keeps the server-paged path,
+  // since that's the one that has to scale.
+  const filtering = subscriptionIds.length > 0;
+
+  const serverSearch = useQuery({
+    queryKey: ["partners-search", q, offset],
+    queryFn: () => api.searchPartners({ search: q, offset, limit: PAGE_SIZE }),
+    placeholderData: keepPreviousData,
+    enabled: !filtering,
+  });
+  const allPartners = useQuery({
+    queryKey: ["partners-all"],
+    queryFn: () => api.listPartners(),
+    enabled: filtering,
+  });
+
+  const filteredSorted = useMemo(() => {
+    if (!filtering) return [];
+    const needle = q.trim().toLowerCase();
+    const wanted = new Set(subscriptionIds);
+    return (allPartners.data ?? []).filter((p) => {
+      if (needle && !p.name.toLowerCase().includes(needle)) return false;
+      const usedBy = partnerSubscriptions.get(p.id) ?? [];
+      return usedBy.some((i) => wanted.has(i.id));
+    });
+  }, [filtering, allPartners.data, partnerSubscriptions, q, subscriptionIds]);
+
+  const isPending = filtering ? allPartners.isPending : serverSearch.isPending;
+  const rows = filtering ? filteredSorted.slice(offset, offset + PAGE_SIZE) : (serverSearch.data?.result ?? []);
+  const total = filtering ? filteredSorted.length : (serverSearch.data?.total ?? 0);
+  const filtered = q || subscriptionIds.length > 0;
 
   return (
     <div>
@@ -56,23 +96,33 @@ export function PartnersPage() {
         }
       />
 
-      <div className="relative mb-4 max-w-xs">
-        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
-        <input
-          type="search"
-          value={q}
-          onChange={(e) => setParam("q", e.target.value || null)}
-          placeholder="Search partners"
-          aria-label="Search partners"
-          className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
-        />
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search partners"
+            aria-label="Search partners"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-60">
+          <SubscriptionMultiFilter
+            subscriptions={subscriptions}
+            selected={subscriptionIds}
+            onChange={(ids) => setParam("subscriptions", ids.length ? ids.join(",") : null)}
+            label="Filter by subscription"
+          />
+        </div>
       </div>
 
-      {partners.isPending ? (
+      {isPending ? (
         <LoadingBlock label="Loading partners…" />
       ) : rows.length === 0 ? (
-        <EmptyState icon={<Handshake />} title={q ? "No partners match" : "No partners yet"}>
-          {q ? "Try a different search." : "Create the first partner you exchange data with."}
+        <EmptyState icon={<Handshake />} title={filtered ? "No partners match" : "No partners yet"}>
+          {filtered ? "Try a different search or filter." : "Create the first partner you exchange data with."}
         </EmptyState>
       ) : (
         <Table
diff --git a/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/NewScheduledJobPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/NewScheduledJobPage.tsx
index 0644a73..5c79518 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/NewScheduledJobPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/NewScheduledJobPage.tsx
@@ -113,6 +113,8 @@ export function NewScheduledJobPage() {
   // set yet are simply empty.
   const studioDraft: StudioDraft = {
     ...draft,
+    // Aggregation only, and this page never creates one.
+    aggregationTarget: "Input",
     enabled: draft.enable,
     workGroupId: null,
     retryPolicyId: null,
diff --git a/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/ScheduledJobsPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/ScheduledJobsPage.tsx
index abf0bae..76d24af 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/ScheduledJobsPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/scheduled-jobs/ScheduledJobsPage.tsx
@@ -7,6 +7,7 @@ import { Can, useSessionCan } from "../../auth/guards";
 import { PageHeader } from "../../components/layout/PageHeader";
 import { Badge, Button, EmptyState, LoadingBlock } from "../../components/ui/basics";
 import { ConfirmDialog } from "../../components/ui/overlays";
+import { Select } from "../../components/ui/forms";
 import { Pagination } from "../../components/ui/Pagination";
 import { Table } from "../../components/ui/Table";
 import {
@@ -65,6 +66,12 @@ function ReceiveNowButton({ job }: { job: SubscriptionRow }) {
  * means the job is not going to run, while Status still reads "Active" — so it
  * outranks the ordinary badges rather than sitting beside them.
  */
+const STATUS_OPTIONS = [
+  { value: "", label: "Any status" },
+  { value: "false", label: "Active" },
+  { value: "true", label: "Disabled" },
+];
+
 function ScheduleFault({ health }: { health: ScheduleHealth | undefined }) {
   const fault = scheduleFault(health);
   if (!fault) return null;
@@ -89,13 +96,16 @@ export function ScheduledJobsPage() {
   const [searchParams, setSearchParams] = useSearchParams();
   const navigate = useNavigate();
   const q = searchParams.get("q") ?? "";
+  const inactiveParam = searchParams.get("inactive");
+  const inactive = inactiveParam === "true" ? true : inactiveParam === "false" ? false : null;
   const offset = searchParams.get("offset") ? Number(searchParams.get("offset")) : 0;
   const canOperate = useSessionCan("subscriptions.operate");
   const canSeeInfoTypes = useSessionCan("documents.view");
 
   const rows = useQuery({
-    queryKey: ["subscription-rows-search", "Receiving", q, offset],
-    queryFn: () => api.searchSubscriptionRows({ search: q, type: "Receiving", offset, limit: PAGE_SIZE }),
+    queryKey: ["subscription-rows-search", "Receiving", q, inactive, offset],
+    queryFn: () =>
+      api.searchSubscriptionRows({ search: q, type: "Receiving", inactive, offset, limit: PAGE_SIZE }),
     placeholderData: keepPreviousData,
   });
   // The list rows don't carry work group or retry policy; the subscriptions
@@ -140,23 +150,34 @@ export function ScheduledJobsPage() {
         }
       />
 
-      <div className="relative mb-4 max-w-xs">
-        <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
-        <input
-          type="search"
-          value={q}
-          onChange={(e) => setParam("q", e.target.value || null)}
-          placeholder="Search jobs"
-          aria-label="Search scheduled jobs"
-          className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
-        />
+      <div className="mb-4 flex flex-wrap items-center gap-2">
+        <div className="relative w-full max-w-xs">
+          <Search className="pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-ink-400" />
+          <input
+            type="search"
+            value={q}
+            onChange={(e) => setParam("q", e.target.value || null)}
+            placeholder="Search jobs"
+            aria-label="Search scheduled jobs"
+            className="h-9 w-full rounded-lg border border-ink-200 bg-white pr-3 pl-9 text-sm placeholder:text-ink-400 focus:border-crimson-400 focus:ring-2 focus:ring-crimson-100 focus:outline-none"
+          />
+        </div>
+        <div className="w-40">
+          <Select
+            aria-label="Filter by status"
+            className="!h-8 text-[13px]"
+            value={inactiveParam ?? ""}
+            onChange={(e) => setParam("inactive", e.target.value || null)}
+            options={STATUS_OPTIONS}
+          />
+        </div>
       </div>
 
       {rows.isPending ? (
         <LoadingBlock label="Loading scheduled jobs…" />
       ) : filtered.length === 0 ? (
-        <EmptyState icon={<CalendarClock />} title={q ? "No jobs match" : "No scheduled jobs yet"}>
-          {q ? "Try a different search." : "Create a job to pull documents in on a schedule."}
+        <EmptyState icon={<CalendarClock />} title={q || inactive !== null ? "No jobs match" : "No scheduled jobs yet"}>
+          {q || inactive !== null ? "Try a different search or filter." : "Create a job to pull documents in on a schedule."}
         </EmptyState>
       ) : (
         <Table
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/SubscriptionPage.tsx b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/SubscriptionPage.tsx
index a997178..81b21ac 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/SubscriptionPage.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/SubscriptionPage.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useState } from "react";
 import { Link, useNavigate, useParams, useSearchParams } from "react-router";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { DownloadCloud, Pause, Play, Trash2, X } from "lucide-react";
+import { DownloadCloud, FileStack, Pause, Play, Trash2, X } from "lucide-react";
 import { api } from "../../api";
 import { Can, useSessionCan } from "../../auth/guards";
 import { Badge, Button, EmptyState, FormError, LoadingBlock } from "../../components/ui/basics";
@@ -10,6 +10,7 @@ import { CodeBadge, EditableTitle, Panel, UnsavedBar } from "../../components/ui
 import { AdapterConfig, useAdapterCatalog } from "../../components/config/AdapterConfig";
 import { MatchExpressionEditor } from "../../components/config/MatchExpressionEditor";
 import { ScheduleEditor } from "../../components/config/ScheduleEditor";
+import { AggregationFields } from "../../components/config/AggregationFields";
 import { TypeBadge, scheduleFault, useSubscriptionsCache } from "../../components/config/shared";
 import { STAGES, stagesFor, type StageId } from "./studio/stages";
 import { StageRail } from "./studio/StageRail";
@@ -61,6 +62,7 @@ export function SubscriptionPage() {
   const [deleting, setDeleting] = useState(false);
   const [confirmingPause, setConfirmingPause] = useState(false);
   const [confirmingReceive, setConfirmingReceive] = useState(false);
+  const [confirmingAggregate, setConfirmingAggregate] = useState(false);
   const [loaded, setLoaded] = useState(false);
 
   useEffect(() => {
@@ -126,6 +128,15 @@ export function SubscriptionPage() {
     onSuccess: invalidate,
   });
 
+  const aggregate = useMutation({
+    mutationFn: () => api.aggregateNow(subscriptionId),
+    onSuccess: async () => {
+      await invalidate();
+      void queryClient.invalidateQueries({ queryKey: ["subscription-runs", subscriptionId] });
+      void queryClient.invalidateQueries({ queryKey: ["last-runs"] });
+    },
+  });
+
   const receive = useMutation({
     mutationFn: () => api.receiveNow(subscriptionId),
     onSuccess: async () => {
@@ -153,6 +164,8 @@ export function SubscriptionPage() {
   const isInternal = s.type === "Internal";
   const isApiCall = s.type === "ApiCall";
   const isAggregation = s.type === "Aggregation";
+  const aggregationSource =
+    allSubscriptions.data?.find((x) => x.id === s.aggregationForId) ?? null;
   const paused = s.pausedOn !== null;
   const entryPoints = entryPointsOf(s);
 
@@ -185,8 +198,13 @@ export function SubscriptionPage() {
       catalogs: { receivers, validators, mappers, handlers },
       entryPoints,
       nextRunOn: s.nextReceiveOn,
-      fault: id === "schedule" || id === "aggregation" ? fault : undefined,
+      // The fault belongs to the Schedule node now that aggregations have one. It used
+      // to be pinned to the aggregation node too, which was the only node they had —
+      // and that node could not be edited, so the page reported a broken schedule and
+      // offered no way to fix it.
+      fault: id === "schedule" ? fault : undefined,
       subscriptionNames: allSubscriptions.data,
+      aggregationForId: s.aggregationForId,
     }),
   );
 
@@ -231,7 +249,12 @@ export function SubscriptionPage() {
         );
       case "schedule":
         return (
-          <Panel title={label} description={description}>
+          <Panel
+            title={label}
+            description={
+              isAggregation ? "When the source's exchanges are rolled up." : description
+            }
+          >
             <ScheduleEditor
               schedules={draft.schedules}
               onChange={(schedules) => set("schedules", schedules)}
@@ -242,10 +265,12 @@ export function SubscriptionPage() {
       case "aggregation":
         return (
           <Panel title={label} description={description}>
-            <p className="text-sm text-ink-500">
-              Aggregation settings aren't editable in the new UI yet — they arrive in a later phase.
-              Everything else on this page works as usual.
-            </p>
+            <AggregationFields
+              source={aggregationSource}
+              target={draft.aggregationTarget}
+              onTargetChange={(aggregationTarget) => set("aggregationTarget", aggregationTarget)}
+              disabled={!canEdit}
+            />
           </Panel>
         );
       case "validation":
@@ -357,6 +382,36 @@ export function SubscriptionPage() {
                 <DownloadCloud className="size-4" /> Receive now
               </Button>
             )}
+            {isAggregation && canOperate && (
+              <Button
+                onClick={() => setConfirmingAggregate(true)}
+                // AggregationJob returns immediately for a disabled subscription, so the
+                // button would appear to work and record nothing at all. The list page
+                // already refuses for the same reason; these two must agree.
+                disabled={!s.enabled}
+                title={
+                  s.enabled
+                    ? "Collect everything outstanding immediately and run the delivery, without waiting for the schedule."
+                    : "Enable the aggregation first — a disabled one never runs, even when triggered by hand."
+                }
+              >
+                <Play className="size-4" /> Roll up now
+              </Button>
+            )}
+            {/* Creating the aggregation from here rather than from a type picker: the
+                thing being rolled up is the page you are standing on, so it can never
+                be the wrong one. Not offered on an aggregation — roll-ups of roll-ups
+                are not a shape anyone has asked for, and the picker refuses them too. */}
+            {!isAggregation && (
+              <Can permission="subscriptions.create">
+                <Button
+                  onClick={() => navigate(`/aggregations/new?source=${s.id}`)}
+                  title="Create an aggregation that collects this subscription's exchanges on a schedule into one summary exchange."
+                >
+                  <FileStack className="size-4" /> Roll these up
+                </Button>
+              </Can>
+            )}
             {canOperate && (
               <Button
                 onClick={() => setConfirmingPause(true)}
@@ -372,7 +427,7 @@ export function SubscriptionPage() {
               </Button>
             </Can>
           </div>
-          <FormError>{receive.error?.message}</FormError>
+          <FormError>{receive.error?.message ?? aggregate.error?.message}</FormError>
         </div>
       </div>
 
@@ -444,6 +499,18 @@ export function SubscriptionPage() {
         />
       )}
 
+      {confirmingAggregate && (
+        <ConfirmDialog
+          title="Roll up now?"
+          body={`${s.name} collects everything outstanding immediately and runs its delivery — outside the regular schedule.`}
+          confirmLabel="Roll up now"
+          onConfirm={async () => {
+            await aggregate.mutateAsync();
+          }}
+          onClose={() => setConfirmingAggregate(false)}
+        />
+      )}
+
       {deleting && (
         <ConfirmDialog
           title="Delete this subscription?"
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/Overview.tsx b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/Overview.tsx
index 62e6d1f..db43d7e 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/Overview.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/Overview.tsx
@@ -10,7 +10,7 @@ import { Panel } from "../../../components/ui/Panel";
 import { ExchangesList, HealthBadge, TrailTable } from "../../../components/config/shared";
 import { WorkGroupDialog } from "../../../components/config/WorkGroupDialog";
 import { formatDate, formatDateTime, formatDurationMs, timeAgo, timeUntil } from "../../../lib/dates";
-import { ReceiveAttemptsPanel } from "./ReceiveAttemptsPanel";
+import { ReceiveAttemptsPanel, type AttemptKind } from "./ReceiveAttemptsPanel";
 import { RetryBudget } from "./RetryBudget";
 import type { Draft, EntryPoint } from "./model";
 
@@ -175,20 +175,24 @@ export function Overview({
     staleTime: Infinity,
   });
   const retryPolicies = useQuery({ queryKey: ["retry-policies"], queryFn: () => api.listRetryPolicies() });
-  // Receiving gets its own attempt history (ReceiveAttemptsPanel) instead — the scheduler's
-  // run history there is Quartz vocabulary an operator has no reason to know, and it always
-  // reports success even when the receive step itself failed (see ReceivingJob).
+  // Both scheduled types keep their own attempt history and show it in one table
+  // (ReceiveAttemptsPanel) instead of the scheduler's run history beside a separate exchange
+  // list. The scheduler's history is Quartz vocabulary an operator has no reason to know, it
+  // always reports success even when the job's own step failed, and — the reason two tables
+  // were worse than one — nothing joins a run to the exchange it produced.
   const receiving = s.type === "Receiving";
+  const aggregation = s.type === "Aggregation";
+  const attemptKind: AttemptKind | null = receiving ? "receiving" : aggregation ? "aggregation" : null;
   const runs = useQuery({
     queryKey: ["subscription-runs", s.id],
     queryFn: () => api.listSubscriptionRuns(s.id, 20),
-    enabled: scheduled && !receiving,
+    enabled: scheduled && attemptKind === null,
   });
   // Just for the "Last run" fact above — ReceiveAttemptsPanel fetches its own page.
   const latestAttempt = useQuery({
     queryKey: ["receive-attempts", s.id, null, 0, 1],
     queryFn: () => api.searchReceiveAttempts(s.id, { outcome: null, offset: 0, limit: 1 }),
-    enabled: receiving,
+    enabled: attemptKind !== null,
   });
   const lastReceiveRun: SubscriptionRun | undefined = ((): SubscriptionRun | undefined => {
     const a = latestAttempt.data?.result[0];
@@ -220,7 +224,7 @@ export function Overview({
           <>
             <Fact label="Next run">{s.nextReceiveOn ? timeUntil(s.nextReceiveOn) : "—"}</Fact>
             <Fact label="Last run">
-              <LastRunFact run={receiving ? lastReceiveRun : runs.data?.[0]} />
+              <LastRunFact run={attemptKind !== null ? lastReceiveRun : runs.data?.[0]} />
             </Fact>
           </>
         )}
@@ -295,9 +299,9 @@ export function Overview({
           on resume.
         </p>
       )}
-      {/* Receiving gets this per-attempt instead, in ReceiveAttemptsPanel below — showing
-          it again here duplicated the same error twice on one page. */}
-      {s.lastException && !receiving && (
+      {/* The scheduled types get this per-attempt instead, in ReceiveAttemptsPanel below —
+          showing it again here duplicated the same error twice on one page. */}
+      {s.lastException && attemptKind === null && (
         <pre className="max-h-40 overflow-auto rounded-xl border border-danger-200 bg-danger-50 px-4 py-3 font-mono text-[11px] leading-relaxed whitespace-pre-wrap text-danger-800">
           {s.lastException}
         </pre>
@@ -311,15 +315,15 @@ export function Overview({
         />
       )}
 
-      {receiving && (
+      {attemptKind !== null && (
         <Can permission="exchanges.view">
-          <ReceiveAttemptsPanel subscriptionId={s.id} />
+          <ReceiveAttemptsPanel subscriptionId={s.id} kind={attemptKind} />
         </Can>
       )}
 
       <div className="grid gap-5 lg:grid-cols-2">
         <div className="min-w-0 space-y-5">
-          {scheduled && !receiving && (
+          {scheduled && attemptKind === null && (
             <Panel title="Recent runs" description="From the scheduler's own history, kept about 30 days.">
               <RunsTable runs={runs.data ?? []} pending={runs.isPending} />
             </Panel>
@@ -333,7 +337,7 @@ export function Overview({
         </div>
 
         <div className="min-w-0 space-y-5">
-          {!receiving && (
+          {attemptKind === null && (
             <Can permission="exchanges.view">
               <Panel title="Recent exchanges" description="Latest traffic through this subscription.">
                 <ExchangesList items={s.recentExchanges} hide={["type", "partner"]} />
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/ReceiveAttemptsPanel.tsx b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/ReceiveAttemptsPanel.tsx
index 4a6d425..2c0ddd3 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/ReceiveAttemptsPanel.tsx
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/ReceiveAttemptsPanel.tsx
@@ -13,12 +13,67 @@ import { formatDateTime, timeAgo } from "../../../lib/dates";
 
 const PAGE_SIZE = 25;
 
-const OUTCOME_OPTIONS: { value: string; label: string }[] = [
-  { value: "", label: "All" },
-  { value: "Failed", label: "Couldn't check" },
-  { value: "NoNewData", label: "Nothing new" },
-  { value: "Received", label: "Received data" },
-];
+/**
+ * Both scheduled types write into the same history, so this panel serves both — but a
+ * receiver "checks for new data" and an aggregation "rolls up what its source produced",
+ * and one set of words cannot honestly describe both. The outcomes underneath are the
+ * same three; only what they mean to a person changes.
+ */
+export type AttemptKind = "receiving" | "aggregation";
+
+const WORDING: Record<
+  AttemptKind,
+  {
+    description: string;
+    empty: string;
+    emptyHint: string;
+    exchangeHeader: string;
+    exchangeHint: string;
+    resultHint: string;
+    failed: string;
+    failedHint: string;
+    nothing: string;
+    nothingHint: string;
+    outcomes: { value: string; label: string }[];
+  }
+> = {
+  receiving: {
+    description: "Every time this subscription checked for new data — what it found, and what happened to it.",
+    empty: "No checks recorded yet",
+    emptyHint: "This subscription hasn't checked for new data since this history started being kept.",
+    exchangeHeader: "Exchange",
+    exchangeHint: "The exchanges this run created, one per document it received.",
+    resultHint: "What the run found when it checked its source.",
+    failed: "Couldn't check",
+    failedHint: "The run could not reach or read its source — no documents were received.",
+    nothing: "Nothing new",
+    nothingHint: "Checked for new data — there was nothing to receive this time.",
+    outcomes: [
+      { value: "", label: "All" },
+      { value: "Failed", label: "Couldn't check" },
+      { value: "NoNewData", label: "Nothing new" },
+      { value: "Received", label: "Received data" },
+    ],
+  },
+  aggregation: {
+    description: "Every time this aggregation ran — whether it had anything to collect, and the exchange it produced.",
+    empty: "No runs recorded yet",
+    emptyHint: "This aggregation hasn't run since this history started being kept.",
+    exchangeHeader: "Roll-up",
+    exchangeHint: "The single exchange this run produced. Opening it also lists everything it collected.",
+    resultHint: "Whether the run found anything outstanding to roll up.",
+    failed: "Couldn't run",
+    failedHint: "The run threw before it finished — nothing was rolled up.",
+    nothing: "Nothing to roll up",
+    nothingHint: "Ran, but the source had no new successful exchanges waiting. No exchange is created for an empty period.",
+    outcomes: [
+      { value: "", label: "All" },
+      { value: "Failed", label: "Couldn't run" },
+      { value: "NoNewData", label: "Nothing to roll up" },
+      { value: "Received", label: "Rolled up" },
+    ],
+  },
+};
 
 function CopyErrorButton({ text }: { text: string }) {
   const [copied, setCopied] = useState(false);
@@ -69,16 +124,27 @@ function ErrorText({ text }: { text: string }) {
   );
 }
 
-function AttemptResult({ attempt }: { attempt: ReceiveAttemptRow }) {
+function AttemptResult({ attempt, kind }: { attempt: ReceiveAttemptRow; kind: AttemptKind }) {
+  const w = WORDING[kind];
   if (attempt.outcome === "Failed")
     return (
       <span className="flex flex-col gap-0.5">
-        <Badge tone="danger">Couldn't check</Badge>
+        <Badge tone="danger" title={w.failedHint}>
+          {w.failed}
+        </Badge>
         {attempt.errorMessage && <ErrorText text={attempt.errorMessage} />}
       </span>
     );
-  if (attempt.outcome === "NoNewData")
-    return <Badge title="Checked for new data — there was nothing to receive this time.">Nothing new</Badge>;
+  if (attempt.outcome === "NoNewData") return <Badge title={w.nothingHint}>{w.nothing}</Badge>;
+  // No count for an aggregation: the attempt holds the one roll-up it made, not the number
+  // of exchanges that went into it — saying "Rolled up 1" would be a plain lie. The link in
+  // the next column opens the roll-up together with everything it collected.
+  if (kind === "aggregation")
+    return (
+      <span className="text-ink-800" title="Collected everything outstanding into one exchange.">
+        Rolled up
+      </span>
+    );
   return (
     <span className="text-ink-800">
       Received {attempt.exchanges.length} item{attempt.exchanges.length === 1 ? "" : "s"}
@@ -113,7 +179,14 @@ function AttemptExchanges({ exchanges }: { exchanges: ReceiveAttemptRow["exchang
  * that couldn't even connect shows up here just as much as one that produced an exchange —
  * "Exchanges" as a title would undersell the rows that have none.
  */
-export function ReceiveAttemptsPanel({ subscriptionId }: { subscriptionId: number }) {
+export function ReceiveAttemptsPanel({
+  subscriptionId,
+  kind,
+}: {
+  subscriptionId: number;
+  kind: AttemptKind;
+}) {
+  const w = WORDING[kind];
   const [outcome, setOutcome] = useState<ReceiveOutcome | null>(null);
   const [offset, setOffset] = useState(0);
 
@@ -131,9 +204,7 @@ export function ReceiveAttemptsPanel({ subscriptionId }: { subscriptionId: numbe
       <div className="mb-3 flex items-start justify-between gap-3">
         <div>
           <h2 className="text-[15px] font-semibold text-ink-900">Runs</h2>
-          <p className="mt-0.5 text-[13px] text-ink-500">
-            Every time this subscription checked for new data — what it found, and what happened to it.
-          </p>
+          <p className="mt-0.5 text-[13px] text-ink-500">{w.description}</p>
         </div>
         <div className="w-44 shrink-0">
           <Select
@@ -144,7 +215,7 @@ export function ReceiveAttemptsPanel({ subscriptionId }: { subscriptionId: numbe
               setOutcome((e.target.value || null) as ReceiveOutcome | null);
               setOffset(0);
             }}
-            options={OUTCOME_OPTIONS}
+            options={w.outcomes}
           />
         </div>
       </div>
@@ -152,10 +223,8 @@ export function ReceiveAttemptsPanel({ subscriptionId }: { subscriptionId: numbe
       {attempts.isPending ? (
         <LoadingBlock label="Loading runs…" />
       ) : rows.length === 0 ? (
-        <EmptyState title={outcome ? "Nothing matches" : "No checks recorded yet"}>
-          {outcome
-            ? "Try a different filter."
-            : "This subscription hasn't checked for new data since this history started being kept."}
+        <EmptyState title={outcome ? "Nothing matches" : w.empty}>
+          {outcome ? "Try a different filter." : w.emptyHint}
         </EmptyState>
       ) : (
         <Table
@@ -168,14 +237,23 @@ export function ReceiveAttemptsPanel({ subscriptionId }: { subscriptionId: numbe
           columns={[
             {
               header: "When",
+              headerTitle: "When the run started. Hover a value for the exact time.",
               cell: (a) => (
                 <span title={formatDateTime(a.startedOn)} className="text-ink-800">
                   {timeAgo(a.startedOn)}
                 </span>
               ),
             },
-            { header: "Result", cell: (a) => <AttemptResult attempt={a} /> },
-            { header: "Exchange", cell: (a) => <AttemptExchanges exchanges={a.exchanges} /> },
+            {
+              header: "Result",
+              headerTitle: w.resultHint,
+              cell: (a) => <AttemptResult attempt={a} kind={kind} />,
+            },
+            {
+              header: w.exchangeHeader,
+              headerTitle: w.exchangeHint,
+              cell: (a) => <AttemptExchanges exchanges={a.exchanges} />,
+            },
           ]}
         />
       )}
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/faces.ts b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/faces.ts
index 419cda4..bc6edaf 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/faces.ts
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/faces.ts
@@ -1,4 +1,5 @@
 import type { AdapterInfo, SubscriptionType } from "../../../api";
+import { AGGREGATION_TARGET_DETAIL } from "../../../components/config/AggregationFields";
 import { schedulesSummary } from "../../../lib/schedules";
 import { formatDateTime } from "../../../lib/dates";
 import type { StageFace } from "./StageRail";
@@ -8,6 +9,7 @@ import { locationHint, stageDirty, type Draft, type EntryPoint } from "./model";
 const labelOf = (catalog: { data: AdapterInfo[] | undefined }, id: string | null) =>
   catalog.data?.find((a) => a.id === id)?.label ?? id;
 
+
 /**
  * Whether a chosen adapter still has a required property empty.
  *
@@ -43,8 +45,10 @@ export interface FaceInput {
   nextRunOn?: string | null;
   /** Only ever set on the Schedule node — see `StageFace.fault`. */
   fault?: StageFace["fault"];
-  /** Names for the "feed the response into" target. */
+  /** Names for the "feed the response into" target, and for the aggregation's source. */
   subscriptionNames?: { id: number; name: string }[];
+  /** Aggregation only: whose exchanges it rolls up. Fixed at creation, so not on the draft. */
+  aggregationForId?: number | null;
   /**
    * Set while the subscription is being defined and nothing is saved yet. A delivery-less
    * subscription that already exists is a legal thing that records and stops; one being
@@ -61,7 +65,8 @@ export interface FaceInput {
  * while editing is how the two drift apart.
  */
 export function faceOf(stageId: StageId, input: FaceInput): StageFace {
-  const { type, draft: d, catalogs, saved, entryPoints = [], nextRunOn, fault, subscriptionNames, unsaved } = input;
+  const { type, draft: d, catalogs, saved, entryPoints = [], nextRunOn, fault, subscriptionNames,
+    aggregationForId, unsaved } = input;
   const dirty = saved ? stageDirty(stageId, d, saved) : false;
 
   switch (stageId) {
@@ -100,8 +105,20 @@ export function faceOf(stageId: StageId, input: FaceInput): StageFace {
         state: d.schedules.length ? "set" : "missing",
         fault,
       };
-    case "aggregation":
-      return { id: stageId, dirty, title: "Not editable yet", state: "none", fault };
+    case "aggregation": {
+      // The source is what the node is *for*, so it is the title even though the only
+      // editable half is which file gets collected — an aggregation without a source is
+      // not a thing the backend will create.
+      const source = subscriptionNames?.find((x) => x.id === aggregationForId)?.name;
+      return {
+        id: stageId,
+        dirty,
+        title: source ?? (aggregationForId === null || aggregationForId === undefined ? "No source" : "Deleted subscription"),
+        detail: AGGREGATION_TARGET_DETAIL[d.aggregationTarget],
+        state: aggregationForId ? "set" : "missing",
+        fault,
+      };
+    }
     case "validation":
       return {
         id: stageId,
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/model.ts b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/model.ts
index f1b4476..58dcfea 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/model.ts
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/model.ts
@@ -20,6 +20,7 @@ export type Draft = Pick<
   | "schedules"
   | "responseSubscriptionId"
   | "responseMessageTypeName"
+  | "aggregationTarget"
 >;
 
 export const draftOf = (d: SubscriptionDetail): Draft => ({
@@ -39,6 +40,7 @@ export const draftOf = (d: SubscriptionDetail): Draft => ({
   schedules: structuredClone(d.schedules),
   responseSubscriptionId: d.responseSubscriptionId,
   responseMessageTypeName: d.responseMessageTypeName,
+  aggregationTarget: d.aggregationTarget,
 });
 
 /**
@@ -66,6 +68,7 @@ export const EMPTY_SUBSCRIPTION: Draft = {
   schedules: [],
   responseSubscriptionId: null,
   responseMessageTypeName: null,
+  aggregationTarget: "Input",
 };
 
 /**
@@ -84,7 +87,7 @@ const STAGE_FIELDS: Record<StageId, (keyof Draft)[]> = {
   trigger: ["matchExpression"],
   source: ["receiverId", "receiverProperties"],
   schedule: ["schedules"],
-  aggregation: [],
+  aggregation: ["aggregationTarget"],
   validation: ["validatorId", "validatorProperties"],
   transformation: ["mapperId", "mapperProperties"],
   delivery: ["handlerId", "handlerProperties"],
diff --git a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/stages.ts b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/stages.ts
index 0098a8a..6965690 100644
--- a/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/stages.ts
+++ b/SW.Bitween.Web/ClientApp/src/pages/subscriptions/studio/stages.ts
@@ -37,7 +37,11 @@ export const STAGES: Record<StageId, { label: string; description: string; icon:
     description: "When the source is checked for new documents.",
     icon: Clock,
   },
-  aggregation: { label: "Aggregation", description: "What this subscription collects.", icon: Layers },
+  aggregation: {
+    label: "Rolls up",
+    description: "Whose exchanges this collects, and which of their files it links to.",
+    icon: Layers,
+  },
   validation: {
     label: "Validation",
     description: "Rejects bad documents before they enter the pipeline.",
@@ -67,16 +71,22 @@ export const STAGES: Record<StageId, { label: string; description: string; icon:
  *   subscriptions submit through `FilterService` and never reach it, so a
  *   validator saved here is stored and never executed. Offering the card would be
  *   offering a setting that does nothing.
- * - **No Transformation or Schedule for Aggregation.** Matches what the page has
- *   always done; aggregation configuration is still a placeholder pending its own
- *   pass, so its one card says so rather than pretending to be editable.
+ * - **No Validation for Aggregation.** Same reason: a roll-up exchange is created by
+ *   `AggregationJob` and published on the bus, never through the partner-key API path
+ *   that runs the validator.
+ *
+ * Aggregation gets Schedule and Transformation like any other pipeline. It used to have
+ * neither — a single "Aggregation" node saying it was not editable — while the schedule
+ * fault badge was pinned to that very node. The page would tell you an aggregation's
+ * schedule was broken and then offer no way to fix it, and the mapper it hid genuinely
+ * runs on the roll-up.
  */
 export function stagesFor(type: SubscriptionType): StageId[] {
   switch (type) {
     case "Receiving":
       return ["source", "schedule", "transformation", "delivery", "response"];
     case "Aggregation":
-      return ["aggregation", "delivery", "response"];
+      return ["aggregation", "schedule", "transformation", "delivery", "response"];
     case "BusGateway":
       return ["trigger", "transformation", "delivery", "response"];
     case "GatewayApiCall":
diff --git a/SW.Bitween.Web/ClientApp/src/router.tsx b/SW.Bitween.Web/ClientApp/src/router.tsx
index 20c86d5..5fe93ac 100644
--- a/SW.Bitween.Web/ClientApp/src/router.tsx
+++ b/SW.Bitween.Web/ClientApp/src/router.tsx
@@ -35,6 +35,8 @@ import { PartnerPage } from "./pages/partners/PartnerPage";
 import { PartnersPage } from "./pages/partners/PartnersPage";
 import { NewScheduledJobPage } from "./pages/scheduled-jobs/NewScheduledJobPage";
 import { ScheduledJobsPage } from "./pages/scheduled-jobs/ScheduledJobsPage";
+import { AggregationsPage } from "./pages/aggregations/AggregationsPage";
+import { NewAggregationPage } from "./pages/aggregations/NewAggregationPage";
 import { RetryPoliciesPage } from "./pages/retry-policies/RetryPoliciesPage";
 import { RetryPolicyPage } from "./pages/retry-policies/RetryPolicyPage";
 import { MembersTab } from "./pages/team/MembersTab";
@@ -215,6 +217,22 @@ export const router = createBrowserRouter([
               </RequirePermission>
             ),
           },
+          {
+            path: "aggregations",
+            element: (
+              <RequirePermission permission="subscriptions.view">
+                <AggregationsPage />
+              </RequirePermission>
+            ),
+          },
+          {
+            path: "aggregations/new",
+            element: (
+              <RequirePermission permission="subscriptions.create">
+                <NewAggregationPage />
+              </RequirePermission>
+            ),
+          },
           {
             path: "api-gateways/new",
             element: (